Changeset 9287

Timestamp:

11/28/08 15:35:33 (5 years ago)

Author:

robert

Message:

From Jeremy Moles, updates to osgWidget

Merged my Robert Osfield from OpenSceneGraph-osgWidget-dev.

Location:

OpenSceneGraph/trunk

Files:

• include/osgWidget/Box (modified) (3 diffs)
• include/osgWidget/Browser (copied) (copied from OpenSceneGraph/branches/OpenSceneGraph-osgWidget-dev/include/osgWidget/Browser)
• include/osgWidget/Canvas (modified) (2 diffs)
• include/osgWidget/EventInterface (modified) (8 diffs)
• include/osgWidget/Export (modified) (2 diffs)
• include/osgWidget/Frame (modified) (8 diffs)
• include/osgWidget/Input (modified) (3 diffs)
• include/osgWidget/Label (modified) (2 diffs)
• include/osgWidget/Lua (modified) (1 diff)
• include/osgWidget/Python (modified) (1 diff)
• include/osgWidget/ScriptEngine (modified) (1 diff)
• include/osgWidget/StyleInterface (modified) (1 diff)
• include/osgWidget/StyleManager (modified) (1 diff)
• include/osgWidget/Table (modified) (1 diff)
• include/osgWidget/Types (modified) (2 diffs)
• include/osgWidget/UIObjectParent (modified) (2 diffs)
• include/osgWidget/Util (modified) (2 diffs)
• include/osgWidget/Version (modified) (1 diff)
• include/osgWidget/ViewerEventHandlers (modified) (8 diffs)
• include/osgWidget/Widget (modified) (10 diffs)
• include/osgWidget/Window (modified) (8 diffs)
• include/osgWidget/WindowManager (modified) (6 diffs)
• src/osgWidget/Box.cpp (modified) (2 diffs)
• src/osgWidget/Browser.cpp (copied) (copied from OpenSceneGraph/branches/OpenSceneGraph-osgWidget-dev/src/osgWidget/Browser.cpp)
• src/osgWidget/Canvas.cpp (modified) (2 diffs)
• src/osgWidget/Frame.cpp (modified) (9 diffs)
• src/osgWidget/Input.cpp (modified) (7 diffs)
• src/osgWidget/Label.cpp (modified) (6 diffs)
• src/osgWidget/Lua.cpp (modified) (1 diff)
• src/osgWidget/Python.cpp (modified) (2 diffs)
• src/osgWidget/StyleManager.cpp (modified) (1 diff)
• src/osgWidget/Table.cpp (modified) (1 diff)
• src/osgWidget/Util.cpp (modified) (4 diffs)
• src/osgWidget/ViewerEventHandlers.cpp (modified) (3 diffs)
• src/osgWidget/Widget.cpp (modified) (16 diffs)
• src/osgWidget/Window.cpp (modified) (20 diffs)
• src/osgWidget/WindowManager.cpp (modified) (11 diffs)

