Canvas: Respect clipping while event handling.

[simgear.git] / simgear / canvas / elements / CanvasGroup.hxx

diff --git a/simgear/canvas/elements/CanvasGroup.hxx b/simgear/canvas/elements/CanvasGroup.hxx
index d57cea71d0d10c29ea6ab9abec598b5c40cbd6e7..74adeafe6a7270511a1bff7b13f33b44162c257c 100644 (file)
--- a/simgear/canvas/elements/CanvasGroup.hxx
+++ b/simgear/canvas/elements/CanvasGroup.hxx
@@ -21,44 +21,102 @@
 
 #include "CanvasElement.hxx"
 
-#include <boost/shared_ptr.hpp>
 #include <list>
-#include <map>
 
 namespace simgear
 {
 namespace canvas
 {
 
-  typedef boost::shared_ptr<Element> ElementPtr;
+  typedef std::map<std::string, ElementFactory> ElementFactories;
 
   class Group:
     public Element
   {
     public:
+      static const std::string TYPE_NAME;
+      static void staticInit();
+
       typedef std::list< std::pair< const SGPropertyNode*,
                                     ElementPtr
                                   >
                        > ChildList;
 
       Group( const CanvasWeakPtr& canvas,
-             SGPropertyNode_ptr node,
-             const Style& parent_style = Style() );
+             const SGPropertyNode_ptr& node,
+             const Style& parent_style = Style(),
+             Element* parent = 0 );
       virtual ~Group();
 
+      ElementPtr createChild( const std::string& type,
+                              const std::string& id = "" );
+      ElementPtr getChild(const SGPropertyNode* node);
+      ElementPtr getChild(const std::string& id);
+      ElementPtr getOrCreateChild( const std::string& type,
+                                   const std::string& id );
+
+      template<class T>
+      boost::shared_ptr<T> createChild(const std::string& id = "")
+      {
+        return boost::dynamic_pointer_cast<T>( createChild(T::TYPE_NAME, id) );
+      }
+
+      template<class T>
+      boost::shared_ptr<T> getChild(const SGPropertyNode* node)
+      {
+        return boost::dynamic_pointer_cast<T>( getChild(node) );
+      }
+
+      template<class T>
+      boost::shared_ptr<T> getChild(const std::string& id)
+      {
+        return boost::dynamic_pointer_cast<T>( getChild(id) );
+      }
+
+      template<class T>
+      boost::shared_ptr<T> getOrCreateChild(const std::string& id)
+      {
+        return
+          boost::dynamic_pointer_cast<T>( getOrCreateChild(T::TYPE_NAME, id) );
+      }
+
+      /**
+       * Get first child with given id (breadth-first search)
+       *
+       * @param id  Id (value if property node 'id') of element
+       */
+      ElementPtr getElementById(const std::string& id);
+
+      virtual void clearEventListener();
+
       virtual void update(double dt);
 
+      virtual bool traverse(EventVisitor& visitor);
+
+      virtual bool setStyle( const SGPropertyNode* child,
+                             const StyleInfo* style_info = 0 );
+
+      virtual osg::BoundingBox getTransformedBounds(const osg::Matrix& m) const;
+
     protected:
 
-      ChildList _children;
+      static ElementFactories   _child_factories;
 
-      virtual bool handleLocalMouseEvent(const canvas::MouseEvent& event);
+      /**
+       * Overload in derived classes to allow for more/other types of elements
+       * to be managed.
+       */
+      virtual ElementFactory getChildFactory(const std::string& type) const;
 
       virtual void childAdded(SGPropertyNode * child);
       virtual void childRemoved(SGPropertyNode * child);
       virtual void childChanged(SGPropertyNode * child);
 
-      void handleZIndexChanged(SGPropertyNode* node, int z_index);
+      void handleZIndexChanged(ElementPtr child, int z_index = 0);
+
+      ElementPtr getChildByIndex(size_t index) const;
+      ElementPtr findChild( const SGPropertyNode* node,
+                            const std::string& id ) const;
   };
 
 } // namespace canvas