08a793eb87
Stephan: "attached you'll find some modifications to the GraphicsWindow-class and their platform-dependant implementations. The problem: setWindowRectangle and setWindowDecoration do not update the traits-object, so, if you call setWindowRectangle on a not-realized-window it will open with another size when realized later. getWindowRectangle reports possible wrong sizes if setWindowRectangle called before. My solution: split the implementation in two parts: GraphicsWindow::setWindowRectangle will update its traits-object and call afterwards the virtual method setWindowRectangleImplementation (which is implemented by the derived platformspecific classess). For setWindowDecoration I am useing a similar mechanism. I hope you'll find the submission useful, the Win32 and X11 changes are not tested but should work." Changes to this made by Robert are call of resized in setWindowRectangle instead of setting of Traits, and use of a bool return type.
251 lines
11 KiB
C++
251 lines
11 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
|
|
*
|
|
* This library is open source and may be redistributed and/or modified under
|
|
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
|
* (at your option) any later version. The full license is in LICENSE file
|
|
* included with this distribution, and on the openscenegraph.org website.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* OpenSceneGraph Public License for more details.
|
|
*/
|
|
|
|
#ifndef OSGVIEWER_GRAPHICWINDOW
|
|
#define OSGVIEWER_GRAPHICWINDOW 1
|
|
|
|
#include <osg/GraphicsContext>
|
|
#include <osg/Notify>
|
|
|
|
#include <osgGA/EventQueue>
|
|
#include <osgGA/GUIActionAdapter>
|
|
|
|
#include <osgViewer/Export>
|
|
|
|
extern "C"
|
|
{
|
|
typedef void (* CGraphicsWindowFunction) (void);
|
|
}
|
|
|
|
namespace osgViewer {
|
|
|
|
/** Base class for providing Windowing API agnostic access to creating and managing graphisc window and events.
|
|
* Note, the GraphicsWindow is subclassed from osg::GraphicsContext, and to provide an implemention you'll need to implement its
|
|
* range of pure virtual functions, you'll find these all have naming convention methodNameImplemention(..).
|
|
* GraphicsWindow adds the event queue ontop of the GraphicsContext, thereby adding a mechnism for adapting Windowing events
|
|
* as well as basics graphics context work, you should wire up custom GraphicsWindowImplementation to push their events through
|
|
* into the EventQueue. */
|
|
class OSGVIEWER_EXPORT GraphicsWindow : public osg::GraphicsContext, public osgGA::GUIActionAdapter
|
|
{
|
|
public:
|
|
|
|
GraphicsWindow() { _eventQueue = new osgGA::EventQueue; }
|
|
|
|
|
|
void setEventQueue(osgGA::EventQueue* eventQueue) { _eventQueue = eventQueue; }
|
|
osgGA::EventQueue* getEventQueue() { return _eventQueue.get(); }
|
|
const osgGA::EventQueue* getEventQueue() const { return _eventQueue.get(); }
|
|
|
|
virtual void checkEvents() {}
|
|
|
|
/** Set the window's position and size.*/
|
|
void setWindowRectangle(int x, int y, int width, int height)
|
|
{
|
|
if (setWindowRectangleImplementation(x ,y ,width, height) && _traits.valid())
|
|
{
|
|
resized(x,y,width,height);
|
|
}
|
|
}
|
|
|
|
/** implementation of setWindowRectangle, should be implemented by derived classes */
|
|
virtual bool setWindowRectangleImplementation(int /*x*/, int /*y*/, int /*width*/, int /*height*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::setWindowRectangleImplementation(..) not implemented."<<std::endl; return false; }
|
|
|
|
/** Get the window's position and size.*/
|
|
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; } }
|
|
|
|
/** Set Window decoration.*/
|
|
void setWindowDecoration(bool flag)
|
|
{
|
|
if (setWindowDecorationImplementation(flag) && _traits.valid())
|
|
{
|
|
_traits->windowDecoration = flag;
|
|
}
|
|
}
|
|
|
|
/** implementation of setWindowDecoration, should be implemented by derived classes */
|
|
virtual bool setWindowDecorationImplementation(bool /*flag*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::setWindowDecorationImplementation(..) not implemented."<<std::endl; return false; }
|
|
|
|
|
|
/** Set Window decoration.*/
|
|
virtual bool getWindowDecoration() const { return _traits.valid() ? _traits->windowDecoration : false; }
|
|
|
|
/** Get focus.*/
|
|
virtual void grabFocus() { osg::notify(osg::NOTICE)<<"GraphicsWindow::grabFocus(..) not implemented."<<std::endl; }
|
|
|
|
/** Get focus on if the pointer is in this window.*/
|
|
virtual void grabFocusIfPointerInWindow() { osg::notify(osg::NOTICE)<<"GraphicsWindow::grabFocusIfPointerInWindow(..) not implemented."<<std::endl; }
|
|
|
|
/** Mouse cursor types, the same ones already present with ancient glut ... */
|
|
enum MouseCursor {
|
|
InheritCursor,
|
|
NoCursor,
|
|
RightArrowCursor,
|
|
LeftArrowCursor,
|
|
InfoCursor,
|
|
DestroyCursor,
|
|
HelpCursor,
|
|
CycleCursor,
|
|
SprayCursor,
|
|
WaitCursor,
|
|
TextCursor,
|
|
CrosshairCursor,
|
|
UpDownCursor,
|
|
LeftRightCursor,
|
|
TopSideCursor,
|
|
BottomSideCursor,
|
|
LeftSideCursor,
|
|
RightSideCursor,
|
|
TopLeftCorner,
|
|
TopRightCorner,
|
|
BottomRightCorner,
|
|
BottomLeftCorner
|
|
};
|
|
/** Switch on/off the cursor.*/
|
|
virtual void useCursor(bool cursorOn) { setCursor(cursorOn ? InheritCursor : NoCursor); }
|
|
|
|
/** Set mouse cursor to a specific shape.*/
|
|
virtual void setCursor(MouseCursor /*mouseCursor*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::setCursor(..) not implemented."<<std::endl; }
|
|
|
|
/** Create a new mouse cursor from the usual bitmap data.*/
|
|
//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; }
|
|
|
|
public:
|
|
|
|
/** Return whether a valid and usable GraphicsContext has been created.*/
|
|
virtual bool valid() const { osg::notify(osg::NOTICE)<<"GraphicsWindow::realizeImplementation() not implemented."<<std::endl; return false; }
|
|
|
|
/** Realise the GraphicsContext implementation,
|
|
* Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
|
|
virtual bool realizeImplementation() { osg::notify(osg::NOTICE)<<"GraphicsWindow::realizeImplementation() not implemented."<<std::endl; return false; }
|
|
|
|
/** Return true if the graphics context has been realised, and is ready to use, implementation.
|
|
* Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
|
|
virtual bool isRealizedImplementation() const { osg::notify(osg::NOTICE)<<"GraphicsWindow::isRealizedImplementation() not implemented."<<std::endl; return false; }
|
|
|
|
/** Close the graphics context implementation.
|
|
* Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
|
|
virtual void closeImplementation() { osg::notify(osg::NOTICE)<<"GraphicsWindow::closeImplementation() not implemented."<<std::endl; }
|
|
|
|
/** Make this graphics context current implementation.
|
|
* Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
|
|
virtual bool makeCurrentImplementation() { osg::notify(osg::NOTICE)<<"GraphicsWindow::makeCurrentImplementation() not implemented."<<std::endl; return false;}
|
|
|
|
/** Make this graphics context current with specified read context implementation.
|
|
* Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
|
|
virtual bool makeContextCurrentImplementation(GraphicsContext* /*readContext*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::makeContextCurrentImplementation(..) not implemented."<<std::endl; return false;}
|
|
|
|
/** Release the graphics context.*/
|
|
virtual bool releaseContextImplementation() { osg::notify(osg::NOTICE)<<"GraphicsWindow::releaseContextImplementation(..) not implemented."<<std::endl; return false; }
|
|
|
|
/** Pure virtual, Bind the graphics context to associated texture implementation.
|
|
* Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
|
|
virtual void bindPBufferToTextureImplementation(GLenum /*buffer*/) { osg::notify(osg::NOTICE)<<"GraphicsWindow::bindPBufferToTextureImplementation(..) not implemented."<<std::endl; }
|
|
|
|
/** Swap the front and back buffers implementation.
|
|
* Pure virtual - must be implemented by Concrate implementations of GraphicsContext. */
|
|
virtual void swapBuffersImplementation() { osg::notify(osg::NOTICE)<<"GraphicsWindow:: swapBuffersImplementation() not implemented."<<std::endl; }
|
|
|
|
public:
|
|
|
|
// Override from GUIActionAdapter
|
|
virtual void requestRedraw() {}
|
|
|
|
// Override from GUIActionAdapter
|
|
virtual void requestContinuousUpdate(bool /*needed*/=true) {}
|
|
|
|
// Override from GUIActionAdapter
|
|
virtual void requestWarpPointer(float /*x*/,float /*y*/) {}
|
|
|
|
|
|
protected:
|
|
|
|
osg::ref_ptr<osgGA::EventQueue> _eventQueue;
|
|
|
|
};
|
|
|
|
|
|
class GraphicsWindowEmbedded : public GraphicsWindow
|
|
{
|
|
public:
|
|
|
|
GraphicsWindowEmbedded(osg::GraphicsContext::Traits* traits=0)
|
|
{
|
|
_traits = traits;
|
|
|
|
init();
|
|
|
|
}
|
|
|
|
GraphicsWindowEmbedded(int x, int y, int width, int height)
|
|
{
|
|
_traits = new GraphicsContext::Traits;
|
|
_traits->x = x;
|
|
_traits->y = y;
|
|
_traits->width = width;
|
|
_traits->height = height;
|
|
|
|
init();
|
|
}
|
|
|
|
void init()
|
|
{
|
|
if (valid())
|
|
{
|
|
setState( new osg::State );
|
|
getState()->setGraphicsContext(this);
|
|
|
|
if (_traits.valid() && _traits->sharedContext)
|
|
{
|
|
getState()->setContextID( _traits->sharedContext->getState()->getContextID() );
|
|
incrementContextIDUsageCount( getState()->getContextID() );
|
|
}
|
|
else
|
|
{
|
|
getState()->setContextID( osg::GraphicsContext::createNewContextID() );
|
|
}
|
|
}
|
|
}
|
|
|
|
// dumy implementations, assume that graphics context is *always* current and valid.
|
|
virtual bool valid() const { return true; }
|
|
virtual bool realizeImplementation() { return true; }
|
|
virtual bool isRealizedImplementation() const { return true; }
|
|
virtual void closeImplementation() {}
|
|
virtual bool makeCurrentImplementation() { return true; }
|
|
virtual bool releaseContextImplementation() { return true; }
|
|
virtual void swapBuffersImplementation() {}
|
|
virtual void grabFocus() {}
|
|
virtual void grabFocusIfPointerInWindow() {}
|
|
};
|
|
|
|
struct GrapicsWindowFunctionProxy
|
|
{
|
|
GrapicsWindowFunctionProxy(CGraphicsWindowFunction function) { (function)(); }
|
|
};
|
|
|
|
#define USE_GRAPICSWINDOW_IMPLEMENTATION(ext) \
|
|
extern "C" void graphicswindow_##ext(void); \
|
|
static osgViewer::GrapicsWindowFunctionProxy graphicswindowproxy_##ext(graphicswindow_##ext);
|
|
|
|
#if defined(_WIN32)
|
|
#define USE_GRAPHICSWINDOW() USE_GRAPICSWINDOW_IMPLEMENTATION(Win32)
|
|
#elif defined(__APPLE__)
|
|
#define USE_GRAPHICSWINDOW() USE_GRAPICSWINDOW_IMPLEMENTATION(Carbon)
|
|
#else
|
|
#define USE_GRAPHICSWINDOW() USE_GRAPICSWINDOW_IMPLEMENTATION(X11)
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|