Added beginnings of new osgUI library, a replacement for osgWidget that works fully in 3D/stereo and is scriptable.

src/CMakeLists.txt

@@ -7,15 +7,15 @@ IF(MSVC80 OR MSVC90)
 ENDIF()
 
 #the old construct SUBDIRS( was substituded by ADD_SUBDIRECTORY that is to be preferred according on CMake docs.
-FOREACH( mylibfolder 
+FOREACH( mylibfolder
         OpenThreads
         osg
-        osgDB 
-        osgUtil 
-        osgGA 
-        osgText 
+        osgDB
+        osgUtil
+        osgGA
+        osgText
         osgViewer
-        osgAnimation 
+        osgAnimation
         osgFX
         osgManipulator
         osgParticle
@@ -24,6 +24,7 @@ FOREACH( mylibfolder
         osgSim
         osgTerrain
         osgWidget
+        osgUI
         osgVolume
         osgWrappers/serializers
         osgWrappers/deprecated-dotosg

src/osgUI/AlignmentSettings.cpp

@@ -0,0 +1,29 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+
+#include <osgUI/Style>
+#include <osg/Geode>
+#include <osgText/Text>
+
+using namespace osgUI;
+
+AlignmentSettings::AlignmentSettings():
+    _alignment(AlignmentSettings::LEFT_BOTTOM)
+{
+}
+
+AlignmentSettings::AlignmentSettings(const AlignmentSettings& alingmentSettings, const osg::CopyOp& copyop):
+    osg::Object(alingmentSettings, copyop),
+    _alignment(alingmentSettings._alignment)
+{
+}

src/osgUI/CMakeLists.txt

@@ -0,0 +1,41 @@
+
+IF   (DYNAMIC_OPENSCENEGRAPH)
+    ADD_DEFINITIONS(-DOSGGA_LIBRARY)
+ELSE (DYNAMIC_OPENSCENEGRAPH)
+    ADD_DEFINITIONS(-DOSG_LIBRARY_STATIC)
+ENDIF(DYNAMIC_OPENSCENEGRAPH)
+
+SET(LIB_NAME osgUI)
+SET(HEADER_PATH ${OpenSceneGraph_SOURCE_DIR}/include/${LIB_NAME})
+SET(TARGET_H
+    ${HEADER_PATH}/Export
+    ${HEADER_PATH}/Widget
+    ${HEADER_PATH}/Label
+    ${HEADER_PATH}/LineEdit
+    ${HEADER_PATH}/Style
+    ${HEADER_PATH}/AlignmentSettings
+    ${HEADER_PATH}/FrameSettings
+    ${HEADER_PATH}/TextSettings
+)
+
+SET(TARGET_SRC
+    Widget.cpp
+    Label.cpp
+    LineEdit.cpp
+    Style.cpp
+    AlignmentSettings.cpp
+    FrameSettings.cpp
+    TextSettings.cpp
+    ${OPENSCENEGRAPH_VERSIONINFO_RC}
+)
+
+SET(TARGET_LIBRARIES
+    osgDB
+    osgUtil
+    osgText
+    osg
+    OpenThreads
+)
+
+SETUP_LIBRARY(${LIB_NAME})
+

src/osgUI/FrameSettings.cpp

@@ -0,0 +1,31 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+
+#include <osgUI/FrameSettings>
+
+using namespace osgUI;
+
+FrameSettings::FrameSettings():
+    _shape(FrameSettings::NO_FRAME),
+    _shadow(FrameSettings::PLAIN),
+    _lineWidth(0.01)
+{
+}
+
+FrameSettings::FrameSettings(const FrameSettings& frameSettings, const osg::CopyOp& copyop):
+    osg::Object(frameSettings, copyop),
+    _shape(frameSettings._shape),
+    _shadow(frameSettings._shadow),
+    _lineWidth(frameSettings._lineWidth)
+{
+}

src/osgUI/Label.cpp

@@ -0,0 +1,40 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+
+
+#include <osgUI/Label>
+#include <osgText/String>
+#include <osgText/Font>
+#include <osgText/Text>
+
+using namespace osgUI;
+
+Label::Label()
+{
+}
+
+Label::Label(const osgUI::Label& label, const osg::CopyOp& copyop):
+    Widget(label, copyop),
+    _text(label._text)
+{
+}
+
+void Label::createGraphicsImplementation()
+{
+    OSG_NOTICE<<"Label::createGraphicsImplementation()"<<std::endl;
+
+    Widget::createGraphicsImplementation();
+
+    Style* style = (getStyle()!=0) ? getStyle() : Style::instance().get();
+    addChild(style->createText(_extents, getAlignmentSettings(), getTextSettings(), _text));
+}

src/osgUI/LineEdit.cpp

@@ -0,0 +1,69 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+
+
+#include <osgUI/LineEdit>
+#include <osgText/String>
+#include <osgText/Font>
+#include <osgText/Text>
+
+using namespace osgUI;
+
+LineEdit::LineEdit()
+{
+}
+
+LineEdit::LineEdit(const osgUI::LineEdit& label, const osg::CopyOp& copyop):
+    Widget(label, copyop),
+    _text(label._text)
+{
+}
+
+bool LineEdit::handleImplementation(osgGA::EventVisitor* ev, osgGA::Event* event)
+{
+    osgGA::GUIEventAdapter* ea = event->asGUIEventAdapter();
+    if (!ea) return false;
+
+    switch(ea->getEventType())
+    {
+        case(osgGA::GUIEventAdapter::KEYDOWN):
+            if (ea->getKey()==osgGA::GUIEventAdapter::KEY_BackSpace ||
+                ea->getKey()==osgGA::GUIEventAdapter::KEY_Delete)
+            {
+                if (!_text.empty()) _text.erase(_text.size()-1, 1);
+            }
+            else if (ea->getKey()>=32 && ea->getKey()<=0xff00)
+            {
+                _text.push_back(ea->getKey());
+            }
+            dirty();
+            break;
+        default:
+            break;
+    }
+
+    return false;
+}
+
+void LineEdit::createGraphicsImplementation()
+{
+    OSG_NOTICE<<"LineEdit::createGraphicsImplementation()"<<std::endl;
+
+    Widget::createGraphicsImplementation();
+
+    Style* style = (getStyle()!=0) ? getStyle() : Style::instance().get();
+
+    removeChildren(0, getNumChildren());
+
+    addChild(style->createText(_extents, getAlignmentSettings(), getTextSettings(), _text));
+}

src/osgUI/Style.cpp

@@ -0,0 +1,75 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+
+#include <osgUI/Style>
+#include <osg/Geode>
+#include <osgText/Text>
+
+using namespace osgUI;
+
+osg::ref_ptr<Style>& Style::instance()
+{
+    static osg::ref_ptr<Style> s_style = new Style;
+    return s_style;
+}
+
+OSG_INIT_SINGLETON_PROXY(StyleSingletonProxy, Style::instance())
+
+Style::Style()
+{
+}
+
+Style::Style(const Style& style, const osg::CopyOp& copyop):
+    osg::Object(style, copyop)
+{
+}
+
+osg::Node* Style::createPanel(const osg::BoundingBox& extents, const osg::Vec4& colour)
+{
+    return 0;
+}
+
+osg::Node* Style::createFrame(const osg::BoundingBox& extents, const FrameSettings* frameSettings)
+{
+    return 0;
+}
+
+osg::Node* Style::createText(const osg::BoundingBox& extents, const AlignmentSettings* as, const TextSettings* ts, const std::string& text)
+{
+    osg::ref_ptr<osg::Geode> textGeode = new osg::Geode;
+    osg::ref_ptr<osgText::Text> textDrawable = new osgText::Text;
+
+    textGeode->addDrawable(textDrawable.get());
+
+    textDrawable->setText(text);
+
+    if (ts)
+    {
+        textDrawable->setFont(ts->getFont());
+        textDrawable->setCharacterSize(ts->getCharacterSize());
+    }
+
+    if (as)
+    {
+        osgText::TextBase::AlignmentType alignmentType = static_cast<osgText::TextBase::AlignmentType>(as->getAlignment());
+        textDrawable->setAlignment(alignmentType);
+    }
+
+    return textGeode.release();
+}
+
+osg::Node* Style::createIcon(const osg::BoundingBox& extents, const std::string& filename)
+{
+    return 0;
+}
+

src/osgUI/TextSettings.cpp

@@ -0,0 +1,31 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+
+#include <osgUI/TextSettings>
+#include <osg/Geode>
+#include <osgText/Text>
+
+using namespace osgUI;
+
+TextSettings::TextSettings():
+    _characterSize(1.0)
+{
+}
+
+TextSettings::TextSettings(const TextSettings& textSettings, const osg::CopyOp& copyop):
+    osg::Object(textSettings, copyop),
+    _font(textSettings._font),
+    _characterSize(textSettings._characterSize)
+{
+}
+

src/osgUI/Widget.cpp

@@ -0,0 +1,331 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
+ *
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * OpenSceneGraph Public License for more details.
+*/
+
+
+#include <osg/Geode>
+#include <osg/ScriptEngine>
+#include <osg/Geometry>
+#include <osg/MatrixTransform>
+#include <osg/ValueObject>
+#include <osg/io_utils>
+
+#include <osgUI/Widget>
+#include <osgGA/EventVisitor>
+#include <osgGA/GUIActionAdapter>
+
+using namespace osgUI;
+
+Widget::Widget():
+    _focusBehaviour(FOCUS_FOLLOWS_POINTER),
+    _hasEventFocus(false),
+    _graphicsInitialized(false)
+{
+    setNumChildrenRequiringEventTraversal(1);
+}
+
+Widget::Widget(const Widget& widget, const osg::CopyOp& copyop):
+    osg::Group(),
+    _focusBehaviour(widget._focusBehaviour),
+    _hasEventFocus(false),
+    _graphicsInitialized(false),
+    _alignmentSettings(osg::clone(widget._alignmentSettings.get(), copyop)),
+    _frameSettings(osg::clone(widget._frameSettings.get(), copyop)),
+    _textSettings(osg::clone(widget._textSettings.get(), copyop))
+{
+    setNumChildrenRequiringEventTraversal(1);
+}
+
+void Widget::setExtents(const osg::BoundingBoxf& bb)
+{
+    _extents = bb;
+}
+
+void Widget::updateFocus(osg::NodeVisitor& nv)
+{
+    osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(&nv);
+    osgGA::GUIActionAdapter* aa = ev ? ev->getActionAdapter() : 0;
+    if (ev && aa)
+    {
+        osgGA::EventQueue::Events& events = ev->getEvents();
+        for(osgGA::EventQueue::Events::iterator itr = events.begin();
+            itr != events.end();
+            ++itr)
+        {
+            osgGA::GUIEventAdapter* ea = (*itr)->asGUIEventAdapter();
+            if (ea)
+            {
+                bool previousFocus = _hasEventFocus;
+                if (_focusBehaviour==CLICK_TO_FOCUS)
+                {
+                    if (ea->getEventType()==osgGA::GUIEventAdapter::PUSH)
+                    {
+                        int numButtonsPressed = 0;
+                        if (ea->getButtonMask()&osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON) ++numButtonsPressed;
+                        if (ea->getButtonMask()&osgGA::GUIEventAdapter::MIDDLE_MOUSE_BUTTON) ++numButtonsPressed;
+                        if (ea->getButtonMask()&osgGA::GUIEventAdapter::RIGHT_MOUSE_BUTTON) ++numButtonsPressed;
+
+                        if (numButtonsPressed==1)
+                        {
+                            osgUtil::LineSegmentIntersector::Intersections intersections;
+                            bool withinWidget = aa->computeIntersections(*ea, nv.getNodePath(), intersections);
+                            if (withinWidget) _hasEventFocus = true;
+                            else _hasEventFocus = false;
+                        }
+                    }
+                }
+                else if (_focusBehaviour==FOCUS_FOLLOWS_POINTER)
+                {
+                    bool checkWithinWidget = false;
+                    if (!_hasEventFocus)
+                    {
+                        checkWithinWidget = (ea->getEventType()!=osgGA::GUIEventAdapter::FRAME) && ea->getButtonMask()==0;
+                    }
+                    else
+                    {
+                        // if mouse move or mouse release check to see if mouse still within widget to retain focus
+                        if (ea->getEventType()==osgGA::GUIEventAdapter::MOVE)
+                        {
+                            checkWithinWidget = true;
+                        }
+                        else if (ea->getEventType()==osgGA::GUIEventAdapter::RELEASE)
+                        {
+                            // if no buttons pressed then check
+                            if (ea->getButtonMask()==0) checkWithinWidget = true;
+                        }
+                    }
+
+                    if (checkWithinWidget)
+                    {
+                        osgUtil::LineSegmentIntersector::Intersections intersections;
+                        bool withinWidget = aa->computeIntersections(*ea, nv.getNodePath(), intersections);
+
+                        _hasEventFocus = withinWidget;
+                    }
+                }
+
+                if (previousFocus != _hasEventFocus)
+                {
+                    if (_hasEventFocus)
+                    {
+                        enter();
+#if 0
+                        if (view->getCameraManipulator())
+                        {
+                            view->getCameraManipulator()->finishAnimation();
+                            view->requestContinuousUpdate( false );
+                        }
+#endif
+                    }
+                    else
+                    {
+                        leave();
+                    }
+                }
+
+            }
+        }
+    }
+}
+
+void Widget::setHasEventFocus(bool focus)
+{
+    if (_hasEventFocus == focus) return;
+
+    _hasEventFocus = focus;
+
+    if (_hasEventFocus) enter();
+    else leave();
+}
+
+bool Widget::getHasEventFocus() const
+{
+    return _hasEventFocus;
+}
+
+void Widget::enter()
+{
+    osg::CallbackObject* co = osg::getCallbackObject(this, "enter");
+    if (co)
+    {
+        co->run(this);
+    }
+    else
+    {
+        enterImplementation();
+    }
+}
+
+void Widget::enterImplementation()
+{
+    OSG_NOTICE<<"enter()"<<std::endl;
+}
+
+void Widget::leave()
+{
+    osg::CallbackObject* co = osg::getCallbackObject(this, "leave");
+    if (co)
+    {
+        co->run(this);
+    }
+    else
+    {
+        leaveImplementation();
+    }
+}
+
+void Widget::leaveImplementation()
+{
+    OSG_NOTICE<<"leave()"<<std::endl;
+}
+
+void Widget::traverse(osg::NodeVisitor& nv)
+{
+    osg::CallbackObject* co = osg::getCallbackObject(this, "traverse");
+    if (co)
+    {
+        // currently lua scripting takes a ref count so messes up handling of NodeVisitor's created on stack,
+        // so don't attempt to call the sctipt.
+        if (nv.referenceCount()==0)
+        {
+            traverseImplementation(nv);
+            return;
+        }
+
+        osg::Parameters inputParameters, outputParameters;
+        inputParameters.push_back(&nv);
+        co->run(this, inputParameters, outputParameters);
+    }
+    else
+    {
+        traverseImplementation(nv);
+    }
+}
+
+void Widget::traverseImplementation(osg::NodeVisitor& nv)
+{
+    if (!_graphicsInitialized && nv.getVisitorType()!=osg::NodeVisitor::CULL_VISITOR) createGraphics();
+
+
+    osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(&nv);
+    if (ev)
+    {
+        updateFocus(nv);
+
+        if (getHasEventFocus())
+        {
+            // signify that event has been taken by widget with focus
+            ev->setEventHandled(true);
+
+            osgGA::EventQueue::Events& events = ev->getEvents();
+            for(osgGA::EventQueue::Events::iterator itr = events.begin();
+                itr != events.end();
+                ++itr)
+            {
+                if (handle(ev, itr->get()))
+                {
+                    (*itr)->setHandled(true);
+                }
+            }
+        }
+    }
+    else
+    {
+        osg::Group::traverse(nv);
+    }
+}
+
+bool Widget::handle(osgGA::EventVisitor* ev, osgGA::Event* event)
+{
+    osg::CallbackObject* co = osg::getCallbackObject(this, "handle");
+    if (co)
+    {
+        // currently lua scripting takes a ref count so messes up handling of NodeVisitor's created on stack,
+        // so don't attempt to call the sctipt.
+        if (ev->referenceCount()==0)
+        {
+            return handleImplementation(ev, event);
+        }
+
+        osg::Parameters inputParameters, outputParameters;
+        inputParameters.push_back(ev);
+        inputParameters.push_back(event);
+        if (co->run(this, inputParameters, outputParameters))
+        {
+            if (outputParameters.size()>=1)
+            {
+                osg::BoolValueObject* bvo = dynamic_cast<osg::BoolValueObject*>(outputParameters[0].get());
+                if (bvo)
+                {
+                    return bvo->getValue();
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+    else
+    {
+        return handleImplementation(ev, event);
+    }
+}
+
+bool Widget::handleImplementation(osgGA::EventVisitor* ev, osgGA::Event* event)
+{
+    return false;
+}
+
+bool Widget::computePositionInLocalCoordinates(osgGA::EventVisitor* ev, osgGA::GUIEventAdapter* event, osg::Vec3& localPosition) const
+{
+    osgGA::GUIActionAdapter* aa = ev ? ev->getActionAdapter() : 0;
+    osgUtil::LineSegmentIntersector::Intersections intersections;
+    if (aa && aa->computeIntersections(*event, ev->getNodePath(), intersections))
+    {
+        localPosition = intersections.begin()->getLocalIntersectPoint();
+
+        return (_extents.contains(localPosition, 1e-6));
+    }
+    else
+    {
+        return false;
+    }
+}
+
+void Widget::dirty()
+{
+    _graphicsInitialized = false;
+}
+
+void Widget::createGraphics()
+{
+    osg::CallbackObject* co = osg::getCallbackObject(this, "createGraphics");
+    if (co)
+    {
+        co->run(this);
+    }
+    else
+    {
+        createGraphicsImplementation();
+    }
+
+}
+
+void Widget::createGraphicsImplementation()
+{
+    _graphicsInitialized = true;
+}
+
+osg::BoundingSphere Widget::computeBound() const
+{
+    if (_extents.valid()) return osg::BoundingSphere(_extents);
+    else return osg::Group::computeBound();
+}

src/osgWrappers/serializers/CMakeLists.txt

@@ -50,3 +50,4 @@ ADD_SUBDIRECTORY(osgText)
 ADD_SUBDIRECTORY(osgVolume)
 ADD_SUBDIRECTORY(osgPresentation)
 ADD_SUBDIRECTORY(osgViewer)
+ADD_SUBDIRECTORY(osgUI)

src/osgWrappers/serializers/osgUI/AlignmentSettings.cpp

@@ -0,0 +1,31 @@
+#include <osgUI/AlignmentSettings>
+#include <osg/ValueObject>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+
+
+REGISTER_OBJECT_WRAPPER( AlignmentSettings,
+                         new osgUI::AlignmentSettings,
+                         osgUI::AlignmentSettings,
+                         "osg::Object osgUI::AlignmentSettings" )
+{
+    BEGIN_ENUM_SERIALIZER2( Alignment, osgUI::AlignmentSettings::Alignment, LEFT_BOTTOM );
+        ADD_ENUM_VALUE( LEFT_TOP );
+        ADD_ENUM_VALUE( LEFT_CENTER );
+        ADD_ENUM_VALUE( LEFT_BOTTOM );
+        ADD_ENUM_VALUE( CENTER_TOP );
+        ADD_ENUM_VALUE( CENTER_CENTER );
+        ADD_ENUM_VALUE( CENTER_BOTTOM );
+        ADD_ENUM_VALUE( RIGHT_TOP );
+        ADD_ENUM_VALUE( RIGHT_CENTER );
+        ADD_ENUM_VALUE( RIGHT_BOTTOM );
+        ADD_ENUM_VALUE( LEFT_BASE_LINE );
+        ADD_ENUM_VALUE( CENTER_BASE_LINE );
+        ADD_ENUM_VALUE( RIGHT_BASE_LINE );
+        ADD_ENUM_VALUE( LEFT_BOTTOM_BASE_LINE );
+        ADD_ENUM_VALUE( CENTER_BOTTOM_BASE_LINE );
+        ADD_ENUM_VALUE( RIGHT_BOTTOM_BASE_LINE );
+    END_ENUM_SERIALIZER();  // _alignment
+}

src/osgWrappers/serializers/osgUI/CMakeLists.txt

@@ -0,0 +1,7 @@
+FILE(GLOB TARGET_SRC *.cpp)
+FILE(GLOB TARGET_H *.h)
+
+SET(TARGET_ADDED_LIBRARIES osgUI )
+
+#### end var setup  ###
+SETUP_PLUGIN(osgui)

src/osgWrappers/serializers/osgUI/FrameSettings.cpp

@@ -0,0 +1,27 @@
+#include <osgUI/FrameSettings>
+#include <osg/ValueObject>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+
+
+REGISTER_OBJECT_WRAPPER( FrameSettings,
+                         new osgUI::FrameSettings,
+                         osgUI::FrameSettings,
+                         "osg::Object osgUI::FrameSettings" )
+{
+    BEGIN_ENUM_SERIALIZER2( Shape, osgUI::FrameSettings::Shape, NO_FRAME );
+        ADD_ENUM_VALUE( NO_FRAME );
+        ADD_ENUM_VALUE( BOX );
+        ADD_ENUM_VALUE( PANEL );
+    END_ENUM_SERIALIZER();
+
+    BEGIN_ENUM_SERIALIZER2( Shadow, osgUI::FrameSettings::Shadow, PLAIN );
+        ADD_ENUM_VALUE( PLAIN );
+        ADD_ENUM_VALUE( SUNKEN );
+        ADD_ENUM_VALUE( RAISED );
+    END_ENUM_SERIALIZER();
+
+    ADD_FLOAT_SERIALIZER( LineWidth, 0.01);
+}

src/osgWrappers/serializers/osgUI/Label.cpp

@@ -0,0 +1,15 @@
+#include <osgUI/Label>
+#include <osg/ValueObject>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+
+REGISTER_OBJECT_WRAPPER( Label,
+                         new osgUI::Label,
+                         osgUI::Label,
+                         "osg::Object osg::Node osg::Group osgUI::Widget osgUI::Label" )
+{
+    ADD_STRING_SERIALIZER( Text, std::string());
+
+}

src/osgWrappers/serializers/osgUI/LineEdit.cpp

@@ -0,0 +1,14 @@
+#include <osgUI/LineEdit>
+#include <osg/ValueObject>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+
+REGISTER_OBJECT_WRAPPER( LineEdit,
+                         new osgUI::LineEdit,
+                         osgUI::LineEdit,
+                         "osg::Object osg::Node osg::Group osgUI::Widget osgUI::LineEdit" )
+{
+    ADD_STRING_SERIALIZER( Text, std::string());
+}

src/osgWrappers/serializers/osgUI/TextSettings.cpp

@@ -0,0 +1,16 @@
+#include <osgUI/TextSettings>
+#include <osg/ValueObject>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+
+
+REGISTER_OBJECT_WRAPPER( TextSettings,
+                         new osgUI::TextSettings,
+                         osgUI::TextSettings,
+                         "osg::Object osgUI::TextSettings" )
+{
+    ADD_STRING_SERIALIZER( Font, std::string());
+    ADD_FLOAT_SERIALIZER( CharacterSize, 0.0f);
+}

src/osgWrappers/serializers/osgUI/Widget.cpp

@@ -0,0 +1,155 @@
+#include <osgUI/Widget>
+#include <osg/ValueObject>
+#include <osgDB/ObjectWrapper>
+#include <osgDB/InputStream>
+#include <osgDB/OutputStream>
+
+
+struct CreateGraphics : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters&, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        widget->createGraphics();
+        return true;
+    }
+};
+
+struct CreateGraphicsImplementation : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters&, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        widget->createGraphicsImplementation();
+        return true;
+    }
+};
+
+struct Enter : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters&, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        widget->enter();
+        return true;
+    }
+};
+
+struct EnterImplementation : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters&, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        widget->enterImplementation();
+        return true;
+    }
+};
+
+struct Leave : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters&, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        widget->leave();
+        return true;
+    }
+};
+
+struct LeaveImplementation : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters&, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        widget->leaveImplementation();
+        return true;
+    }
+};
+
+
+struct Traverse : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters& inputParameters, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        osg::NodeVisitor* nv = (inputParameters.size()>=1) ? dynamic_cast<osg::NodeVisitor*>(inputParameters[0].get()) : 0;
+        if (!nv) return false;
+        widget->traverse(*nv);
+        return true;
+    }
+};
+
+struct TraverseImplementation : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters& inputParameters, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        osg::NodeVisitor* nv = (inputParameters.size()>=1) ? dynamic_cast<osg::NodeVisitor*>(inputParameters[0].get()) : 0;
+        if (!nv) return false;
+        widget->traverseImplementation(*nv);
+        return true;
+    }
+};
+
+struct Handle : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters& inputParameters, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        osgGA::EventVisitor* ev = (inputParameters.size()>=1) ? dynamic_cast<osgGA::EventVisitor*>(inputParameters[0].get()) : 0;
+        osgGA::Event* event = (inputParameters.size()>=2) ? dynamic_cast<osgGA::Event*>(inputParameters[1].get()) : 0;
+        if (!widget || !ev || !event) return false;
+        widget->handle(ev, event);
+        return true;
+    }
+};
+
+struct HandleImplementation : public osgDB::MethodObject
+{
+    virtual bool run(void* objectPtr, osg::Parameters& inputParameters, osg::Parameters&) const
+    {
+        osgUI::Widget* widget = reinterpret_cast<osgUI::Widget*>(objectPtr);
+        osgGA::EventVisitor* ev = (inputParameters.size()>=1) ? dynamic_cast<osgGA::EventVisitor*>(inputParameters[0].get()) : 0;
+        osgGA::Event* event = (inputParameters.size()>=2) ? dynamic_cast<osgGA::Event*>(inputParameters[1].get()) : 0;
+        if (!widget || !ev || !event) return false;
+        widget->handleImplementation(ev, event);
+        return true;
+    }
+};
+
+
+REGISTER_OBJECT_WRAPPER( Widget,
+                         new osgUI::Widget,
+                         osgUI::Widget,
+                         "osg::Object osg::Node osg::Group osgUI::Widget" )
+{
+    BEGIN_ENUM_SERIALIZER( FocusBehaviour, FOCUS_FOLLOWS_POINTER );
+        ADD_ENUM_VALUE( CLICK_TO_FOCUS );
+        ADD_ENUM_VALUE( FOCUS_FOLLOWS_POINTER );
+        ADD_ENUM_VALUE( EVENT_DRIVEN_FOCUS_DISABLED );
+    END_ENUM_SERIALIZER();
+
+    ADD_BOOL_SERIALIZER(HasEventFocus, false);
+
+    ADD_BOUNDINGBOXF_SERIALIZER(Extents, osg::BoundingBoxf());
+
+    ADD_OBJECT_SERIALIZER( FrameSettings, osgUI::FrameSettings, NULL );
+    ADD_OBJECT_SERIALIZER( AlignmentSettings, osgUI::AlignmentSettings, NULL );
+    ADD_OBJECT_SERIALIZER( TextSettings, osgUI::TextSettings, NULL );
+
+
+    ADD_METHOD_OBJECT( "createGraphics", CreateGraphics );
+    ADD_METHOD_OBJECT( "createGraphicsImplementation", CreateGraphicsImplementation );
+
+    ADD_METHOD_OBJECT( "enter", Enter );
+    ADD_METHOD_OBJECT( "enterImplementation", EnterImplementation );
+
+    ADD_METHOD_OBJECT( "leave", Leave );
+    ADD_METHOD_OBJECT( "leaveImplementation", LeaveImplementation );
+
+    ADD_METHOD_OBJECT( "traverse", Traverse );
+    ADD_METHOD_OBJECT( "traverseImplementation", TraverseImplementation );
+
+    ADD_METHOD_OBJECT( "handle", Handle );
+    ADD_METHOD_OBJECT( "handleImplementation", HandleImplementation );
+
+}