OpenSceneGraph/trunk/include/osgWidget/Box

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Box 46 2008-04-30 16:11:51Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_BOX
@@ -22 +21 @@
 namespace osgWidget {
 
+//! The Box object is a Window subclass that can be configured to uniformly (or
+//! non-uniformly) position it's children either vertically or horizontally. It
+//! is the most basic Window implementation, though there is some difficulty when
+//! positioning children such that each child object ends up pixel-aligned. 
 class OSGWIDGET_EXPORT Box: public Window
 {
     public:
-        enum BOX_TYPE {
+
+        //! An enum corresponding to the type of Box alignment.
+        enum BoxType {
             VERTICAL,
             HORIZONTAL
         };
 
-        META_Object   (osgWidget, Box);
-
-        Box (const std::string& = "", BOX_TYPE = HORIZONTAL, bool = false);
+        META_Object(osgWidget, Box);
+        
+        //! The main constructor; takes the string name, the BoxType orientation, and a
+        //! boolean indicating whether or not all of the Box regions should be uniformly
+        //! sized.
+        Box (const std::string& = "", BoxType = HORIZONTAL, bool = false);
         Box (const Box&, const osg::CopyOp&);
 
@@ -44 +52 @@
     private:
 
-        BOX_TYPE     _boxType;
+        BoxType      _boxType;
         bool         _uniform;
         unsigned int _lastAdd;
-
 };
 

OpenSceneGraph/trunk/include/osgWidget/Canvas

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Canvas 66 2008-07-14 21:54:09Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_CANVAS
@@ -25 +24 @@
 {
     public:
-        META_Object   (osgWidget, Canvas);
+
+        META_Object(osgWidget, Canvas);
 
         Canvas (const std::string& = "");
         Canvas (const Canvas&, const osg::CopyOp&);
 
-        // This would conflict with the normal addWidget if there were default values. :(
+        //! Adds a Widget at the given XY coordinate.
         virtual bool addWidget(Widget*, point_type, point_type);
 

OpenSceneGraph/trunk/include/osgWidget/EventInterface

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: EventInterface 64 2008-06-30 21:32:00Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_EVENT_INTERFACE
@@ -68 +67 @@
 
         Event(WindowManager* wm, EventType _type = EVENT_NONE):
-        _wm     (wm),
-        _window (0),
-        _widget (0),
-        _data   (0),
         type    (_type),
         x       (0.0f),
         y       (0.0f),
         key     (-1),
-        keyMask (-1) {
+        keyMask (-1),
+        _wm     (wm),
+        _window (0),
+        _widget (0),
+        _data   (0) {
         }
 
@@ -204 +203 @@
 
 // The highlevel functor.
-class OSGWIDGET_EXPORT Callback
+class OSGWIDGET_EXPORT Callback: public osg::Referenced
 {
     public:
-    
-        Callback():_type(EVENT_NONE),_data(0) {}
-        Callback(const Callback& rhs):_type(rhs._type),_data(rhs._data),_callback(rhs._callback) {}
-    
+        Callback(): _type(EVENT_NONE), _data(0), _callback(0) {}
+        Callback(const Callback& rhs): osg::Referenced(rhs), _type(rhs._type), _data(rhs._data), _callback(rhs._callback) {}
+
+        // The more traditional style of OSG Callbacks.
+        Callback(EventType type, void* data=0):
+        _type     (type),
+        _data     (data),
+        _callback (0) {
+        }
+
         // Creates a Callback that is bound to a member function.
         template<typename T>
@@ -227 +232 @@
         }
 
-        bool operator()(Event& ev) {
+        virtual ~Callback() {}
+
+        virtual bool operator()(Event& ev) {
+            if(!_callback) return false;
+
             return (*_callback)(ev);
         }
@@ -242 +251 @@
             return _data;
         }
+
     protected:
         EventType _type;
-        void*      _data;
+        void*     _data;
 
         // We use a ref_ptr here so that we don't have to worry about memory.
@@ -302 +312 @@
         }
 
-        void addCallback(const Callback& cb) {
+        void addCallback(Callback* cb) {
             _callbacks.push_back(cb);
         }
@@ -313 +323 @@
                 // if(i->getType() == ev.type && (*i)(ev)) return true;
 
-                if(i->getType() == ev.type) {
-                    ev.setData(i->getData());
-
-                    if((*i)(ev)) return true;
+                if(i->get()->getType() & ev.type) {
+                    ev.setData(i->get()->getData());
+
+                    if((*i->get())(ev)) return true;
                 }
             }
@@ -388 +398 @@
 
     private:
-        typedef std::list<Callback> CallbackList;
+        typedef std::list<osg::ref_ptr<Callback> > CallbackList;
 
         unsigned int _eventMask;

OpenSceneGraph/trunk/include/osgWidget/Export

@@ -11 +11 @@
  * OpenSceneGraph Public License for more details.
 */
+
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_EXPORT_
@@ -42 +44 @@
 \namespace osgWidget
 
-The osgWidget library is a NodeKit that extends the core scene graph to support 3D GUI widget set.
+The osgWidget library is a NodeKit that extends the core scene graph to support a 2D (and eventually 3D) GUI widget set.
 */
 

OpenSceneGraph/trunk/include/osgWidget/Frame

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Frame 59 2008-05-15 20:55:31Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_FRAME
@@ -21 +20 @@
 
 namespace osgWidget {
+
+/*
+Lets take a moment and explain how Frame texturing works. When you create a Frame, you use
+a specially designed texture that is "chopped" up horizontally by the Frame code into 8 equal
+regions. Each region is then textured to a corresponding portion of the Frame, in the
+following order:
+
+        +---+---+---+---+---+---+---+---+
+        | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+        +---+---+---+---+---+---+---+---+
+
+        1. Upper-Left corner.
+        2. Top border (rotated 90 degrees CCW).
+        3. Upper-Right corner.
+        4. Left border.
+        5. Right border.
+        6. Bottom-Left corner.
+        7. Bottom border (rotated 90 degrees CCW).
+        8. Bottom-Right corner.
+
+Now, these should be pretty self-explanatory if you visualize a frame as a 3x3 "table"
+(which is exactly what it is), but note how regions 2 and 7 are rotated counter-clockwise.
+We do this for a VERY important reason: we want to enable texture repeat on the border
+regions, so that when the frame is resized the borders cleanly paint the texture over
+the entire are (and don't stretch it). However, it is impossible in OpenGL to repeat a
+sub-region of a texture without including either the vertical or horizontal bounds, so the
+artist is required to rotate the region during their rendering so that our code can properly
+rotate it back internally and have it repeat in the desired way.
+
+This method of texturing a Frame object is inspired by World of Warcraft "edge files", and it
+is both efficient and easy-to-use--once you understand the basics. If you're still confused,
+take a look at this URL, or any of the example themes:
+
+        http://www.wowwiki.com/EdgeFiles
+*/
 
 class OSGWIDGET_EXPORT Frame: public Table
@@ -26 +60 @@
     public:
     
-        enum CORNER
+        enum CornerType
         {
             CORNER_LOWER_LEFT,
@@ -34 +68 @@
         };
 
-        enum BORDER 
+        enum BorderType
         {
             BORDER_LEFT,
@@ -42 +76 @@
         };
 
-        static std::string cornerToString (CORNER);
-        static std::string borderToString (BORDER);
+        enum FrameOptions
+        {
+            FRAME_RESIZE  = 1,
+            FRAME_MOVE    = 2,
+            FRAME_TEXTURE = 4,
+            FRAME_ALL     = FRAME_RESIZE | FRAME_MOVE | FRAME_TEXTURE
+        };
+
+        static std::string cornerTypeToString (CornerType);
+        static std::string borderTypeToString (BorderType);
 
         class OSGWIDGET_EXPORT Corner: public Widget
         {
         public:
-            META_Object   (osgWidget, Corner);
-
-            Corner (CORNER = CORNER_LOWER_LEFT, point_type = 0.0f, point_type = 0.0f);
+            META_Object(osgWidget, Corner);
+
+            Corner (CornerType = CORNER_LOWER_LEFT, point_type = 0.0f, point_type = 0.0f);
             Corner (const Corner&, const osg::CopyOp&);
 
-            bool mouseDrag(double, double, WindowManager*);
-
-            CORNER getCorner() const {
+            virtual void parented  (Window*);
+            virtual bool mouseDrag (double, double, WindowManager*);
+
+            CornerType getCornerType() const
+            {
                 return _corner;
             }
 
-            void setCorner(CORNER corner) {
+            void setCornerType(CornerType corner)
+            {
                 _corner = corner;
             }
 
-            void setCornerAndName(CORNER corner) {
+            void setCornerTypeAndName(CornerType corner)
+            {
                 _corner = corner;
-                _name   = cornerToString(corner);
+                _name   = cornerTypeToString(corner);
             }
             
         protected:
-            CORNER _corner;
+
+            CornerType _corner;
         };
 
@@ -75 +122 @@
         {
         public:
-            META_Object   (osgWidget, Border);
-
-            Border (BORDER = BORDER_LEFT, point_type = 0.0f, point_type = 0.0f);
+            META_Object(osgWidget, Border);
+
+            Border (BorderType = BORDER_LEFT, point_type = 0.0f, point_type = 0.0f);
             Border (const Border&, const osg::CopyOp&);
 
-            bool mouseDrag(double, double, WindowManager*);
-
-            BORDER getBorder() const {
+            virtual void parented   (Window*);
+            virtual void positioned ();
+            virtual bool mouseDrag  (double, double, WindowManager*);
+
+            BorderType getBorderType() const
+            {
                 return _border;
             }
 
-            void setBorder(BORDER border) {
+            void setBorderType(BorderType border)
+            {
                 _border = border;
             }
 
-            void setBorderAndName(BORDER border) {
+            void setBorderTypeAndName(BorderType border)
+            {
                 _border = border;
-                _name   = borderToString(border);
+                _name   = borderTypeToString(border);
             }
             
         protected:
         
-            BORDER _border;
-
-        };
-
-        META_Object   (osgWidget, Frame);
-
-        Frame (const std::string& = "");
+            BorderType _border;
+        };
+
+        META_Object(osgWidget, Frame);
+
+        Frame (const std::string& = "", unsigned int = 0);
         Frame (const Frame&, const osg::CopyOp&);
-
-        virtual void managed(WindowManager*);
 
         static Frame* createSimpleFrame(
@@ -114 +163 @@
             point_type,
             point_type,
-            Frame* = 0
+            unsigned int = 0,
+            Frame*       = 0
         );
 
         static Frame* createSimpleFrameWithSingleTexture(
             const std::string&,
+            osg::Image*,
+            point_type,
+            point_type,
+            unsigned int = 0,
+            Frame*       = 0
+        );
+
+        static Frame* createSimpleFrameFromTheme(
             const std::string&,
-            point_type,
-            point_type,
-            point_type,
-            point_type,
-            point_type,
-            point_type,
-            Frame* = 0
+            osg::Image*,
+            point_type,
+            point_type,
+            unsigned int = 0,
+            Frame*       = 0
         );
 
         void createSimpleFrame(point_type cw, point_type ch, point_type w, point_type h)
         {
-            createSimpleFrame(_name, cw, ch, w, h, this);
+            createSimpleFrame(_name, cw, ch, w, h, 0, this);
         }
 
         void createSimpleFrameWithSingleTexture(
-            const std::string& tex,
-            point_type tw,
-            point_type th,
-            point_type cw,
-            point_type ch,
-            point_type w,
-            point_type h
+            osg::Image* image,
+            point_type  w,
+            point_type  h
         )
         {
-            createSimpleFrameWithSingleTexture(_name, tex, tw, th, cw, ch, w, h, this);
+            createSimpleFrameWithSingleTexture(_name, image, w, h, 0, this);
         }
 
@@ -153 +205 @@
         const EmbeddedWindow* getEmbeddedWindow() const { return dynamic_cast<const EmbeddedWindow*>(getByRowCol(1, 1)); }
 
-        Corner* getCorner(CORNER c) { return dynamic_cast<Corner*>(_getCorner(c)); }
-
-        const Corner* getCorner(CORNER c) const { return dynamic_cast<const Corner*>(_getCorner(c)); }
-
-        Border* getBorder(BORDER b) { return dynamic_cast<Border*>(_getBorder(b)); }
-
-        const Border* getBorder(BORDER b) const { return dynamic_cast<const Border*>(_getBorder(b)); }
+        Corner* getCorner(CornerType c) { return dynamic_cast<Corner*>(_getCorner(c)); }
+
+        const Corner* getCorner(CornerType c) const { return dynamic_cast<const Corner*>(_getCorner(c)); }
+
+        Border* getBorder(BorderType b) { return dynamic_cast<Border*>(_getBorder(b)); }
+
+        const Border* getBorder(BorderType b) const { return dynamic_cast<const Border*>(_getBorder(b)); }
+
+        // This method resizes the internal EmbeddedWindow object and then properly resizes
+        // the reset of the Frame based on the sizes of the Corners, Borders, etc.
+        bool resizeFrame(point_type, point_type);
+
+        unsigned int getFlags() const
+        {
+            return _flags;
+        }
+
+        void setFlags(unsigned int flags)
+        {
+            _flags = flags;
+        }
+
+        bool canResize() const
+        {
+            return (_flags & FRAME_RESIZE) != 0;
+        }
+
+        bool canMove() const
+        {
+            return (_flags & FRAME_MOVE) != 0;
+        }
+
+        bool canTexture() const
+        {
+            return (_flags & FRAME_TEXTURE) != 0;
+        }
 
     protected:
     
-        Widget* _getCorner (CORNER) const;
-        Widget* _getBorder (BORDER) const;
-
+        Widget* _getCorner (CornerType) const;
+        Widget* _getBorder (BorderType) const;
+
+        unsigned int _flags;
 };
 

OpenSceneGraph/trunk/include/osgWidget/Input

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Input 45 2008-04-23 16:46:11Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_INPUT
@@ -22 +21 @@
 namespace osgWidget {
 
+// This is a string of values we use to try and determine the best Y
+// descent value (yoffset); you're welcome to use what works best for
+// your font.
+const std::string DESCENT_STRING("qpl");
+
 class OSGWIDGET_EXPORT Input: public Label
 {
     public:
+
         Input(const std::string& = "", const std::string& = "", unsigned int = 20);
 
@@ -35 +40 @@
         virtual bool keyDown (int, int, WindowManager*);
 
-        void setCursor(Widget*);
+        void         setCursor            (Widget*);
+        unsigned int calculateBestYOffset (const std::string& = "qgl");
 
         void setXOffset(point_type xo) {

OpenSceneGraph/trunk/include/osgWidget/Label

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Label 59 2008-05-15 20:55:31Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_LABEL
@@ -35 +34 @@
         virtual void parented   (Window*);
         virtual void unparented (Window*);
-        virtual void managed    (WindowManager*);
         virtual void positioned ();
 
-        void update       ();
         void setLabel     (const std::string&);
         void setFont      (const std::string&);

OpenSceneGraph/trunk/include/osgWidget/Lua

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Lua 2 2008-01-24 16:11:26Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_LUA

OpenSceneGraph/trunk/include/osgWidget/Python

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Python 2 2008-01-24 16:11:26Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_PYTHON

OpenSceneGraph/trunk/include/osgWidget/ScriptEngine

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: ScriptEngine 2 2008-01-24 16:11:26Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_SCRIPT_ENGINE

OpenSceneGraph/trunk/include/osgWidget/StyleInterface

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: StyleInterface 63 2008-06-30 19:18:37Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_STYLE_INTERFACE

OpenSceneGraph/trunk/include/osgWidget/StyleManager

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: StyleManager 61 2008-06-24 20:24:26Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_STYLE_MANAGER

OpenSceneGraph/trunk/include/osgWidget/Table

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Table 48 2008-05-05 14:13:20Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_TABLE

OpenSceneGraph/trunk/include/osgWidget/Types

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Types 33 2008-04-04 19:03:12Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_TYPES
@@ -40 +39 @@
 typedef osg::Matrix::value_type matrix_type;
 
+// This is multiplied by a normalized Z value [0.0f, -1.0f] to create a RenderBin number
+// to set the state of the Window/Widget with. Perhaps at some later time this should
+// be configurable.
+const int OSGWIDGET_RENDERBIN_MOD = 5000;
+
 }
 

OpenSceneGraph/trunk/include/osgWidget/UIObjectParent

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: UIObjectParent 55 2008-05-12 19:14:42Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_UI_OBJECT_PARENT
@@ -27 +26 @@
 {
     public:
+
         typedef T                               object_type;
         typedef osg::observer_ptr<object_type>  ptr_type;

OpenSceneGraph/trunk/include/osgWidget/Util

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Util 59 2008-05-15 20:55:31Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_UTIL
 #define OSGWIDGET_UTIL
 
-#include <ctype.h>
+#include <cctype>
 #include <algorithm>
 #include <sstream>
@@ -72 +71 @@
 OSGWIDGET_EXPORT std::string  getFilePath        (const std::string&);
 OSGWIDGET_EXPORT std::string  generateRandomName (const std::string&);
-
-OSGWIDGET_EXPORT osg::Matrix  createInvertedYOrthoProjectionMatrix (matrix_type, matrix_type);
-OSGWIDGET_EXPORT osg::Camera* createOrthoCamera                    (matrix_type, matrix_type);
-OSGWIDGET_EXPORT osg::Camera* createInvertedYOrthoCamera           (matrix_type, matrix_type);
+OSGWIDGET_EXPORT osg::Camera* createOrthoCamera  (matrix_type, matrix_type);
 
 // This function sets up our basic example framework, and optionally sets some root
 // scene data.
-OSGWIDGET_EXPORT int createExample(osgViewer::Viewer&, WindowManager*, osg::Node* = 0);
-
-// This function works like the above routine, except creates an additional "outside"
-// view for looking at your 2D scene.
-// TODO: Fix this!
-OSGWIDGET_EXPORT int createCompositeExample(
-    osgViewer::CompositeViewer&,
-    osgViewer::View*,
-    WindowManager*,
-    osg::Node* = 0
-);
-
-OSGWIDGET_EXPORT bool writeWindowManagerNode(WindowManager*);
+OSGWIDGET_EXPORT int  createExample          (osgViewer::Viewer&, WindowManager*, osg::Node* = 0);
+OSGWIDGET_EXPORT bool writeWindowManagerNode (WindowManager*);
 
 }

OpenSceneGraph/trunk/include/osgWidget/Version

@@ -1 @@
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Version 64 2008-06-30 21:32:00Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_VERSION

OpenSceneGraph/trunk/include/osgWidget/ViewerEventHandlers

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: ViewerEventHandlers 31 2008-04-01 19:36:41Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_VIEWER_EVENT_HANDLERS
@@ -32 +31 @@
 {
     public:
+
         MouseHandler(WindowManager*);
 
@@ -47 +47 @@
     protected:
 
-        osg::ref_ptr<WindowManager> _wm;
+        osg::observer_ptr<WindowManager> _wm;
 
         bool _handleMousePush        (float, float, int);
@@ -58 +58 @@
         MouseAction _isMouseEvent (osgGA::GUIEventAdapter::EventType) const;
         bool        _doMouseEvent (float, float, MouseEvent);
-
 };
 
@@ -65 +64 @@
 {
     public:
+
         KeyboardHandler(WindowManager*);
 
@@ -75 +75 @@
 
     protected:
-        osg::ref_ptr<WindowManager> _wm;
+        osg::observer_ptr<WindowManager> _wm;
 
 };
@@ -83 +83 @@
 {
     public:
-        ResizeHandler(WindowManager*, osg::Camera*);
+
+        ResizeHandler(WindowManager*, osg::Camera* = 0);
 
         virtual bool handle(
@@ -94 +95 @@
     protected:
     
-        osg::ref_ptr<WindowManager> _wm;
-        osg::ref_ptr<osg::Camera>   _camera;
+        osg::observer_ptr<WindowManager> _wm;
+        osg::observer_ptr<osg::Camera>   _camera;
+};
 
+// This class provides a hotkey that lets you toggle back and forth between
+// a camera and setting the CameraManipulator's home point.
+class OSGWIDGET_EXPORT CameraSwitchHandler: public osgGA::GUIEventHandler
+{
+    public:
+
+        CameraSwitchHandler(WindowManager*, osg::Camera*);
+
+        virtual bool handle(
+            const osgGA::GUIEventAdapter&,
+            osgGA::GUIActionAdapter&,
+            osg::Object*,
+            osg::NodeVisitor*
+        );
+
+    protected:
+    
+        osg::observer_ptr<WindowManager> _wm;
+        osg::observer_ptr<osg::Camera>   _camera;
+        osg::ref_ptr<osg::Node>          _oldNode;
 };
 

OpenSceneGraph/trunk/include/osgWidget/Widget

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Widget 64 2008-06-30 21:32:00Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_WIDGET
@@ -45 +44 @@
             UR          = UPPER_RIGHT,
             UL          = UPPER_LEFT,
-            ALL_CORNERS  = 4
+            ALL_CORNERS = 4
         };
 
         enum Layer {
-            LAYER_TOP    = 20,
-            LAYER_HIGH   = 15,
-            LAYER_MIDDLE = 10,
-            LAYER_LOW    = 5,
+            LAYER_TOP    = 100,
+            LAYER_HIGH   = 75,
+            LAYER_MIDDLE = 50,
+            LAYER_LOW    = 25,
             LAYER_BG     = 0
         };
@@ -95 +94 @@
         // TO CALL IN YOUR DERIVED METHODS!) sets the TexMat properly depending
         // on what coordinate system you're using.
-        virtual void managed(WindowManager*);
+        virtual void managed(WindowManager*) {
+        }
 
         virtual void unmanaged(WindowManager*) {
@@ -118 +118 @@
         void addColor    (color_type, color_type, color_type, color_type, Corner = ALL_CORNERS);
         void setTexCoord (texcoord_type, texcoord_type, Corner = ALL_CORNERS);
+        void setLayer    (Layer l, unsigned int offset = 0);
 
         // These are additional texture coordinate setting methods.
@@ -128 +129 @@
         void setTexCoordWrapVertical   ();
 
-        bool setImage (osg::Image*, bool=false);
-        bool setImage (const std::string&, bool=false);
+        bool setImage   (osg::Image*, bool = false, bool = false);
+        bool setImage   (const std::string&, bool = false, bool = false);
+        bool setTexture (osg::Texture*, bool = false, bool = false);
 
         void addX      (point_type);
@@ -150 +152 @@
         const TexCoord& getTexCoord (Corner = ALL_CORNERS) const;
 
-        Corner  convertCorner     (Corner) const;
         Color   getImageColorAtXY (point_type x, point_type y) const;
         XYCoord localXY           (double, double) const;
@@ -217 +218 @@
         }
 
+        void setTexCoordRegion(point_type x, point_type y, const XYCoord& wh) {
+            setTexCoordRegion(x, y, wh.x(), wh.y());
+        }
+
+        void setTexCoordRegion(const XYCoord& xy, const XYCoord& wh) {
+            setTexCoordRegion(xy.x(), xy.y(), wh.x(), wh.y());
+        }
+
         void addColor(const Color& col, Corner p = ALL_CORNERS) {
             addColor(col.r(), col.g(), col.b(), col.a(), p);
@@ -236 +245 @@
         void setMinimumSize(const XYCoord& xy) {
             setMinimumSize(xy.x(), xy.y());
-        }
-
-        // TODO: Refine this...
-        void setLayer(Layer l, unsigned int offset = 0) {
-            _layer = l + offset;
         }
 
@@ -395 +399 @@
     protected:
 
-
-
         point_type _calculateZ(unsigned int) const;
 
@@ -423 +425 @@
         }
 
-        osg::Texture2D* _texture() {
+        osg::Texture* _texture() {
+            osg::StateSet* ss = getStateSet();
+
+            if(!ss) return 0;
+
             return dynamic_cast<osg::Texture2D*>(
-                getStateSet()->getTextureAttribute(0, osg::StateAttribute::TEXTURE)
+                ss->getTextureAttribute(0, osg::StateAttribute::TEXTURE)
             );
         }
 
-        const osg::Texture2D* _texture() const {
+        const osg::Texture* _texture() const {
+            const osg::StateSet* ss = getStateSet();
+
+            if(!ss) return 0;
+
             return dynamic_cast<const osg::Texture2D*>(
-                getStateSet()->getTextureAttribute(0, osg::StateAttribute::TEXTURE)
+                ss->getTextureAttribute(0, osg::StateAttribute::TEXTURE)
             );
         }

OpenSceneGraph/trunk/include/osgWidget/Window

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Window 66 2008-07-14 21:54:09Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_WINDOW
@@ -74 +73 @@
             virtual void positioned ();
 
-            bool setWindow(Window*);
+            bool setWindow            (Window*);
+            void updateSizeFromWindow ();
 
             Window* getWindow() {
@@ -140 +140 @@
         // This method wraps our Geode's addDrawable() method and returns the index of
         // the newly-added Drawable.
-        unsigned int addDrawableAndGetIndex(osg::Drawable*);
+        unsigned int addDrawableAndGetIndex (osg::Drawable*);
+        unsigned int addChildAndGetIndex    (osg::Node*);
 
         bool isVisible         () const;
@@ -148 +149 @@
         bool setFocused        (const Widget*);
         bool setFocused        (const std::string&);
+        bool grabFocus         ();
         bool setFirstFocusable ();
         bool setNextFocusable  ();
@@ -158 +160 @@
 
         // This method wraps the current Window in a EmbeddedWindow object and returns it.
-        EmbeddedWindow* embed();
+        EmbeddedWindow* embed(
+            const std::string& = "",
+            Widget::Layer      = Widget::LAYER_MIDDLE,
+            unsigned int       = 0
+        );
 
         Widget* getFocused() {
@@ -312 +318 @@
         void setY(matrix_type y) {
             _y = y;
+        }
+
+        void setZ(matrix_type z) {
+            _z = z;
+        }
+
+        void setZRange(matrix_type zRange) {
+            _zRange = zRange;
         }
 
@@ -329 +343 @@
         }
 
+        void setOrigin(const XYCoord& xy) {
+                setOrigin(xy.x(), xy.y());
+        }
+
         void setRotate(matrix_type r) {
             _r = r;
@@ -383 +401 @@
 
         void attachMoveCallback() {
-            addCallback(Callback(&callbackWindowMove, EVENT_MOUSE_DRAG));
+            addCallback(new Callback(&callbackWindowMove, EVENT_MOUSE_DRAG));
         }
 
         void attachRotateCallback() {
-            addCallback(Callback(&callbackWindowRotate, EVENT_MOUSE_DRAG));
+            addCallback(new Callback(&callbackWindowRotate, EVENT_MOUSE_DRAG));
         }
 
         void attachScaleCallback() {
-            addCallback(Callback(&callbackWindowScale, EVENT_MOUSE_DRAG));
+            addCallback(new Callback(&callbackWindowScale, EVENT_MOUSE_DRAG));
         }
 
         void attachTabFocusCallback() {
-            addCallback(Callback(&callbackWindowTabFocus, EVENT_KEY_DOWN));
+            addCallback(new Callback(&callbackWindowTabFocus, EVENT_KEY_DOWN));
         }
 

OpenSceneGraph/trunk/include/osgWidget/WindowManager

@@ -12 +12 @@
 */
 
-// -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: WindowManager 66 2008-07-14 21:54:09Z cubicool $
+// Code by: Jeremy Moles (cubicool) 2007-2008
 
 #ifndef OSGWIDGET_WINDOW_MANAGER
@@ -41 +40 @@
     public:
         enum WmFlags {
-            WM_USE_LUA      = 0x00000001,
-            WM_USE_PYTHON   = 0x00000002,
-            WM_PICK_DEBUG   = 0x00000004,
-            WM_NO_INVERT_Y  = 0x00000008,
-            WM_NO_BETA_WARN = 0x00000010
+            WM_USE_LUA        = 0x00000001,
+            WM_USE_PYTHON     = 0x00000002,
+            WM_USE_RENDERBINS = 0x00000004,
+            WM_PICK_DEBUG     = 0x00000008
         };
 
@@ -92 +90 @@
         void resizeAllWindows (bool = true);
 
+        XYCoord windowXY (double, double) const;
+        XYCoord localXY  (double, double) const;
+
         // Methods all called by the ViewerEventHandlers::MouseHandler object, or
         // by some customer caller of your own. Examples of this to come...
@@ -120 +121 @@
         }
 
-        bool isInvertedY() const {
-            return (_flags & WM_NO_INVERT_Y) == 0;
+        bool isUsingRenderBins() const {
+            return (_flags & WM_USE_RENDERBINS) != 0;
         }
 
@@ -241 +242 @@
             _width  = w;
             _height = h;
+        }
+
+        void setWindowSize(point_type w, point_type h) {
+            _windowWidth  = w;
+            _windowHeight = h;
         }
 
@@ -283 +289 @@
         };
 
+        // A functor used to sort the Windows by their BinNum component in descending order.
+        struct WindowBinNumberCompare: public std::binary_function<ptr_type, ptr_type, bool> {
+            bool operator()(const ptr_type& x, const ptr_type& y) {
+                return
+                    x.get()->getOrCreateStateSet()->getBinNumber() >
+                    y.get()->getOrCreateStateSet()->getBinNumber()
+                ;
+            }
+        };
+
         point_type         _width;
         point_type         _height;
-        point_type         _zNear;
-        point_type         _zFar;
+        point_type         _windowWidth;
+        point_type         _windowHeight;
         matrix_type        _numForeground;
         matrix_type        _numBackground;

OpenSceneGraph/trunk/src/osgWidget/Box.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Box.cpp 64 2008-06-30 21:32:00Z cubicool $
 
 #include <osgWidget/Box>
@@ -6 +5 @@
 namespace osgWidget {
 
-Box::Box(const std::string& name, BOX_TYPE bt, bool uniform):
+Box::Box(const std::string& name, BoxType bt, bool uniform):
 Window   (name),
 _boxType (bt),

OpenSceneGraph/trunk/src/osgWidget/Canvas.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Canvas.cpp 66 2008-07-14 21:54:09Z cubicool $
 
 #include <osgWidget/Canvas>
@@ -21 +20 @@
 
 bool Canvas::addWidget(Widget* widget, point_type x, point_type y) {
-    if(Window::addWidget(widget)) {
-        widget->setOrigin(x, y);
+    if(!widget) return false;
 
-        return true;
-    }
-
-    return false;
+    widget->setOrigin(x, y);
+    
+    return Window::addWidget(widget);
 }
 

OpenSceneGraph/trunk/src/osgWidget/Frame.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Frame.cpp 59 2008-05-15 20:55:31Z cubicool $
-
+
+#include <osg/io_utils>
 #include <osgDB/ReadFile>
 #include <osgWidget/WindowManager>
 #include <osgWidget/Frame>
+#include <cassert>
 
 namespace osgWidget {
 
-std::string Frame::cornerToString(CORNER c) {
+std::string Frame::cornerTypeToString(CornerType c)
+{
     if(c == CORNER_LOWER_LEFT) return "CornerLowerLeft";
 
@@ -18 +20 @@
 }
 
-std::string Frame::borderToString(BORDER b) {
+std::string Frame::borderTypeToString(BorderType b)
+{
     if(b == BORDER_LEFT) return "BorderLeft";
 
@@ -28 +31 @@
 }
 
-Frame::Corner::Corner(CORNER corner, point_type width, point_type height):
-Widget  (cornerToString(corner), width, height),
-_corner (corner) {
-    setEventMask(EVENT_MASK_MOUSE_DRAG);
+Frame::Corner::Corner(CornerType corner, point_type width, point_type height):
+Widget  (cornerTypeToString(corner), width, height),
+_corner (corner)
+{
 }
 
 Frame::Corner::Corner(const Corner& corner, const osg::CopyOp& co):
 Widget  (corner, co),
-_corner (corner._corner) {
-}
-
-bool Frame::Corner::mouseDrag(double x, double y, WindowManager* wm) {
-    Window* parent = getParent();
-
-    if(!parent) return false;
-
-    if(wm->isInvertedY()) {
-        if(_corner == CORNER_UPPER_LEFT) {
-            if(parent->resizeAdd(-x, -y)) parent->addOrigin(x, y);
-        }
-
-        else if(_corner == CORNER_UPPER_RIGHT) {
-            if(parent->resizeAdd(x, -y)) parent->addY(y);
-        }
-
-        else if(_corner == CORNER_LOWER_RIGHT) parent->resizeAdd(x, y);
-
-        else {
-            if(parent->resizeAdd(-x, y)) parent->addX(x);
-        }
-    }
-
-    // These are basically flipped-around versions of the above routines; we
-    // do it this way to avoid lots of uncessary if tests.
+_corner (corner._corner)
+{
+}
+
+void Frame::Corner::parented(Window* window) {
+    Frame* parent = dynamic_cast<Frame*>(getParent());
+
+    if(!parent) return;
+
+    if(parent->canResize()) setEventMask(EVENT_MASK_MOUSE_DRAG);
+}
+
+bool Frame::Corner::mouseDrag(double x, double y, WindowManager* wm)
+{
+    Frame* parent = dynamic_cast<Frame*>(getParent());
+
+    if(!parent || !parent->canResize()) return false;
+
+    if(_corner == CORNER_UPPER_LEFT) {
+        if(parent->resizeAdd(-x, y)) parent->addX(x);
+    }
+
+    else if(_corner == CORNER_UPPER_RIGHT) parent->resizeAdd(x, y);
+
+    else if(_corner == CORNER_LOWER_RIGHT) {
+        if(parent->resizeAdd(x, -y)) parent->addY(y);
+    }
+
     else {
-        if(_corner == CORNER_UPPER_LEFT) {
-            if(parent->resizeAdd(-x, y)) parent->addX(x);
-        }
-
-        else if(_corner == CORNER_UPPER_RIGHT) parent->resizeAdd(x, y);
-
-        else if(_corner == CORNER_LOWER_RIGHT) {
-            if(parent->resizeAdd(x, -y)) parent->addY(y);
-        }
-
-        else {
-            if(parent->resizeAdd(-x, -y)) parent->addOrigin(x, y);
-        }
+        if(parent->resizeAdd(-x, -y)) parent->addOrigin(x, y);
     }
 
@@ -83 +76 @@
 }
 
-Frame::Border::Border(BORDER border, point_type width, point_type height):
-Widget  (borderToString(border), width, height),
-_border (border) {
+Frame::Border::Border(BorderType border, point_type width, point_type height):
+Widget  (borderTypeToString(border), width, height),
+_border (border)
+{
     setCanFill(true);
-    setEventMask(EVENT_MASK_MOUSE_DRAG);
 }
 
 Frame::Border::Border(const Border& border, const osg::CopyOp& co):
 Widget  (border, co),
-_border (border._border) {
-}
-
-bool Frame::Border::mouseDrag(double x, double y, WindowManager* wm) {
-    Window* parent = getParent();
-
+_border (border._border) 
+{
+}
+
+void Frame::Border::parented(Window* window) {
+    Frame* parent = dynamic_cast<Frame*>(getParent());
+
+    if(!parent) return;
+
+    if(parent->canResize()) setEventMask(EVENT_MASK_MOUSE_DRAG);
+}
+
+void Frame::Border::positioned()
+{
+    osg::Image* image = _image();
+
+    if(!image) return;
+
+    Frame* parent = dynamic_cast<Frame*>(getParent());
+
+    if(!parent || !parent->canTexture()) return;
+
+    point_type w = image->s() / 8.0f;
+    point_type h = getHeight();
+
+    if(_border == BORDER_LEFT) setTexCoordRegion(w * 3, 0.0f, w, h);
+    
+    else if(_border == BORDER_RIGHT) setTexCoordRegion(w * 4, 0.0f, w, h);
+
+    else if(_border == BORDER_TOP) {
+        // TODO: Temporary; fix this.
+        point_type tx1 = (w * 2) / image->s();
+        point_type tx2 = w / image->s();
+        point_type tx3 = getWidth() / w;
+
+        setTexCoord(tx1, tx3,  LL);
+        setTexCoord(tx1, 0.0f, LR);
+        setTexCoord(tx2, 0.0f, UR);
+        setTexCoord(tx2, tx3,  UL);
+    }
+
+    else {
+        point_type tx1 = (w * 7) / image->s();
+        point_type tx2 = (w * 6) / image->s();
+        point_type tx3 = getWidth() / w;
+
+        setTexCoord(tx1, tx3,  LL);
+        setTexCoord(tx1, 0.0f, LR);
+        setTexCoord(tx2, 0.0f, UR);
+        setTexCoord(tx2, tx3,  UL);
+    }
+}
+
+bool Frame::Border::mouseDrag(double x, double y, WindowManager* wm)
+{
+    Frame* parent = dynamic_cast<Frame*>(getParent());
+    
     if(!parent) return false;
 
-    if(_border == BORDER_LEFT) {
-        if(parent->resizeAdd(-x, 0.0f)) parent->addX(x);
-    }
-
-    else if(_border == BORDER_RIGHT) parent->resizeAdd(x, 0.0f);
-
-    else if(_border == BORDER_TOP) parent->addOrigin(x, y);
+    if(_border == BORDER_TOP && parent->canMove()) parent->addOrigin(x, y);
 
     else {
-        // The only BORDER that inverted-Y affects is this...
-        if(wm->isInvertedY()) parent->resizeAdd(0.0f, y);
+        if(!parent->canResize()) return false;
+
+        if(_border == BORDER_LEFT) {
+            if(parent->resizeAdd(-x, 0.0f)) parent->addX(x);
+        }
+
+        else if(_border == BORDER_RIGHT) parent->resizeAdd(x, 0.0f);
 
         else {
@@ -122 +165 @@
 }
 
-Frame::Frame(const std::string& name):
-Table(name, 3, 3) {
+Frame::Frame(const std::string& name, unsigned int flags):
+Table  (name, 3, 3),
+_flags (flags)
+{
 }
 
 Frame::Frame(const Frame& frame, const osg::CopyOp& co):
-Table(frame, co) {
-}
-
-Widget* Frame::_getCorner(CORNER c) const {
-    return const_cast<Widget*>(getByName(cornerToString(c)));
-}
-
-Widget* Frame::_getBorder(BORDER b) const {
-    return const_cast<Widget*>(getByName(borderToString(b)));
-}
-
-void Frame::managed(WindowManager* wm) {
-    Window::managed(wm);
-
-    // Our Frame is created in an inverted-Y environment, so if this is the case
-    // just return here.
-    if(wm->isInvertedY()) return;
-
-    Corner* ll = getCorner(CORNER_LOWER_LEFT);
-    Corner* lr = getCorner(CORNER_LOWER_RIGHT);
-    Corner* ul = getCorner(CORNER_UPPER_LEFT);
-    Corner* ur = getCorner(CORNER_UPPER_RIGHT);
-    Border* t  = getBorder(BORDER_TOP);
-    Border* b  = getBorder(BORDER_BOTTOM);
-
-    if(!ll || !lr || !ul || !ur || !t || !b) {
-        warn()
-            << "One or more of your Corner/Border objects in the Frame [" 
-            << _name << "] are invalid; cannot invert orientation." << std::endl
-        ;
-
-        return;
-    }
-
-    ll->setCornerAndName(CORNER_UPPER_LEFT);
-    lr->setCornerAndName(CORNER_UPPER_RIGHT);
-    ul->setCornerAndName(CORNER_LOWER_LEFT);
-    ur->setCornerAndName(CORNER_LOWER_RIGHT);
-    t->setBorderAndName(BORDER_BOTTOM);
-    b->setBorderAndName(BORDER_TOP);
-}
-
-bool Frame::setWindow(Window* window) {
+Table(frame, co)
+{
+}
+
+Widget* Frame::_getCorner(CornerType c) const
+{
+    return const_cast<Widget*>(getByName(cornerTypeToString(c)));
+}
+
+Widget* Frame::_getBorder(BorderType b) const
+{
+    return const_cast<Widget*>(getByName(borderTypeToString(b)));
+}
+
+bool Frame::setWindow(Window* window)
+{
     if(!window) return false;
 
@@ -187 +205 @@
     point_type         w,
     point_type         h,
+    unsigned int       flags,
     Frame*             exFrame
 ) {
@@ -193 +212 @@
     // Use an "existing frame" if we have it (for example, if you've in inherited from
     // Frame and want to use this stuff.
-    if(!exFrame) frame = new Frame(name);
+    if(!exFrame) frame = new Frame(name, flags);
 
     else frame = exFrame;
     
-    frame->addWidget(new Corner(CORNER_UPPER_LEFT, cw,  ch), 0, 0);
-    frame->addWidget(new Border(BORDER_TOP, w, ch), 0, 1);
-    frame->addWidget(new Corner(CORNER_UPPER_RIGHT, cw, ch), 0, 2);
-    frame->addWidget(new Border(BORDER_LEFT, cw, h), 1, 0);
-    frame->addWidget(new Border(BORDER_RIGHT, cw, h), 1, 2);
-    frame->addWidget(new Corner(CORNER_LOWER_LEFT, cw, ch), 2, 0);
-    frame->addWidget(new Border(BORDER_BOTTOM, w, ch), 2, 1);
-    frame->addWidget(new Corner(CORNER_LOWER_RIGHT, cw, ch), 2, 2);
+    frame->addWidget(new Corner(CORNER_LOWER_LEFT,  cw, ch), 0, 0);
+    frame->addWidget(new Border(BORDER_BOTTOM,      w,  ch), 0, 1);
+    frame->addWidget(new Corner(CORNER_LOWER_RIGHT, cw, ch), 0, 2);
+    frame->addWidget(new Border(BORDER_LEFT,        cw, h),  1, 0);
+    frame->addWidget(new Border(BORDER_RIGHT,       cw, h),  1, 2);
+    frame->addWidget(new Corner(CORNER_UPPER_LEFT,  cw, ch), 2, 0);
+    frame->addWidget(new Border(BORDER_TOP,         w,  ch), 2, 1);
+    frame->addWidget(new Corner(CORNER_UPPER_RIGHT, cw, ch), 2, 2);
 
     EmbeddedWindow* ew = new EmbeddedWindow(name, w, h);
@@ -215 +234 @@
 }
 
+/*
 Frame* Frame::createSimpleFrameWithSingleTexture(
     const std::string& name,
@@ -248 +268 @@
     return frame;
 }
-
-}
+*/
+
+// Inspired by: http://www.wowwiki.com/EdgeFiles
+Frame* Frame::createSimpleFrameWithSingleTexture(
+    const std::string& name,
+    osg::Image*        image,
+    point_type         width,
+    point_type         height,
+    unsigned int       flags,
+    Frame*             exFrame
+) {
+    Frame* frame = 0;
+
+    double w = width;
+    double h = height;
+
+    if (image)
+    {
+        w = image->s() / 8.0f;
+        h = image->t();
+    }
+
+    // The same as above...
+    if(!exFrame) frame = createSimpleFrame(name, w, h, width, height, flags);
+
+    else frame = createSimpleFrame(name, w, h, width, height, 0, exFrame);
+
+    if (image)
+    {
+
+        for(unsigned int i = 0; i < 9; i++) frame->getObjects()[i]->setImage(image);
+
+        XYCoord twh(w, h);
+
+        frame->getCorner(CORNER_UPPER_LEFT )->setTexCoordRegion(0.0f,  0.0f, twh);
+        frame->getBorder(BORDER_TOP        )->setTexCoordRegion(w,     0.0f, twh);
+        frame->getCorner(CORNER_UPPER_RIGHT)->setTexCoordRegion(w * 2, 0.0f, twh);
+        frame->getBorder(BORDER_LEFT       )->setTexCoordRegion(w * 3, 0.0f, twh);
+        frame->getBorder(BORDER_RIGHT      )->setTexCoordRegion(w * 4, 0.0f, twh);
+        frame->getCorner(CORNER_LOWER_LEFT )->setTexCoordRegion(w * 5, 0.0f, twh);
+        frame->getBorder(BORDER_BOTTOM     )->setTexCoordRegion(w * 6, 0.0f, twh);
+        frame->getCorner(CORNER_LOWER_RIGHT)->setTexCoordRegion(w * 7, 0.0f, twh);
+
+        // We set all of these to wrap vertically, but the REAL texture coordinates will
+        // be generated properly in the positioned() method.
+        frame->getByRowCol(0, 1)->setTexCoordWrapVertical();
+        frame->getByRowCol(1, 0)->setTexCoordWrapVertical();
+        frame->getByRowCol(1, 2)->setTexCoordWrapVertical();
+        frame->getByRowCol(2, 1)->setTexCoordWrapVertical();
+
+        // frame->getEmbeddedWindow()->setTexCoordRegion(cw, ch, tw - (cw * 2.0f), th - (ch * 2.0f));
+    }
+    else 
+    {
+        osg::notify(osg::WARN) << "createSimpleFrameWithSingleTexture with a null image, the frame " << name << " will be use texture" << std::endl;
+    }
+
+    return frame;
+}
+
+bool Frame::resizeFrame(point_type w, point_type h) {
+    Border* left   = getBorder(BORDER_LEFT);
+    Border* right  = getBorder(BORDER_RIGHT);
+    Border* top    = getBorder(BORDER_TOP);
+    Border* bottom = getBorder(BORDER_BOTTOM);
+
+    if(!left || !right || !top || !bottom) return false;
+
+    return resize(
+        left->getWidth() + right->getWidth() + w,
+        top->getHeight() + bottom->getHeight() + h
+    ); 
+}
+
+
+osg::Image* createNatifEdgeImageFromTheme(osg::Image* theme);
+
+Frame* Frame::createSimpleFrameFromTheme(
+    const std::string& name,
+    osg::Image*        image,
+    point_type         width,
+    point_type         height,
+    unsigned int       flags,
+    Frame*             exFrame
+) {
+
+    osg::ref_ptr<osg::Image> natifImage = createNatifEdgeImageFromTheme(image);
+    Frame* frame;
+
+    frame = createSimpleFrameWithSingleTexture(name, natifImage.get(), width, height, flags, exFrame);
+
+    if (frame && image && natifImage.valid()) 
+    {
+        const unsigned int bpps = image->getPixelSizeInBits() / 8;
+        const unsigned int one_third_s = image->s()/3;
+        unsigned char* srcdata = (unsigned char*)image->data();
+        osg::Vec4 color(0,0,0,1);
+        for (unsigned int d = 0; d < bpps; d++)
+        {
+            color[d] = srcdata[one_third_s * image->s() * bpps + (one_third_s) * bpps + d] * 1.0/255.0;
+        }
+        frame->getEmbeddedWindow()->setColor(color);
+    }
+    return frame;
+}
+
+
+
+
+
+
+
+// (c) 2006-2008   Jean-Sébastien Guay
+// adapted by Cedric Pinson
+
+/** Implementation of copyImage. */
+template<typename T>
+void copyDataImpl(const osg::Image* source,
+                  const unsigned int x1, const unsigned int y1,
+                  const unsigned int x2, const unsigned int y2,
+                  osg::Image* destination, 
+                  const unsigned int xd = 0, const unsigned int yd = 0)
+{
+    if ((unsigned int)destination->s() >= xd + (x2 - x1) && 
+        (unsigned int)destination->t() >= yd + (y2 - y1))
+    {
+        const unsigned int bpps =      source->getPixelSizeInBits() / (8 * sizeof(T));
+
+        T* srcdata = (T*)source->data();
+        T* dstdata = (T*)destination->data();
+
+        for (unsigned int y = 0; y < y2 - y1; ++y)
+        {
+            for (unsigned int x = 0; x < x2 - x1; ++x)
+            {
+                for (unsigned int d = 0; d < bpps; d++) 
+                {
+                    T v = srcdata[(y + y1) * source->s() * bpps + (x + x1) * bpps + d];
+                    dstdata[(yd + y) * destination->s() * bpps + (xd + x) * bpps + d] = v;
+                }
+            }
+        }
+    }
+    else
+        assert(false && "copyDataImpl: Incorrect image dimensions.");
+}
+
+/** Copies a rectangle of corners (x1, y1), (x2, y2) from an image into 
+    another image starting at position (xd, yd). No scaling is done, the
+    pixels are just copied, so the destination image must be at least 
+    (xd + (x2 - x1)) by (yd + (y2 - y1)) pixels. */
+void copyData(const osg::Image* source,
+              const unsigned int x1, const unsigned int y1, 
+              const unsigned int x2, const unsigned int y2,
+              osg::Image* destination, 
+              const unsigned int xd, const unsigned int yd)
+{
+    if (source->getDataType() == destination->getDataType())
+    {
+        if (source->getDataType() == GL_UNSIGNED_BYTE)
+        {
+            copyDataImpl<unsigned char>(source, x1, y1, x2, y2, 
+                                        destination, xd, yd);
+        }
+        else
+        {
+            assert(false && "copyData not implemented for this data type");
+        }
+    }
+    else
+    {
+        assert(false && "source and destination images must be of the same type.");
+        return;
+    }
+}
+
+
+/** Implementation of rotateImage. */
+template<typename T>
+osg::Image* rotateImageImpl(osg::Image* image)
+{
+    if (image->s() == image->t())
+    {
+        const unsigned int s = image->s();
+        const unsigned int bpp = image->getPixelSizeInBits() / (8 * sizeof(T));
+
+        osg::ref_ptr<osg::Image> destination  = new osg::Image;
+        destination->allocateImage(s, s, 1,
+                                   image->getPixelFormat(), image->getDataType(),
+                                   image->getPacking());
+        destination->setInternalTextureFormat(image->getInternalTextureFormat());
+
+        T* srcdata = (T*)image->data();
+        T* dstdata = (T*)destination->data();
+
+        for (unsigned int y = 0; y < s; ++y)
+        {
+            for (unsigned int x = 0; x < s; ++x)
+            {
+                for (unsigned int p = 0; p < bpp; p++)
+                    dstdata[y * s * bpp + x * bpp + p] = srcdata[x * s * bpp + y * bpp + p];
+            }
+        }
+
+        return destination.release();
+    }
+    else
+    {
+        assert(false && "rotateImageImpl: Image must be square.");
+        return 0;
+    }
+}
+
+/** Rotates an osg::Image by 90 degrees. Returns a new osg::Image, be sure to
+    store it in a ref_ptr so it will be freed correctly. */
+osg::Image* rotateImage(osg::Image* image)
+{
+    if (image->getDataType() == GL_UNSIGNED_BYTE)
+    {
+        return rotateImageImpl<unsigned char>(image);
+    }
+    else
+    {
+        assert(false && "rotateImage not implemented for this data type");
+        return 0;
+    }
+}
+
+
+
+// SOURCE
+//          +---+---+---+
+//          | 1 | 2 | 3 |
+//          +---+---+---+
+//          | 4 |   | 5 |
+//          +---+---+---+
+//          | 6 | 7 | 8 |
+//          +---+---+---+
+
+
+// FINAL
+//         +---+---+---+---+---+---+---+---+
+//         | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+//         +---+---+---+---+---+---+---+---+
+
+//         1. Upper-Left corner.
+//         2. Top border (rotated 90 degrees CCW).
+//         3. Upper-Right corner.
+//         4. Left border.
+//         5. Right border.
+//         6. Bottom-Left corner.
+//         7. Bottom border (rotated 90 degrees CCW).
+//         8. Bottom-Right corner.
+
+osg::Image* createNatifEdgeImageFromTheme(osg::Image* theme)
+{
+    if (!theme) {
+        osg::notify(osg::WARN) << "can't create a natif edge image from null image theme as argument" << std::endl;
+        return 0;
+    }
+    osg::ref_ptr<osg::Image> final = new osg::Image;
+    const int s = theme->s();
+    const int t = theme->t();
+    const GLenum pixelFormat   = theme->getPixelFormat();
+    const GLenum dataType      = theme->getDataType();
+    const GLint internalFormat = theme->getInternalTextureFormat();
+    unsigned int packing       = theme->getPacking();
+
+    if (s != t)
+    {
+        osg::notify(osg::WARN) << "width and height are different, bad format theme image " << theme->getFileName() << std::endl;
+        return 0;
+    }
+    
+    // check size
+    int ceilvalue = static_cast<int>(ceil(s * 1.0 / 3));
+    int intvalue = s/3;
+    if (intvalue != ceilvalue)
+    {
+        osg::notify(osg::WARN) << "the size of theme file " << theme->getFileName() << " can not be divided by 3, check the documentation about theme format" << std::endl;
+        return 0;
+    }
+
+    const unsigned int one_third_s = s/3;
+    const unsigned int one_third_t = t/3;
+
+    final->allocateImage(8 * one_third_s , one_third_t, 1, pixelFormat, dataType, packing);
+    final->setInternalTextureFormat(internalFormat);
+
+    // copy 1 (6 in source)
+    copyData(theme, 0, 2 * one_third_s, one_third_s, 3 * one_third_s, final.get(), 0, 0);
+
+    // rotate and copy 2
+    osg::ref_ptr<osg::Image> rotateandcopy2  = new osg::Image;
+    rotateandcopy2->allocateImage(one_third_s , one_third_t, 1, pixelFormat, dataType, packing);
+    rotateandcopy2->setInternalTextureFormat(internalFormat);
+    copyData(theme, one_third_s, 0, 2 * one_third_s , one_third_s, rotateandcopy2.get(), 0, 0);
+    rotateandcopy2 = rotateImage(rotateandcopy2.get());
+    rotateandcopy2->flipHorizontal();
+    copyData(rotateandcopy2.get(), 0, 0, one_third_s , one_third_s, final.get(), 6*one_third_s, 0);
+
+    // copy 3 (8 in source)
+    copyData(theme, 2*one_third_s , 2 *one_third_s, 3*one_third_s , 3 * one_third_s, final.get(), 2 * one_third_s, 0);
+
+    // copy 4
+    copyData(theme, 0, one_third_s, one_third_s , 2 * one_third_s, final.get(), 3 * one_third_s, 0);
+
+    // copy 5
+    copyData(theme, 2*one_third_s , one_third_s, 3 * one_third_s , 2 * one_third_s, final.get(), 4 * one_third_s, 0);
+
+    // copy 6 (1 in source)
+    copyData(theme, 0 , 0, one_third_s, one_third_s, final.get(), 5 * one_third_s, 0);
+
+    // rotate and copy 7
+    osg::ref_ptr<osg::Image> rotateandcopy7  = new osg::Image;
+    rotateandcopy7->allocateImage(one_third_s , one_third_t, 1, pixelFormat, dataType, packing);
+    rotateandcopy7->setInternalTextureFormat(internalFormat);
+    copyData(theme, one_third_s, 2*one_third_s, 2 * one_third_s , 3 * one_third_s, rotateandcopy7.get(), 0, 0);
+    rotateandcopy7 = rotateImage(rotateandcopy7.get());
+    rotateandcopy7->flipHorizontal();
+    copyData(rotateandcopy7.get(), 0, 0, one_third_s , one_third_s, final.get(), one_third_s, 0);
+
+    // copy 8 (3 in source)
+    copyData(theme, 2 * one_third_s, 0, 3 * one_third_s , one_third_s , final.get(), 7 * one_third_s, 0);
+
+    return final.release();
+}
+
+}

OpenSceneGraph/trunk/src/osgWidget/Input.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Input.cpp 65 2008-07-14 16:29:28Z cubicool $
 
 #include <osg/io_utils>
@@ -23 +22 @@
     _cursor->setCanClone(false);
     _cursor->setDataVariance(osg::Object::DYNAMIC);
-    _cursor->setColor(0.0f, 0.0f, 0.0f, 0.0f);
+    _cursor->setColor(0.0f, 0.0f, 0.0f, 1.0f);
 
     setEventMask(
@@ -47 +46 @@
     point_type height = _cursor->getHeight();
 
-    if(width > getWidth()) setWidth(osg::round(width));
+    // if(width > getWidth()) setWidth(osg::round(width));
 
-    if(height > getHeight()) setHeight(osg::round(height));
+    // if(height > getHeight()) setHeight(osg::round(height));
 }
 
@@ -60 +59 @@
     const osgText::Text::GlyphQuads& gq = tgqmi->second;
 
-    point_type accum = 0.0f;
+    osg::Vec3 pos = _text->getPosition();
 
-    std::ostream& os = warn() << "_offsets[ ";
-    
     for(unsigned int i = 0; i < _maxSize; i++) {
-        osg::Vec2 ul = gq.getCoords()[0 + (i * 4)];
-        osg::Vec2 ll = gq.getCoords()[1 + (i * 4)];
-        osg::Vec2 lr = gq.getCoords()[2 + (i * 4)];
-        osg::Vec2 ur = gq.getCoords()[3 + (i * 4)];
+        osg::Vec3 ul = gq.getTransformedCoords(0)[0 + (i * 4)];
+        osg::Vec3 ll = gq.getTransformedCoords(0)[1 + (i * 4)];
+        osg::Vec3 lr = gq.getTransformedCoords(0)[2 + (i * 4)];
+        osg::Vec3 ur = gq.getTransformedCoords(0)[3 + (i * 4)];
         
-        accum += osg::round(lr.x() - ll.x());
-
-        _offsets[i] = accum;
-
-        os << _offsets[i] << " (" << static_cast<char>(_text->getText()[i]) << ") ";
+        _offsets[i] = lr.x() - pos.x();
+ 
+        // warn() << "vb: " << gq.getGlyphs()[i]->getHorizontalBearing() << std::endl;
     }
-
-    os << "]" << std::endl;
 }
 
 bool Input::focus(WindowManager*) {
-    _cursor->setColor(1.0f, 1.0f, 1.0f, 0.5f);
+    _cursor->setColor(0.0f, 0.0f, 0.0f, 1.0f);
 
     return true;
@@ -113 +106 @@
 
     point_type x = getX() + _xoff;
-    point_type y = getY() + th + _yoff;
+    point_type y = getY() + _yoff;
 
     // XYCoord size = getTextSize();
@@ -130 +123 @@
 
 bool Input::keyDown(int key, int mask, WindowManager*) {
-    /*
     osgText::String& s = _text->getText();
 
@@ -167 +159 @@
 
     getParent()->resize();
-    */
-
-    warn() << "Input is disabled until someone can help me understand how to use osgText; sorry..." << std::endl;
 
     return false;
 }
 
-void Input::setCursor(Widget*)
-{
-    warn() << "Input::setCursor(Widget*) not implemented yet."<<std::endl;
+void Input::setCursor(Widget*) {
+}
+
+unsigned int Input::calculateBestYOffset(const std::string& s) {
+    const osgText::FontResolution fr(_text->getCharacterHeight(), _text->getCharacterHeight());
+
+    osgText::String utf(s);
+
+    unsigned int descent = 0;
+
+    for(osgText::String::iterator i = utf.begin(); i != utf.end(); i++) {
+        osgText::Font*        font  = const_cast<osgText::Font*>(_text->getFont());
+        osgText::Font::Glyph* glyph = font->getGlyph(fr, *i);
+        unsigned int          d     = abs(glyph->getHorizontalBearing().y());
+
+        if(d > descent) descent = d;
+    }
+
+    return descent;
 }
 
 }
+

OpenSceneGraph/trunk/src/osgWidget/Label.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Label.cpp 59 2008-05-15 20:55:31Z cubicool $
 
 #include <osg/Math>
@@ -10 +9 @@
 Label::Label(const std::string& name, const std::string& label):
 Widget     (name, 0, 0),
-_textIndex (0),
-_text      (new osgText::Text()) {
-    _text->setText(label);
+_text      (new osgText::Text()), 
+_textIndex (0) {
     _text->setAlignment(osgText::Text::LEFT_BOTTOM);
     _text->setDataVariance(osg::Object::DYNAMIC);
+
+    if(label.size()) {
+        _text->setText(label);
+
+        _calculateSize(getTextSize());
+    }
 
     // TODO: Make a patch for this!
@@ -37 +41 @@
 
 void Label::_calculateSize(const XYCoord& size) {
-    if(size.x() && size.y()) setMinimumSize(size.x(), size.y());
+    // if(size.x() && size.y()) setMinimumSize(size.x(), size.y());
 
     if(getWidth() < size.x()) setWidth(size.x());
@@ -46 +50 @@
 // TODO: This will almost certainly get out of sync. :(
 void Label::parented(Window* parent) {
-    // If we've been cloned, use the index of the old text Drawable.
-    if(_textIndex) parent->getGeode()->setDrawable(_textIndex, _text.get());
+    osg::Geode* geode = parent->getGeode();
+
+    // If we've been cloned, use the index of the old text Drawable if it's already there.
+    // However, we have a problem here: imagine a Label gets cloned AFTER being added to
+    // a Window; it'll have a _textIndex, but that _textIndex won't apply to the
+    // currently cloned object. In this case, we'll need to check to be SURE.
+    osgText::Text* text = dynamic_cast<osgText::Text*>(geode->getDrawable(_textIndex));
+    
+    if(text) parent->getGeode()->setDrawable(_textIndex, _text.get());
 
     // Otherwise, add it as new.
@@ -59 +70 @@
 }
 
-void Label::managed(WindowManager* wm) {
-    if(wm->isInvertedY()) {
-        // We rotate along our X axis, so we need to make sure and translate the
-        // text later to preserve centering.
-        _text->setAxisAlignment(osgText::Text::USER_DEFINED_ROTATION);
-        _text->setRotation(osg::Quat(
-            osg::DegreesToRadians(180.0f),
-            osg::Vec3(1.0f, 0.0f, 0.0f)
-        ));
-    }
-}
-
 void Label::positioned() {
     XYCoord    size = getTextSize();
     point_type x    = osg::round(((getWidth() - size.x()) / 2.0f) + getX());
-    point_type y    = 0.0f;
+    point_type y    = osg::round(((getHeight() - size.y()) / 2.0f) + getY());
+    point_type z    = _calculateZ(getLayer() + 1);
 
-    if(getWindowManager() && getWindowManager()->isInvertedY()) y =
-        osg::round(((getHeight() - size.y()) / 2.0f) + getY() + size.y())
-    ;
-
-    else y = osg::round(((getHeight() - size.y()) / 2.0f) + getY());
-    
     // These values are permisable with CENTER_CENTER mode is active.
     // point_type x  = round(getX() + (getWidth() / 2.0f));
     // point_type y  = round(getY() + (getHeight() / 2.0f));
-    
+
     /*
     warn() << "Label widget size : " << getWidth() << " x " << getHeight() << std::endl;
@@ -95 +89 @@
     */
 
-    _text->setPosition(osg::Vec3(x, y, _calculateZ(getLayer() + 1)));
-}
+    const WindowManager* wm = _getWindowManager();
 
-void Label::update()
-{
-    warn() << "Label::update() not implemented yet."<<std::endl;
+    if(wm && wm->isUsingRenderBins()) {
+        _text->getOrCreateStateSet()->setRenderBinDetails(
+            static_cast<int>(z * OSGWIDGET_RENDERBIN_MOD),
+            "RenderBin"
+        );
+
+        z = 0.0f;
+    }
+
+    _text->setPosition(osg::Vec3(x, y, z));
 }
 

OpenSceneGraph/trunk/src/osgWidget/Lua.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Lua.cpp 2 2008-01-24 16:11:26Z cubicool $
 
 #include <osgDB/FileUtils>

OpenSceneGraph/trunk/src/osgWidget/Python.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Python.cpp 59 2008-05-15 20:55:31Z cubicool $
 
 // Python.h needs to be included before anything else.
@@ -173 +172 @@
     }
 
-    FILE*     f = osgDB::fopen(filePath.c_str(), "r");
+    FILE*     f = fopen(filePath.c_str(), "r");
     PyObject* r = PyRun_File(f, filePath.c_str(), Py_file_input, _data->main, _data->main);
 

OpenSceneGraph/trunk/src/osgWidget/StyleManager.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: StyleManager.cpp 55 2008-05-12 19:14:42Z cubicool $
 
 #include <sstream>

OpenSceneGraph/trunk/src/osgWidget/Table.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Table.cpp 48 2008-05-05 14:13:20Z cubicool $
 
 #include <osgWidget/Table>

OpenSceneGraph/trunk/src/osgWidget/Util.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: Util.cpp 59 2008-05-15 20:55:31Z cubicool $
 
 #include <osg/io_utils>
@@ -37 +36 @@
 }
 
-osg::Matrix createInvertedYOrthoProjectionMatrix(matrix_type width, matrix_type height) {
-    osg::Matrix m = osg::Matrix::ortho2D(0.0f, width, 0.0f, height);
-    osg::Matrix s = osg::Matrix::scale(1.0f, -1.0f, 1.0f);
-    osg::Matrix t = osg::Matrix::translate(0.0f, -height, 0.0f);
-
-    return t * s * m;
-}
-
 osg::Camera* createOrthoCamera(matrix_type width, matrix_type height) {
     osg::Camera* camera = new osg::Camera();
@@ -62 +53 @@
 }
 
-osg::Camera* createInvertedYOrthoCamera(matrix_type width, matrix_type height) {
-    osg::Camera* camera = createOrthoCamera(width, height);
+int createExample(osgViewer::Viewer& viewer, WindowManager* wm, osg::Node* node) {
+    if(!wm) return 1;
 
-    camera->setProjectionMatrix(createInvertedYOrthoProjectionMatrix(width, height));
-    
-    return camera;
-}
-
-osg::Group* _createExampleCommon(osgViewer::View* view, WindowManager* wm, osg::Node* node) {
-    if(!wm) return 0;
-
-    view->setUpViewInWindow(
-        0,
-        0,
+    viewer.setUpViewInWindow(
+        50,
+        50,
         static_cast<int>(wm->getWidth()),
         static_cast<int>(wm->getHeight())
@@ -87 +70 @@
     if(node) group->addChild(node);
 
-    view->addEventHandler(new osgWidget::MouseHandler(wm));
-    view->addEventHandler(new osgWidget::KeyboardHandler(wm));
-    view->addEventHandler(new osgWidget::ResizeHandler(wm, camera));
-    view->addEventHandler(new osgViewer::StatsHandler());
-    view->addEventHandler(new osgViewer::WindowSizeHandler());
-    view->addEventHandler(new osgGA::StateSetManipulator(
-        view->getCamera()->getOrCreateStateSet()
+    viewer.addEventHandler(new osgWidget::MouseHandler(wm));
+    viewer.addEventHandler(new osgWidget::KeyboardHandler(wm));
+    viewer.addEventHandler(new osgWidget::ResizeHandler(wm, camera));
+    viewer.addEventHandler(new osgWidget::CameraSwitchHandler(wm, camera));
+    viewer.addEventHandler(new osgViewer::StatsHandler());
+    viewer.addEventHandler(new osgViewer::WindowSizeHandler());
+    viewer.addEventHandler(new osgGA::StateSetManipulator(
+        viewer.getCamera()->getOrCreateStateSet()
     ));
 
     wm->resizeAllWindows();
-    
-    return group;
-}
-
-int createExample(osgViewer::Viewer& viewer, WindowManager* wm, osg::Node* node) {
-    osg::Group* group = _createExampleCommon(&viewer, wm, node);
 
     viewer.setSceneData(group);
-
-    return viewer.run();
-}
-
-// TODO: This function is totally broken; I don't really have any idea of how to do this.
-// Incredibly frustrating stuff.
-int createCompositeExample(
-    osgViewer::CompositeViewer& viewer,
-    osgViewer::View*            view,
-    WindowManager*              wm,
-    osg::Node*                  node
-) {
-    osg::Group*           group   = _createExampleCommon(view, wm, node);
-    osg::MatrixTransform* watcher = new osg::MatrixTransform();
-
-    watcher->addChild(wm);
-
-    // Setup the main 2D view.
-    viewer.addView(view);
-
-    view->setSceneData(group);
-
-    // The view that "watches" the main view.
-    osgViewer::View* viewWatcher = new osgViewer::View();
-
-    viewer.addView(viewWatcher);
-
-    int w = static_cast<int>(wm->getWidth());
-    int h = static_cast<int>(wm->getHeight());
-    
-    viewWatcher->setUpViewInWindow(0, 0, w, h);
-
-    // Setup our parent MatrixTransform so things look right in perspective.
-    watcher->setMatrix(
-        osg::Matrix::scale(1.0f, -1.0f, 1000.0f) *
-        osg::Matrix::rotate(osg::DegreesToRadians(90.0f), osg::Vec3d(1.0f, 0.0f, 0.0f))
-    );
-
-    watcher->getOrCreateStateSet()->setAttributeAndModes(
-        new osg::Scissor(0, 0, w, h),
-        osg::StateAttribute::OVERRIDE
-    );
-
-    osgGA::TrackballManipulator* tb = new osgGA::TrackballManipulator();
-
-    warn() << watcher->getMatrix() << std::endl;
-
-    /*
-    const osg::BoundingSphere& bs = watcher->getBound();
-
-    tb->setHomePosition(
-        bs.center() + osg::Vec3(0.0f, -3.5f * bs.radius(), 0.0f),
-        bs.center(),
-        osg::Vec3(0.0f, 1.0f, 0.0f)
-    );
-    */
-
-    viewWatcher->setSceneData(watcher);
-    viewWatcher->setCameraManipulator(tb);
 
     return viewer.run();

OpenSceneGraph/trunk/src/osgWidget/ViewerEventHandlers.cpp

@@ -1 +1 @@
 // -*-c++-*- osgWidget - Code by: Jeremy Moles (cubicool) 2007-2008
-// $Id: ViewerEventHandlers.cpp 59 2008-05-15 20:55:31Z cubicool $
 
 #include <osgWidget/ViewerEventHandlers>
@@ -176 +175 @@
     osg::Matrix::value_type h = gea.getWindowHeight();
 
-    if(_wm->isInvertedY()) _camera->setProjectionMatrix(
-        createInvertedYOrthoProjectionMatrix(w, h)
-    );
-
-    else _camera->setProjectionMatrix(osg::Matrix::ortho2D(0.0f, w, 0.0f, h));
-    
-    _wm->setSize(w, h);
+    if(_camera.valid()) {
+        _camera->setProjectionMatrix(osg::Matrix::ortho2D(0.0f, w, 0.0f, h));
+
+        _wm->setSize(w, h);
+    }
+    
+    _wm->setWindowSize(w, h);
     _wm->resizeAllWindows();
 
@@ -188 +187 @@
 }
 
-}
+CameraSwitchHandler::CameraSwitchHandler(WindowManager* wm, osg::Camera* camera):
+_wm     (wm),
+_camera (camera) {
+}
+
+bool CameraSwitchHandler::handle(
+    const osgGA::GUIEventAdapter& gea,
+    osgGA::GUIActionAdapter&      gaa,
+    osg::Object*                  obj,
+    osg::NodeVisitor*             nv
+) {
+    if(
+        gea.getEventType() != osgGA::GUIEventAdapter::KEYDOWN ||
+        gea.getKey()       != osgGA::GUIEventAdapter::KEY_F12
+    ) return false;
+
+    osgViewer::View* view = dynamic_cast<osgViewer::View*>(&gaa);
+
+    if(!view) return false;
+
+    osg::Node* oldNode = view->getSceneData();
+
+    osg::MatrixTransform* oldTrans = dynamic_cast<osg::MatrixTransform*>(oldNode);
+
+    if(!oldTrans) {
+        // Imagine this is the number of pixels...
+        double scale  = 2000.0f;
+        double width  = _wm->getWidth();
+        double height = _wm->getHeight();
+
+        _oldNode = oldNode;
+
+        osg::MatrixTransform* mt = new osg::MatrixTransform();
+
+        mt->setMatrix(
+            osg::Matrix::translate(width / 2.0f, 0.0f, 0.0f) *
+            osg::Matrix::scale(1.0f, 1.0f, scale) *
+            osg::Matrix::rotate(osg::DegreesToRadians(45.0f), 0.0f, 1.0f, 0.0f)
+        );
+
+        mt->addChild(_wm.get());
+        mt->getOrCreateStateSet()->setMode(
+            GL_LIGHTING,
+            osg::StateAttribute::PROTECTED | osg::StateAttribute::OFF
+        );
+        mt->getOrCreateStateSet()->setMode(
+            GL_SCISSOR_TEST,
+            osg::StateAttribute::OVERRIDE | osg::StateAttribute::OFF
+        );
+
+        osgGA::MatrixManipulator* mm = view->getCameraManipulator();
+
+        // mm->setDistance(3000.0f);
+        // mm->setMinimumZoomScale(10.0f);
+        mm->setHomePosition(
+            // eye
+            osg::Vec3(width / 2.0f, height, 100.0f),
+            // center
+            osg::Vec3(0.0f, 0.0f, -(scale / 2.0f)),
+            // up
+            osg::Vec3(0.0f, 1.0f, 0.0f)
+        );
+
+        view->setSceneData(mt);
+    }
+
+    else view->setSceneData(_oldNode.get());
+
+    return true;
+}
+
+}

OpenSceneGraph/trunk/src/osgWidget/Widget.cpp

@@ -4 +4 @@
 #include <osg/io_utils>
 #include <osg/Math>
-#include <osg/BlendFunc>
-#include <osg/TexMat>
+#include <osg/TextureRectangle>
 #include <osgDB/ReadFile>
 #include <osgDB/FileUtils>
@@ -35 +34 @@
 _isManaged (false),
 _isStyled  (false),
-_minWidth  (w),
-_minHeight (h) {
+_minWidth  (0.0f),
+_minHeight (0.0f) {
     _name = name.size() ? name : generateRandomName("Widget");
 
@@ -64 +63 @@
     setDimensions(0.0f, 0.0f, w, h);
     setColor(1.0f, 1.0f, 1.0f, 1.0f);
-
-    getOrCreateStateSet()->setMode(GL_BLEND, osg::StateAttribute::ON);
-    getOrCreateStateSet()->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
 }
 
@@ -109 +105 @@
 
 osg::Image* Widget::_getImage() const {
-    const osg::Texture2D* texture = _texture();
+    const osg::Texture* texture = _texture();
 
     if(texture) return const_cast<osg::Image*>(texture->getImage(0));
 
     return 0;
-}
-
-void Widget::managed(WindowManager* wm) {
-    if(!wm->isInvertedY()) return;
-
-    osg::Matrix s = osg::Matrix::scale(1.0f, -1.0f, 1.0f);
-    osg::Matrix t = osg::Matrix::translate(0.0f, -1.0, 0.0f);
-
-    getOrCreateStateSet()->setTextureAttributeAndModes(
-        0,
-        new osg::TexMat(t * s),
-        osg::StateAttribute::ON
-    );
 }
 
@@ -206 +189 @@
     }
 
+    const WindowManager* wm = _getWindowManager();
+
+    if(wm && wm->isUsingRenderBins()) {
+        getOrCreateStateSet()->setRenderBinDetails(static_cast<int>(z), "RenderBin");
+
+        z = 0.0f;
+    }
+
     (*verts)[LL].set(x,     y,     z);
     (*verts)[LR].set(x + w, y,     z);
@@ -222 +213 @@
     }
 
-    else (*cols)[convertCorner(p)].set(r, g, b, a);
+    else (*cols)[p].set(r, g, b, a);
 }
 
@@ -235 +226 @@
     }
 
-    else (*cols)[convertCorner(p)] += Color(r, g, b, a);
+    else (*cols)[p] += Color(r, g, b, a);
 }
 
@@ -248 +239 @@
     }
 
-    else (*texs)[convertCorner(p)].set(tx, ty);
+    else (*texs)[p].set(tx, ty);
+}
+
+// TODO: We chop off any offset here if you use TOP; we need to do the same
+// for BG, etc.
+void Widget::setLayer(Layer layer, unsigned int offset) {
+    if(layer == LAYER_TOP) offset = 0;
+
+    _layer = layer + offset;
 }
 
@@ -264 +263 @@
     XYCoord t(x / tw, y / tw);
 
-    (*texs)[UL] = t;
+    (*texs)[LL] = t;
     
     // Set the LOWER_RIGHT point.
     t += XYCoord(w / tw, 0.0f);
 
-    (*texs)[UR] = t;
+    (*texs)[LR] = t;
 
     // Set the UPPER_RIGHT point.
     t += XYCoord(0.0f, h / th);
 
-    (*texs)[LR] = t;
+    (*texs)[UR] = t;
 
     // Set the UPPER_LEFT point.
     t += XYCoord(-(w / tw), 0.0f);
 
-    (*texs)[LL] = t;
+    (*texs)[UL] = t;
 }
 
 void Widget::setTexCoordWrapHorizontal() {
-    osg::Image*     image   = _image();
-    osg::Texture2D* texture = _texture();
+    osg::Image*   image   = _image();
+    osg::Texture* texture = _texture();
 
     if(!image || !texture || image->s() == 0.0f) return;
@@ -295 +294 @@
 
 void Widget::setTexCoordWrapVertical() {
-    osg::Image*     image   = _image();
-    osg::Texture2D* texture = _texture();
+    osg::Image*   image   = _image();
+    osg::Texture* texture = _texture();
 
     if(!image || !texture || image->t() == 0.0f) return;
@@ -312 +311 @@
 }
 
-bool Widget::setImage(osg::Image* image, bool setTexCoords) {
+bool Widget::setImage(osg::Image* image, bool setTexCoords, bool useTextRect) {
     if(!image) {
         warn() << "Widget [" << _name << "] cannot use a NULL image." << std::endl;
@@ -319 +318 @@
     }
 
-    osg::Texture2D* texture = new osg::Texture2D();
-    
-    texture->setDataVariance(osg::Object::DYNAMIC);
+    osg::Texture* texture = 0;
+    
+    if(useTextRect) texture = new osg::TextureRectangle();
+    
+    else texture = new osg::Texture2D();
+    
+    if(!texture) return false;
+
     texture->setImage(0, image);
 
-    getOrCreateStateSet()->setTextureAttributeAndModes(
-        0,
-        texture,
-        osg::StateAttribute::ON
-    );
-
-    if(setTexCoords) {
-        setTexCoord(0.0f, 0.0f, LOWER_LEFT);
-        setTexCoord(1.0f, 0.0f, LOWER_RIGHT);
-        setTexCoord(1.0f, 1.0f, UPPER_RIGHT);
-        setTexCoord(0.0f, 1.0f, UPPER_LEFT);
-    }
-
-    return true;
-}
-
-bool Widget::setImage(const std::string& filePath, bool setTexCoords) {
+    return setTexture(texture, setTexCoords, useTextRect);
+}
+
+bool Widget::setImage(const std::string& filePath, bool setTexCoords, bool useTextRect) {
     if(!osgDB::findDataFile(filePath).size()) {
         warn()
@@ -351 +342 @@
     }
 
-    return setImage(osgDB::readImageFile(filePath), setTexCoords);
+    return setImage(osgDB::readImageFile(filePath), setTexCoords, useTextRect);
+}
+
+bool Widget::setTexture(osg::Texture* texture, bool setTexCoords, bool useTextRect) {
+    if(!texture) return false;
+
+    getOrCreateStateSet()->setTextureAttributeAndModes(
+        0,
+        texture,
+        osg::StateAttribute::ON
+    );
+
+    if(setTexCoords) {
+        if(useTextRect) {
+             osg::Image* image = texture->getImage(0);
+
+            setTexCoord(0.0f, 0.0f, LOWER_LEFT);
+            setTexCoord(image->s(), 0.0f, LOWER_RIGHT);
+            setTexCoord(image->s(), image->t(), UPPER_RIGHT);
+            setTexCoord(0.0f, image->t(), UPPER_LEFT);
+        }
+
+        else {
+            setTexCoord(0.0f, 0.0f, LOWER_LEFT);
+            setTexCoord(1.0f, 0.0f, LOWER_RIGHT);
+            setTexCoord(1.0f, 1.0f, UPPER_RIGHT);
+            setTexCoord(0.0f, 1.0f, UPPER_LEFT);
+        }
+    }
+
+    return true;
 }
 
@@ -452 +473 @@
     if(p == ALL_CORNERS) point = UPPER_LEFT;
 
-    return (*_verts())[convertCorner(point)];
+    return (*_verts())[point];
 }
 
@@ -460 +481 @@
     if(p == ALL_CORNERS) point = UPPER_LEFT;
 
-    return (*_cols())[convertCorner(point)];
+    return (*_cols())[point];
 }
 
@@ -468 +489 @@
     if(p == ALL_CORNERS) point = UPPER_LEFT;
 
-    return (*_texs())[convertCorner(point)];
-}
-
-// This converts our points back and forth depding on whether or not we're in an
-// inverted-Y WindowManager.
-Widget::Corner Widget::convertCorner(Corner p) const {
-    const WindowManager* wm = getWindowManager();
-
-    if(!wm || !wm->isInvertedY()) return p;
-    
-    if(p == UPPER_LEFT) return LOWER_LEFT;
-
-    else if(p == UPPER_RIGHT) return LOWER_RIGHT;
-
-    else if(p == LOWER_LEFT) return UPPER_LEFT;
-
-    else if(p == LOWER_RIGHT) return UPPER_RIGHT;
-
-    else return p;
+    return (*_texs())[point];
 }
 

OpenSceneGraph/trunk/src/osgWidget/Window.cpp

@@ -71 +71 @@
 
 void Window::EmbeddedWindow::unparented(Window*) {
-    // TODO: Figure out what's necessary here...
+    if(_window.valid()) {
+        _window->_parent = 0;
+
+        if(_parent) _parent->removeChild(_window.get());
+    }
 }
 
@@ -96 +100 @@
     // Whether or not the Window honors this reqest will be up to it.
     _window->setOrigin(x, y);
+    _window->setZ(_calculateZ(getLayer() + 1));
+    _window->setZRange(_calculateZ(LAYER_TOP - (getLayer() + 1)));
     _window->setVisibleArea(0, 0, static_cast<int>(w), static_cast<int>(h));
     _window->resize(w, h);
@@ -110 +116 @@
     }
 
-    // TODO: I need to handle there already being a Window here.
     _window = win;
 
@@ -125 +130 @@
 }
 
+void Window::EmbeddedWindow::updateSizeFromWindow() {
+    setSize(_window->getSize());
+
+    if(_parent) _parent->resize();
+}
+
 Window::Window(const std::string& name):
-_parent      (0),
-_wm          (0),
-_index       (0),
-_x           (0.0f),
-_y           (0.0f),
-_z           (0.0f),
-_zRange      (0.0f),
-_strata      (STRATA_NONE),
-_vis         (VM_FULL),
-_r           (0.0f),
-_s           (1.0f),
-_scaleDenom  (100.0f),
-_vAnchor     (VA_NONE),
-_hAnchor     (HA_NONE) {
+_parent     (0),
+_wm         (0),
+_index      (0),
+_x          (0.0f),
+_y          (0.0f),
+_z          (0.0f),
+_zRange     (0.0f),
+_strata     (STRATA_NONE),
+_vis        (VM_FULL),
+_r          (0.0f),
+_s          (1.0f),
+_scaleDenom (100.0f),
+_vAnchor    (VA_NONE),
+_hAnchor    (HA_NONE) {
     _name = name.size() ? name : generateRandomName("Window");
 
@@ -147 +158 @@
 
     bg->setLayer(Widget::LAYER_BG);
-    bg->setColor(0.0f, 0.0f, 0.0f, 0.5f);
+    bg->setColor(1.0f, 1.0f, 1.0f, 1.0f);
 
     _setParented(bg);
@@ -202 +213 @@
         Widget* widget = dynamic_cast<Widget*>(geode->getDrawable(i));
 
-        if(!widget || !widget->canClone()) continue;
+        if(!widget) continue;
+
+        // TODO: Properly test this...
+        if(!widget->canClone()) {
+            // geode->removeDrawable(widget);
+
+            continue;
+        }
 
         _setParented(widget);
@@ -287 +305 @@
 
 void Window::update() {
-    // Update all embedded children; the zRange values continue to decrease in precision
-    // as you add more and more embedded Windows.
     WindowList wl;
 
     getEmbeddedList(wl);
 
-    // Each child Window gets half the zRange of it's parent Window. This means the more
-    // you embed Windows into other Windows, the less depth precision you're going to have.
-    for(WindowList::iterator w = wl.begin(); w != wl.end(); w++) {    
-        Window* win = w->get();
-
-        win->_z      = _zRange / 2.0f;
-        win->_zRange = _zRange / 2.0f;
-
-        win->update();
-    }
+    for(WindowList::iterator w = wl.begin(); w != wl.end(); w++) w->get()->update();
 
     matrix_type x  = _x;
@@ -319 +326 @@
 
         xy.set(x, y);
+    }
+    
+    matrix_type z = _z;
+
+    // We can't do proper scissoring until we have access to our parent WindowManager, and
+    // we need to determine the sorting method we want to use.
+    if(_wm) {
+        if(_wm->isUsingRenderBins()) {
+            getOrCreateStateSet()->setRenderBinDetails(
+                static_cast<int>((1.0f - fabs(_z)) * OSGWIDGET_RENDERBIN_MOD),
+                "RenderBin"
+            );
+
+            z = 0.0f;
+        }
+
+        int sx = static_cast<int>(xy.x());
+        int sy = static_cast<int>(xy.y());
+        int sw = static_cast<int>(_width.current);
+        int sh = static_cast<int>(_height.current);
+
+        // This sets the Scissor area to some offset defined by the user.
+        if(_vis == VM_PARTIAL) {
+            sw = static_cast<int>(_visibleArea[2]);
+            sh = static_cast<int>(_visibleArea[3]);
+        }
+
+        // Otherwise, use the size of the WindowManager itself.
+        else if(_vis == VM_ENTIRE) {
+            sx = 0;
+            sy = 0;
+            sw = static_cast<int>(_wm->getWidth());
+            sh = static_cast<int>(_wm->getHeight());
+        }
+
+        _scissor()->setScissor(sx, sy, sw, sh);
     }
 
@@ -327 +370 @@
         osg::Vec3d(0.0f, 0.0f, 1.0f)
     );
-    
+
     osg::Matrix s = osg::Matrix::scale(_s, _s, 1.0f);
-    osg::Matrix t = osg::Matrix::translate(x - _visibleArea[0], y - _visibleArea[1], _z);
+    osg::Matrix t = osg::Matrix::translate(x - _visibleArea[0], y - _visibleArea[1], z);
 
     setMatrix(r * s * t);
-
-    // We can't do proper scissoring until we have access to our parent WindowManager.
-    if(_wm) {
-        int x   = static_cast<int>(xy.x());
-        int y   = static_cast<int>(xy.y());
-        int w   = static_cast<int>(_width.current);
-        int h   = static_cast<int>(_height.current);
-        int wmh = static_cast<int>(_wm->getHeight());
-        int nx  = x;
-        int ny  = y;
-        int nw  = w;
-        int nh  = h;
-
-        // This sets the Scissor area to the full size of the Window.
-        if(_vis == VM_FULL && _wm->isInvertedY()) ny = wmh - h - y;
-
-        // This sets the Scissor area to some offset defined by the user.
-        else if(_vis == VM_PARTIAL) {
-            if(_wm->isInvertedY()) ny = wmh - y - static_cast<int>(_visibleArea[3]);
-
-            // else ny = static_cast<int>(_visibleArea[3]);
-
-            nw = static_cast<int>(_visibleArea[2]);
-            nh = static_cast<int>(_visibleArea[3]);
-        }
-
-        // Otherwise, use the size of the WindowManager itself.
-        else {
-            nx = 0;
-            ny = 0;
-            nw = static_cast<int>(_wm->getWidth());
-            nh = wmh;
-        }
-
-        _scissor()->setScissor(nx, ny, nw, nh);
-    }
 }
 
@@ -527 +534 @@
 
     else {
+        widget->unparented(this);
+
         widget->_parent = 0;
-
-        widget->unparented(this);
     }
 }
@@ -640 +647 @@
 }
 
+// The topmost Window always has this method called, instead of the embedded window directly.
 bool Window::setFocused(const Widget* widget) {
     // TODO: I've turned on the warn() here, but perhaps I shouldn't? I need to define
@@ -651 +659 @@
     ConstIterator i = std::find(begin(), end(), widget);
 
+    bool found = false;
+
     if(i == end()) {
+        // We couldn't find the widget in the toplevel, so lets see if one of our
+        // EmbeddedWindow objects has it.
+        WindowList wl;
+
+        getEmbeddedList(wl);
+
+        for(WindowList::iterator w = wl.begin(); w != wl.end(); w++) {
+            ConstIterator ii = std::find(w->get()->begin(), w->get()->end(), widget);
+            
+            if(ii != w->get()->end()) {
+                found = true;
+                i     = ii;
+            }
+        }
+    }
+
+    else found = true;
+
+    if(!found) {
         warn()
             << "Window [" << _name
@@ -667 +696 @@
 
 bool Window::setFocused(const std::string& name) {
-    Widget* w = getByName(name);
-
-    if(!w) {
+    Widget* w1 = getByName(name);
+
+    bool found = false;
+
+    if(!w1) {
+        // Just like above, we couldn't find the widget in the toplevel, so lets see if
+        // one of our EmbeddedWindow objects has it. The difference here is that we
+        // search by name.
+        WindowList wl;
+
+        getEmbeddedList(wl);
+
+        for(WindowList::iterator w = wl.begin(); w != wl.end(); w++) {
+            Widget* w2 = w->get()->getByName(name);
+
+            if(w2) {
+                found = true;
+                w1    = w2;
+            }
+        }
+    }
+
+    else found = true;
+
+    if(!found) {
         warn()
             << "Window [" << _name
@@ -679 +730 @@
     }
 
-    _setFocused(w);
+    _setFocused(w1);
     
     return true;
+}
+
+bool Window::grabFocus() {
+    if(!_wm) return false;
+
+    return _wm->setFocused(this);
 }
 
@@ -725 +782 @@
     double  y  = absy - xy.y();
 
-    if(_wm && _wm->isInvertedY()) y = (_wm->getHeight() - absy) - xy.y();
-
     return XYCoord(x + _visibleArea[0], y + _visibleArea[1]);
 }
@@ -747 +802 @@
 }
 
-Window::EmbeddedWindow* Window::embed() {
-    EmbeddedWindow* ew = new EmbeddedWindow(_name + "Embedded", getWidth(), getHeight());
+Window::EmbeddedWindow* Window::embed(
+    const std::string& newName,
+    Widget::Layer      layer,
+    unsigned int       layerOffset
+) {
+    EmbeddedWindow* ew = new EmbeddedWindow(
+        newName.size() > 0 ? newName : _name + "Embedded",
+        getWidth(),
+        getHeight()
+    );
 
     ew->setWindow(this);
     ew->setSize(getWidth(), getHeight());
-    ew->setMinimumSize(getMinWidth(), getMinHeight());
     ew->setCanFill(true);
+    ew->setLayer(layer, layerOffset);
 
     return ew;
@@ -780 +843 @@
         if(!ew || !ew->getWindow()) continue;
 
-        wl.push_back(ew->getWindow());
+        else {
+            wl.push_back(ew->getWindow());
+
+            ew->getWindow()->getEmbeddedList(wl);
+        }
     }
 
@@ -853 +920 @@
 }
 
+unsigned int Window::addChildAndGetIndex(osg::Node* node) {
+    if(addChild(node)) return getChildIndex(node);
+
+    return 0;
+}
+
 // All of the subsequent functions are very boring and uninteresting, although hopefully
 // self-explanatory. They simply wrap calls to _compare<>() with the proper templates, and
@@ -946 +1019 @@
     point_type w = osg::round(bb.xMax() - bb.xMin());
 
-    return Sizes(w, w);
+    return Sizes(w, 0.0f);
 }
 
@@ -954 +1027 @@
     point_type h = osg::round(bb.yMax() - bb.yMin());
 
-    return Sizes(h, h);
-}
-
-}
+    return Sizes(h, 0.0f);
+}
+
+}

OpenSceneGraph/trunk/src/osgWidget/WindowManager.cpp

@@ -24 +24 @@
 _width          (width),
 _height         (height),
-_zNear          (0.0f),
-_zFar           (-1.0f),
+_windowWidth    (width),
+_windowHeight   (height),
 _numForeground  (0.0f),
 _numBackground  (0.0f),
@@ -57 +57 @@
     }
 
+    if(_flags & WM_USE_RENDERBINS) getOrCreateStateSet()->setMode(GL_DEPTH_TEST, false);
+
     // Setup our picking debug (is debug the right word here?) Window...
     if(_flags & WM_PICK_DEBUG) {
@@ -80 +82 @@
     }
 
-    if(!(_flags & WM_NO_BETA_WARN)) {
-        Box*   box   = new Box("BetaWarningBox", Box::VERTICAL);
-        Label* label = new Label("BetaWarning");
-
-        label->setFontSize(15);
-        label->setFontColor(0.0f, 0.0f, 1.0f, 1.0f);
-        label->setFont("fonts/arial.ttf");
-        label->setPadding(5.0f);
-        label->setCanFill(true);
-        label->setLabel("This is BETA software! Please see: http://osgwidget.googlecode.com");
-
-        box->getBackground()->setColor(1.0f, 0.7f, 0.0f, 1.0f);
-        box->addWidget(label);
-        box->setNodeMask(~_nodeMask);
-        box->removeEventMask(EVENT_MASK_FOCUS);
-        box->setStrata(Window::STRATA_BACKGROUND);
-        box->setOrigin(0.0f, 0.0f);
-
-        addChild(box);
-        
-        box->resizePercent(100.0f, 0.0f);
-    }
+    getOrCreateStateSet()->setMode(
+        GL_BLEND,
+        osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE
+    );
+    getOrCreateStateSet()->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
 }
 
@@ -141 +126 @@
     if(!_lastPush) return false;
 
-    bool handled = _lastPush->callMethodAndCallbacks(ev);
+    // TODO: This is the old way; it didn't allow Event handler code to call grabFocus().
+    // bool handled = _lastPush->callMethodAndCallbacks(ev);
 
     if(_focusMode != PFM_SLOPPY) {
@@ -156 +142 @@
     }
 
-    return handled;
+    return _lastPush->callMethodAndCallbacks(ev);
 }
 
@@ -182 +168 @@
 void WindowManager::_getPointerXYDiff(float& x, float& y) {
     x -= _lastX;
-
-    if(isInvertedY()) y = -(y - _lastY);
-
-    else y -= _lastY;
+    y -= _lastY;
 }
 
@@ -300 +283 @@
             // Make sure that our window is valid, and that our pick is within the
             // "visible area" of the Window.
-            if(!win ||
-              (win->getVisibilityMode()==Window::VM_PARTIAL && !win->isPointerXYWithinVisible(x, y))) 
-            {
+            if(
+                !win ||
+                (win->getVisibilityMode() == Window::VM_PARTIAL && !win->isPointerXYWithinVisible(x, y))
+            ) {
                 continue;
             }
@@ -334 +318 @@
     return false;
 }
+
+/*
+bool WindowManager::pickAtXY(float x, float y, WidgetList& wl) {
+    Intersections intr;
+
+    if(!_view->computeIntersections(x, y, intr, _nodeMask)) return false;
+
+    typedef std::vector<osg::observer_ptr<Window> > WindowVector;
+
+    WindowVector windows;
+
+    Window* activeWin = 0;
+
+    for(Intersections::iterator i = intr.begin(); i != intr.end(); i++) {
+        Window* win = dynamic_cast<Window*>(i->nodePath.back()->getParent(0));
+
+        if(
+            !win ||
+            (win->getVisibilityMode() == Window::VM_PARTIAL && !win->isPointerXYWithinVisible(x, y))
+        ) {
+            continue;
+        }
+
+        if(activeWin != win) {
+            activeWin = win;
+
+            windows.push_back(win);
+        }
+    }
+
+    if(!windows.size()) return false;
+
+    std::sort(windows.begin(), windows.end(), WindowBinNumberCompare());
+
+    for(WindowVector::iterator i = windows.begin(); i != windows.end(); i++) {
+        warn() << "- " << i->get()->getName() << " " << i->get()->getOrCreateStateSet()->getBinNumber() << std::endl;
+    }
+        
+    warn() << std::endl;
+
+    return false;
+}
+*/
 
 bool WindowManager::setFocused(Window* window) {
@@ -372 +399 @@
     // add 2 additional Windows here for anything that should appear in the background
     // and foreground areas.
-    matrix_type zRange = (_zNear - _zFar) / (focusable.size() + 2.0f);
+    matrix_type zRange = 1.0f / (focusable.size() + 2.0f);
 
     // Our offset for the following for() loop.
@@ -458 +485 @@
 }
 
+// Returns the application window coordinates of the WindowManager XY position.
+XYCoord WindowManager::windowXY(double x, double y) const {
+    return XYCoord((_windowWidth / _width) * x, (_windowHeight / _height) * y);
+}
+
+// Returns the WindowManager coordinates of the application window XY position.
+XYCoord WindowManager::localXY(double x, double y) const {
+    return XYCoord((_width / _windowWidth) * x, (_height / _windowHeight) * y);
+}
+
 // This is called by a ViewerEventHandler/MouseHandler (or whatever) as the pointer moves
 // around and intersects with objects. It also resets our state data (_widget, _leftDown,
@@ -575 +612 @@
 // width and height.
 osg::Camera* WindowManager::createParentOrthoCamera() {
-    osg::Camera* camera = 0;
-
-    if(isInvertedY()) camera = createInvertedYOrthoCamera(_width, _height);
-
-    else camera = createOrthoCamera(_width, _height);
+    osg::Camera* camera = createOrthoCamera(_width, _height);
 
     camera->addChild(this);