Canvas: base Elements/Canvas on SGWeakReferenced.

simgear/canvas/Canvas.cxx

@@ -48,8 +48,12 @@ namespace canvas
   void Canvas::CullCallback::operator()( osg::Node* node,
                                          osg::NodeVisitor* nv )
   {
-    if( (nv->getTraversalMask() & simgear::MODEL_BIT) && !_canvas.expired() )
-      _canvas.lock()->enableRendering();
+    if( (nv->getTraversalMask() & simgear::MODEL_BIT) )
+    {
+      CanvasPtr canvas = _canvas.lock();
+      if( canvas )
+        canvas->enableRendering();
+    }
 
     traverse(node, nv);
   }
@@ -72,6 +76,13 @@ namespace canvas
   {
     _status = 0;
     setStatusFlags(MISSING_SIZE_X | MISSING_SIZE_Y);
+
+    _root_group.reset( new Group(this, _node) );
+
+    // Remove automatically created property listener as we forward them on our
+    // own
+    _root_group->removeListener();
+    _cull_callback = new CullCallback(this);
   }
 
   //----------------------------------------------------------------------------
@@ -239,21 +250,23 @@ namespace canvas
 
     if( _visible || _render_always )
     {
-      BOOST_FOREACH(CanvasWeakPtr canvas, _child_canvases)
+      BOOST_FOREACH(CanvasWeakPtr canvas_weak, _child_canvases)
       {
         // TODO should we check if the image the child canvas is displayed
         //      within is really visible?
-        if( !canvas.expired() )
-          canvas.lock()->_visible = true;
+        CanvasPtr canvas = canvas_weak.lock();
+        if( canvas )
+          canvas->_visible = true;
       }
 
       if( _render_dirty )
       {
         // Also mark all canvases this canvas is displayed within as dirty
-        BOOST_FOREACH(CanvasWeakPtr canvas, _parent_canvases)
+        BOOST_FOREACH(CanvasWeakPtr canvas_weak, _parent_canvases)
         {
-          if( !canvas.expired() )
-            canvas.lock()->_render_dirty = true;
+          CanvasPtr canvas = canvas_weak.lock();
+          if( canvas )
+            canvas->_render_dirty = true;
         }
       }
 
@@ -296,11 +309,7 @@ namespace canvas
       if( placement_factory != _placement_factories.end() )
       {
         Placements& placements = _placements[ node->getIndex() ] =
-          placement_factory->second
-          (
-            node,
-            boost::static_pointer_cast<Canvas>(_self.lock())
-          );
+          placement_factory->second(node, this);
         node->setStringValue
         (
           "status-msg",
@@ -613,23 +622,6 @@ namespace canvas
     return _system_adapter;
   }
 
-  //----------------------------------------------------------------------------
-  void Canvas::setSelf(const PropertyBasedElementPtr& self)
-  {
-    PropertyBasedElement::setSelf(self);
-
-    CanvasPtr canvas = boost::static_pointer_cast<Canvas>(self);
-
-    _root_group.reset( new Group(canvas, _node) );
-    _root_group->setSelf(_root_group);
-
-    // Remove automatically created property listener as we forward them on our
-    // own
-    _root_group->removeListener();
-
-    _cull_callback = new CullCallback(canvas);
-  }
-
   //----------------------------------------------------------------------------
   void Canvas::setStatusFlags(unsigned int flags, bool set)
   {

simgear/canvas/Canvas.hxx

@@ -205,7 +205,6 @@ namespace canvas
       typedef std::map<std::string, PlacementFactory> PlacementFactoryMap;
       static PlacementFactoryMap _placement_factories;
 
-      virtual void setSelf(const PropertyBasedElementPtr& self);
       void setStatusFlags(unsigned int flags, bool set = true);
 
     private:

simgear/canvas/CanvasEventVisitor.cxx

@@ -20,7 +20,6 @@
 #include "CanvasEvent.hxx"
 #include "CanvasEventVisitor.hxx"
 #include <simgear/canvas/elements/CanvasElement.hxx>
-#include <iostream>
 
 namespace simgear
 {
@@ -73,7 +72,7 @@ namespace canvas
           && !el.hitBound(_target_path.front().local_pos, pos, local_pos) )
         return false;
 
-      EventTarget target = {el.getWeakPtr(), local_pos};
+      EventTarget target = {ElementPtr(&el), local_pos};
       _target_path.push_back(target);
 
       if( el.traverse(*this) || &el == _root.get() )

simgear/canvas/CanvasMgr.cxx

@@ -45,25 +45,25 @@ namespace canvas
   //----------------------------------------------------------------------------
   CanvasPtr CanvasMgr::createCanvas(const std::string& name)
   {
-    return boost::static_pointer_cast<Canvas>( createElement(name) );
+    return static_cast<Canvas*>( createElement(name).get() );
   }
 
   //----------------------------------------------------------------------------
   CanvasPtr CanvasMgr::getCanvas(size_t index) const
   {
-    return boost::static_pointer_cast<Canvas>( getElement(index) );
+    return static_cast<Canvas*>( getElement(index).get() );
   }
 
   //----------------------------------------------------------------------------
   CanvasPtr CanvasMgr::getCanvas(const std::string& name) const
   {
-    return boost::static_pointer_cast<Canvas>( getElement(name) );
+    return static_cast<Canvas*>( getElement(name).get() );
   }
 
   //----------------------------------------------------------------------------
   void CanvasMgr::elementCreated(PropertyBasedElementPtr element)
   {
-    CanvasPtr canvas = boost::static_pointer_cast<Canvas>(element);
+    CanvasPtr canvas = static_cast<Canvas*>(element.get());
     canvas->setCanvasMgr(this);
   }
 

simgear/canvas/canvas_fwd.hxx

@@ -39,8 +39,8 @@ namespace canvas
 
 #define SG_FWD_DECL(name)\
   class name;\
-  typedef boost::shared_ptr<name> name##Ptr;\
-  typedef boost::weak_ptr<name> name##WeakPtr;
+  typedef SGSharedPtr<name> name##Ptr;\
+  typedef SGWeakPtr<name> name##WeakPtr;
 
   SG_FWD_DECL(Canvas)
   SG_FWD_DECL(Element)
@@ -50,6 +50,13 @@ namespace canvas
   SG_FWD_DECL(Path)
   SG_FWD_DECL(Text)
 
+#undef SG_FWD_DECL
+
+#define SG_FWD_DECL(name)\
+  class name;\
+  typedef boost::shared_ptr<name> name##Ptr;\
+  typedef boost::weak_ptr<name> name##WeakPtr;
+
   SG_FWD_DECL(Event)
   SG_FWD_DECL(MouseEvent)
   SG_FWD_DECL(Placement)

simgear/canvas/elements/CanvasElement.cxx

@@ -143,17 +143,6 @@ namespace canvas
     }
   }
 
-  //----------------------------------------------------------------------------
-  void Element::setSelf(const PropertyBasedElementPtr& self)
-  {
-    PropertyBasedElement::setSelf(self);
-
-    _transform->setUserData
-    (
-      new OSGUserData(boost::static_pointer_cast<Element>(self))
-    );
-  }
-
   //----------------------------------------------------------------------------
   void Element::onDestroy()
   {
@@ -168,16 +157,10 @@ namespace canvas
     }
   }
 
