root/OpenSceneGraph/trunk/include/osgViewer/GraphicsWindow @ 13429

Revision 13429, 13.0 kB (checked in by robert, 5 days ago)

Fixed comment

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13
14#ifndef OSGVIEWER_GRAPHICWINDOW
15#define OSGVIEWER_GRAPHICWINDOW 1
16
17#include <osg/GraphicsContext>
18#include <osg/Notify>
19
20#include <osgGA/EventQueue>
21#include <osgGA/GUIActionAdapter>
22
23#include <osgViewer/Export>
24
25
26extern "C"
27{
28    typedef void (* CGraphicsWindowFunction) (void);
29}
30
31namespace osgViewer {
32
33class View;
34
35
36/** Base class for providing Windowing API agnostic access to creating and managing graphics window and events.
37  * Note, the GraphicsWindow is subclassed from osg::GraphicsContext, and to provide an implemention you'll need to implement its
38  * range of pure virtual functions, you'll find these all have naming convention methodNameImplemention(..).
39  * GraphicsWindow adds the event queue on top of the GraphicsContext, thereby adding a mechanism for adapting Windowing events
40  * as well as basics graphics context work, you should wire up custom GraphicsWindowImplementation to push their events through
41  * into the EventQueue. */
42class OSGVIEWER_EXPORT GraphicsWindow : public osg::GraphicsContext, public osgGA::GUIActionAdapter
43{
44    public:
45
46        GraphicsWindow() { _eventQueue = new osgGA::EventQueue; _eventQueue->setGraphicsContext(this); }
47
48        virtual bool isSameKindAs(const Object* object) const { return dynamic_cast<const GraphicsWindow*>(object)!=0; }
49        virtual const char* libraryName() const { return "osgViewer"; }
50        virtual const char* className() const { return "GraphicsWindow"; }
51
52        void setEventQueue(osgGA::EventQueue* eventQueue) { _eventQueue = eventQueue; }
53        osgGA::EventQueue* getEventQueue() { return _eventQueue.get(); }
54        const osgGA::EventQueue* getEventQueue() const { return _eventQueue.get(); }
55
56        /** Check events, return true if events have been received.*/
57        virtual bool checkEvents() { return false; }
58
59        /** Set the window's position and size.*/
60        void setWindowRectangle(int x, int y, int width, int height)
61        {
62            if (setWindowRectangleImplementation(x ,y ,width, height) && _traits.valid())
63            {
64                resized(x,y,width,height);
65            }
66        }
67
68        /** implementation of setWindowRectangle, should be implemented by derived classes */
69        virtual bool setWindowRectangleImplementation(int /*x*/, int /*y*/, int /*width*/, int /*height*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::setWindowRectangleImplementation(..) not implemented."<<std::endl; return false; }
70
71        /** Get the window's position and size.*/
72        virtual void getWindowRectangle(int& x, int& y, int& width, int& height) { if (_traits.valid()) { x = _traits->x; y = _traits->y; width = _traits->width; height = _traits->height; }  }
73
74        /** Set Window decoration.*/
75        void setWindowDecoration(bool flag)
76        {
77            if (setWindowDecorationImplementation(flag) && _traits.valid())
78            {
79                _traits->windowDecoration = flag;
80            }
81        }
82
83        /** implementation of setWindowDecoration, should be implemented by derived classes */
84        virtual bool setWindowDecorationImplementation(bool /*flag*/) {  osg::notify(osg::NOTICE)<<"GraphicsWindow::setWindowDecorationImplementation(..) not implemented."<<std::endl; return false; }
85
86
87        /** Set Window decoration.*/
88        virtual bool getWindowDecoration() const { return _traits.valid() ? _traits->windowDecoration : false; }
89
90        /** Get focus.*/
91        virtual void grabFocus() { osg::notify(osg::NOTICE)<<"GraphicsWindow::grabFocus(..) not implemented."<<std::endl; }
92
93        /** Get focus on if the pointer is in this window.*/
94        virtual void grabFocusIfPointerInWindow() { osg::notify(osg::NOTICE)<<"GraphicsWindow::grabFocusIfPointerInWindow(..) not implemented."<<std::endl; }
95
96        /** Raise the window to the top.*/
97        virtual void raiseWindow() { osg::notify(osg::NOTICE)<<"GraphicsWindow::raiseWindow(..) not implemented."<<std::endl; }
98
99        /** Mouse cursor types, the same ones already present with ancient glut ... */
100        enum MouseCursor {
101            InheritCursor,
102            NoCursor,
103            RightArrowCursor,
104            LeftArrowCursor,
105            InfoCursor,
106            DestroyCursor,
107            HelpCursor,
108            CycleCursor,
109            SprayCursor,
110            WaitCursor,
111            TextCursor,
112            CrosshairCursor,
113            HandCursor,
114            UpDownCursor,
115            LeftRightCursor,
116            TopSideCursor,
117            BottomSideCursor,
118            LeftSideCursor,
119            RightSideCursor,
120            TopLeftCorner,
121            TopRightCorner,
122            BottomRightCorner,
123            BottomLeftCorner
124        };
125
126        /** Set the name of the window */
127        virtual void setWindowName(const std::string& /*name*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::setWindowName(..) not implemented."<<std::endl; }
128
129        /** Return the name of the window */
130        virtual std::string getWindowName() { return _traits.valid() ? _traits->windowName : ""; }
131
132        /** Switch on/off the cursor.*/
133        virtual void useCursor(bool cursorOn) { setCursor(cursorOn ? InheritCursor : NoCursor); }
134
135        /** Set mouse cursor to a specific shape.*/
136        virtual void setCursor(MouseCursor /*mouseCursor*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::setCursor(..) not implemented."<<std::endl; }
137
138        /** Create a new mouse cursor from the usual bitmap data.*/
139        //virtual MouseCursor createCursor(const char *data, const char *mask, unsigned w, unsigned h, unsigned hotx, unsigned hoty) { osg::notify(osg::NOTICE)<<"GraphicsWindow::createCursor(..) not implemented."<<std::endl; }
140
141        /** Set sync-to-vblank. */
142        virtual void setSyncToVBlank(bool on)
143        {
144            osg::notify(osg::NOTICE) << "GraphicsWindow::setSyncToVBlank(" << on << ") not implemented." << std::endl;
145        }
146
147        bool getSyncToVBlank() const { return _traits.valid() ? _traits->vsync : true; }
148
149        /** Set swap group. */
150        virtual void setSwapGroup(bool on, GLuint group, GLuint barrier)
151        {
152            osg::notify(osg::NOTICE) << "GraphicsWindow::setSwapGroup(" << on << " " << group << " " << barrier << ") not implemented." << std::endl;
153        }
154
155        void getSwapGroup(bool& on, GLuint& group, GLuint& barrier) const { on = _traits->swapGroupEnabled; group = _traits->swapGroup; barrier = _traits->swapBarrier; }
156
157    public:
158
159        /** Return whether a valid and usable GraphicsContext has been created.*/
160        virtual bool valid() const { osg::notify(osg::NOTICE)<<"GraphicsWindow::valid() not implemented."<<std::endl; return false; }
161
162        /** Realize the GraphicsContext implementation,
163          * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */
164        virtual bool realizeImplementation() { osg::notify(osg::NOTICE)<<"GraphicsWindow::realizeImplementation() not implemented."<<std::endl; return false; }
165
166        /** Return true if the graphics context has been realized, and is ready to use, implementation.
167          * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */
168        virtual bool isRealizedImplementation() const  { osg::notify(osg::NOTICE)<<"GraphicsWindow::isRealizedImplementation() not implemented."<<std::endl; return false; }
169
170        /** Close the graphics context implementation.
171          * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */
172        virtual void closeImplementation()  { osg::notify(osg::NOTICE)<<"GraphicsWindow::closeImplementation() not implemented."<<std::endl; }
173
174        /** Make this graphics context current implementation.
175          * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */
176        virtual bool makeCurrentImplementation()  { osg::notify(osg::NOTICE)<<"GraphicsWindow::makeCurrentImplementation() not implemented."<<std::endl; return false;}
177
178        /** Make this graphics context current with specified read context implementation.
179          * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */
180        virtual bool makeContextCurrentImplementation(GraphicsContext* /*readContext*/)  { osg::notify(osg::NOTICE)<<"GraphicsWindow::makeContextCurrentImplementation(..) not implemented."<<std::endl; return false;}
181
182        /** Release the graphics context.*/
183        virtual bool releaseContextImplementation() {  osg::notify(osg::NOTICE)<<"GraphicsWindow::releaseContextImplementation(..) not implemented."<<std::endl; return false; }
184
185        /** Pure virtual, Bind the graphics context to associated texture implementation.
186          * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */
187        virtual void bindPBufferToTextureImplementation(GLenum /*buffer*/)  { osg::notify(osg::NOTICE)<<"GraphicsWindow::bindPBufferToTextureImplementation(..) not implemented."<<std::endl; }
188
189        /** Swap the front and back buffers implementation.
190          * Pure virtual - must be implemented by concrete implementations of GraphicsContext. */
191        virtual void swapBuffersImplementation()  { osg::notify(osg::NOTICE)<<"GraphicsWindow:: swapBuffersImplementation() not implemented."<<std::endl; }
192
193    public:
194
195        typedef std::list<osgViewer::View*> Views;
196        /** Returns the list of views (osgViewer::View) attached to this GraphicsWindow.
197         *  Internally, the method walks through all the cameras and collects all the views attached to the cameras.*/
198        void getViews(Views& views);
199
200        // Override from GUIActionAdapter
201        virtual void requestRedraw();
202
203        // Override from GUIActionAdapter
204        virtual void requestContinuousUpdate(bool /*needed*/=true) {}
205
206        // Override from GUIActionAdapter
207        virtual void requestWarpPointer(float /*x*/,float /*y*/) {}
208
209
210    protected:
211
212        osg::ref_ptr<osgGA::EventQueue> _eventQueue;
213
214};
215
216
217class GraphicsWindowEmbedded : public GraphicsWindow
218{
219    public:
220
221        GraphicsWindowEmbedded(osg::GraphicsContext::Traits* traits=0)
222        {
223            _traits = traits;
224
225            init();
226
227        }
228
229        GraphicsWindowEmbedded(int x, int y, int width, int height)
230        {
231            _traits = new GraphicsContext::Traits;
232            _traits->x = x;
233            _traits->y = y;
234            _traits->width = width;
235            _traits->height = height;
236
237            init();
238        }
239
240        virtual bool isSameKindAs(const Object* object) const { return dynamic_cast<const GraphicsWindowEmbedded*>(object)!=0; }
241        virtual const char* libraryName() const { return "osgViewer"; }
242        virtual const char* className() const { return "GraphicsWindowEmbedded"; }
243
244        void init()
245        {
246            if (valid())
247            {
248                setState( new osg::State );
249                getState()->setGraphicsContext(this);
250
251                if (_traits.valid() && _traits->sharedContext.valid())
252                {
253                    getState()->setContextID( _traits->sharedContext->getState()->getContextID() );
254                    incrementContextIDUsageCount( getState()->getContextID() );
255                }
256                else
257                {
258                    getState()->setContextID( osg::GraphicsContext::createNewContextID() );
259                }
260            }
261        }
262
263        // dummy implementations, assume that graphics context is *always* current and valid.
264        virtual bool valid() const { return true; }
265        virtual bool realizeImplementation() { return true; }
266        virtual bool isRealizedImplementation() const  { return true; }
267        virtual void closeImplementation() {}
268        virtual bool makeCurrentImplementation() { return true; }
269        virtual bool releaseContextImplementation() { return true; }
270        virtual void swapBuffersImplementation() {}
271        virtual void grabFocus() {}
272        virtual void grabFocusIfPointerInWindow() {}
273        virtual void raiseWindow() {}
274};
275
276struct GraphicsWindowFunctionProxy
277{
278    GraphicsWindowFunctionProxy(CGraphicsWindowFunction function) { (function)(); }
279};
280
281#define USE_GRAPICSWINDOW_IMPLEMENTATION(ext) \
282    extern "C" void graphicswindow_##ext(void); \
283    static osgViewer::GraphicsWindowFunctionProxy graphicswindowproxy_##ext(graphicswindow_##ext);
284
285#if defined(_WIN32)
286    #define USE_GRAPHICSWINDOW()  USE_GRAPICSWINDOW_IMPLEMENTATION(Win32)
287#elif defined(__APPLE__)
288    #define USE_GRAPHICSWINDOW()  USE_GRAPICSWINDOW_IMPLEMENTATION(Carbon)
289#else
290    #define USE_GRAPHICSWINDOW()  USE_GRAPICSWINDOW_IMPLEMENTATION(X11)
291#endif
292
293}
294
295#endif
Note: See TracBrowser for help on using the browser.