-  //----------------------------------------------------------------------------
-  ElementWeakPtr Element::getWeakPtr() const
-  {
-    return boost::static_pointer_cast<Element>(_self.lock());
-  }
-
   //----------------------------------------------------------------------------
   ElementPtr Element::getParent()
   {
-    return _parent ? _parent->getWeakPtr().lock() : ElementPtr();
+    return _parent;
   }
 
   //----------------------------------------------------------------------------
@@ -674,6 +657,8 @@ namespace canvas
                 "PreOrderBin",
                 osg::StateSet::OVERRIDE_RENDERBIN_DETAILS
               );
+
+    _transform->setUserData( new OSGUserData(this) );
   }
 
   //----------------------------------------------------------------------------

simgear/canvas/elements/CanvasElement.hxx

@@ -90,11 +90,8 @@ namespace canvas
        *
        */
       virtual ~Element() = 0;
-
-      virtual void setSelf(const PropertyBasedElementPtr& self);
       virtual void onDestroy();
 
-      ElementWeakPtr getWeakPtr() const;
       ElementPtr getParent();
 
       /**
@@ -200,9 +197,7 @@ namespace canvas
                       const Style& style,
                       Element* parent )
       {
-        ElementPtr el( new Derived(canvas, node, style, parent) );
-        el->setSelf(el);
-        return el;
+        return ElementPtr( new Derived(canvas, node, style, parent) );
       }
 
     protected:

simgear/canvas/elements/CanvasGroup.cxx

@@ -146,7 +146,7 @@ namespace canvas
       if( el->get<std::string>("id") == id )
         return el;
 
-      GroupPtr group = boost::dynamic_pointer_cast<Group>(el);
+      Group* group = dynamic_cast<Group*>(el.get());
       if( group )
         groups.push_back(group);
     }

simgear/canvas/elements/CanvasGroup.hxx

@@ -56,28 +56,27 @@ namespace canvas
                                    const std::string& id );
 
       template<class T>
-      boost::shared_ptr<T> createChild(const std::string& id = "")
+      SGSharedPtr<T> createChild(const std::string& id = "")
       {
-        return boost::dynamic_pointer_cast<T>( createChild(T::TYPE_NAME, id) );
+        return dynamic_cast<T*>( createChild(T::TYPE_NAME, id).get() );
       }
 
       template<class T>
-      boost::shared_ptr<T> getChild(const SGPropertyNode* node)
+      SGSharedPtr<T> getChild(const SGPropertyNode* node)
       {
-        return boost::dynamic_pointer_cast<T>( getChild(node) );
+        return dynamic_cast<T*>( getChild(node).get() );
       }
 
       template<class T>
-      boost::shared_ptr<T> getChild(const std::string& id)
+      SGSharedPtr<T> getChild(const std::string& id)
       {
-        return boost::dynamic_pointer_cast<T>( getChild(id) );
+        return dynamic_cast<T*>( getChild(id).get() );
       }
 
       template<class T>
-      boost::shared_ptr<T> getOrCreateChild(const std::string& id)
+      SGSharedPtr<T> getOrCreateChild(const std::string& id)
       {
-        return
-          boost::dynamic_pointer_cast<T>( getOrCreateChild(T::TYPE_NAME, id) );
+        return dynamic_cast<T*>( getOrCreateChild(T::TYPE_NAME, id).get() );
       }
 
       /**

simgear/canvas/elements/CanvasImage.cxx

@@ -75,8 +75,9 @@ namespace canvas
                            osg::Drawable* drawable,
                            osg::RenderInfo* renderInfo ) const
   {
-    if( !_canvas.expired() )
-      _canvas.lock()->enableRendering();
+    CanvasPtr canvas = _canvas.lock();
+    if( canvas )
+      canvas->enableRendering();
 
     if( !_cull_next_frame )
       // TODO check if window/image should be culled

simgear/props/PropertyBasedElement.cxx

@@ -65,10 +65,4 @@ namespace simgear
     return _node;
   }
 
-  //----------------------------------------------------------------------------
-  void PropertyBasedElement::setSelf(const PropertyBasedElementPtr& self)
-  {
-    _self = self;
-  }
-
 } // namespace simgear

simgear/props/PropertyBasedElement.hxx

@@ -20,24 +20,19 @@
 #define SG_PROPERTY_BASED_ELEMENT_HXX_
 
 #include <simgear/props/props.hxx>
+#include <simgear/structure/SGWeakReferenced.hxx>
 
 #include <boost/call_traits.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
-
 
 namespace simgear
 {
 
-  class PropertyBasedElement;
-  typedef boost::shared_ptr<PropertyBasedElement> PropertyBasedElementPtr;
-  typedef boost::weak_ptr<PropertyBasedElement> PropertyBasedElementWeakPtr;
-
   /**
    * Base class for a property controlled element
    */
   class PropertyBasedElement:
-    public SGPropertyChangeListener
+    public SGPropertyChangeListener,
+    public SGWeakReferenced
   {
     public:
       PropertyBasedElement(SGPropertyNode* node);
@@ -80,15 +75,20 @@ namespace simgear
         return getValue<T>(child);
       }
 
-      virtual void setSelf(const PropertyBasedElementPtr& self);
+      // Unshadow what we have just hidden...
+      using SGWeakReferenced::get;
+
       virtual void onDestroy() {};
 
     protected:
 
       SGPropertyNode_ptr _node;
-      PropertyBasedElementWeakPtr _self;
+
   };
 
+  typedef SGSharedPtr<PropertyBasedElement> PropertyBasedElementPtr;
+  typedef SGWeakPtr<PropertyBasedElement> PropertyBasedElementWeakPtr;
+
 } // namespace simgear
 
 #endif /* SG_PROPERTY_BASED_ELEMENT_HXX_ */

simgear/props/PropertyBasedMgr.cxx

@@ -140,7 +140,6 @@ namespace simgear
     }
 
     PropertyBasedElementPtr el = _element_factory(child);
-    el->setSelf( el );
     _elements[index] = el;
     elementCreated( el );
   }

simgear/props/PropertyBasedMgr.hxx

@@ -22,7 +22,6 @@
 #include "PropertyBasedElement.hxx"
 #include <simgear/structure/subsystem_mgr.hxx>
 
-#include <boost/shared_ptr.hpp>
 #include <boost/function.hpp>
 #include <vector>