simgear/canvas/Canvas.hxx

   1 // The canvas for rendering with the 2d API
   2 //
   3 // Copyright (C) 2012  Thomas Geymayer <tomgey@gmail.com>
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Library General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2 of the License, or (at your option) any later version.
   9 //
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // Library General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Library General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  18
  19 #ifndef CANVAS_HXX_
  20 #define CANVAS_HXX_
  21
  22 #include "canvas_fwd.hxx"
  23 #include "ODGauge.hxx"
  24
  25 #include <simgear/canvas/elements/CanvasGroup.hxx>
  26 #include <simgear/math/SGRect.hxx>
  27 #include <simgear/props/PropertyBasedElement.hxx>
  28 #include <simgear/props/propertyObject.hxx>
  29 #include <osg/NodeCallback>
  30 #include <osg/observer_ptr>
  31
  32 #include <memory>
  33 #include <string>
  34
  35 namespace simgear
  36 {
  37 namespace canvas
  38 {
  39   class CanvasMgr;
  40   class MouseEvent;
  41
  42   class Canvas:
  43     public PropertyBasedElement
  44   {
  45     public:
  46
  47       enum StatusFlags
  48       {
  49         STATUS_OK,
  50         STATUS_DIRTY     = 1,
  51         MISSING_SIZE_X = STATUS_DIRTY << 1,
  52         MISSING_SIZE_Y = MISSING_SIZE_X << 1,
  53         CREATE_FAILED  = MISSING_SIZE_Y << 1
  54       };
  55
  56       /**
  57        * This callback is installed on every placement of the canvas in the
  58        * scene to only render the canvas if at least one placement is visible
  59        */
  60       class CullCallback:
  61         public osg::NodeCallback
  62       {
  63         public:
  64           CullCallback(const CanvasWeakPtr& canvas);
  65
  66         private:
  67           CanvasWeakPtr _canvas;
  68
  69           virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
  70       };
  71       typedef osg::ref_ptr<CullCallback> CullCallbackPtr;
  72
  73       Canvas(SGPropertyNode* node);
  74       virtual ~Canvas();
  75
  76       void setSystemAdapter(const SystemAdapterPtr& system_adapter);
  77       SystemAdapterPtr getSystemAdapter() const;
  78
  79       void setCanvasMgr(CanvasMgr* canvas_mgr);
  80       CanvasMgr* getCanvasMgr() const;
  81
  82       bool isInit() const;
  83       void destroy();
  84
  85       /**
  86        * Add a canvas which should be marked as dirty upon any change to this
  87        * canvas.
  88        *
  89        * This mechanism is used to eg. redraw a canvas if it's displaying
  90        * another canvas (recursive canvases)
  91        */
  92       void addParentCanvas(const CanvasWeakPtr& canvas);
  93
  94       /**
  95        * Add a canvas which should be marked visible if this canvas is visible.
  96        */
  97       void addChildCanvas(const CanvasWeakPtr& canvas);
  98
  99       /**
 100        * Stop notifying the given canvas upon changes
 101        */
 102       void removeParentCanvas(const CanvasWeakPtr& canvas);
 103       void removeChildCanvas(const CanvasWeakPtr& canvas);
 104
 105       GroupPtr createGroup(const std::string& name = "");
 106       GroupPtr getGroup(const std::string& name);
 107       GroupPtr getRootGroup();
 108
 109       /**
 110        * Enable rendering for the next frame
 111        *
 112        * @param force   Force redraw even if nothing has changed (if dirty flag
 113        *                is not set)
 114        */
 115       void enableRendering(bool force = false);
 116
 117       void update(double delta_time_sec);
 118
 119       naRef addEventListener(const nasal::CallContext& ctx);
 120
 121       void setSizeX(int sx);
 122       void setSizeY(int sy);
 123
 124       int getSizeX() const;
 125       int getSizeY() const;
 126
 127       void setViewWidth(int w);
 128       void setViewHeight(int h);
 129
 130       int getViewWidth() const;
 131       int getViewHeight() const;
 132       SGRect<int> getViewport() const;
 133
 134       bool handleMouseEvent(const MouseEventPtr& event);
 135
 136       virtual void childAdded( SGPropertyNode * parent,
 137                                SGPropertyNode * child );
 138       virtual void childRemoved( SGPropertyNode * parent,
 139                                  SGPropertyNode * child );
 140       virtual void valueChanged (SGPropertyNode * node);
 141
 142       osg::Texture2D* getTexture() const;
 143
 144       CullCallbackPtr getCullCallback() const;
 145
 146       void reloadPlacements( const std::string& type = std::string() );
 147       static void addPlacementFactory( const std::string& type,
 148                                        PlacementFactory factory );
 149
 150     protected:
 151
 152       SystemAdapterPtr  _system_adapter;
 153       CanvasMgr        *_canvas_mgr;
 154
 155       std::auto_ptr<EventManager>   _event_manager;
 156
 157       int _size_x,
 158           _size_y,
 159           _view_width,
 160           _view_height;
 161
 162       PropertyObject<int>           _status;
 163       PropertyObject<std::string>   _status_msg;
 164
 165       bool _sampling_dirty,
 166            _render_dirty,
 167            _visible;
 168
 169       ODGauge _texture;
 170       GroupPtr _root_group;
 171
 172       CullCallbackPtr _cull_callback;
 173       bool _render_always; //<! Used to disable automatic lazy rendering (culling)
 174
 175       std::vector<SGPropertyNode*> _dirty_placements;
 176       std::vector<Placements> _placements;
 177       std::set<CanvasWeakPtr> _parent_canvases, //<! Canvases showing this canvas
 178                               _child_canvases;  //<! Canvases displayed within
 179                                                 //   this canvas
 180
 181       typedef std::map<std::string, PlacementFactory> PlacementFactoryMap;
 182       static PlacementFactoryMap _placement_factories;
 183
 184       virtual void setSelf(const PropertyBasedElementPtr& self);
 185       void setStatusFlags(unsigned int flags, bool set = true);
 186
 187     private:
 188
 189       Canvas(const Canvas&); // = delete;
 190       Canvas& operator=(const Canvas&); // = delete;
 191   };
 192
 193 } // namespace canvas
 194 } // namespace simgear
 195
 196 #endif /* CANVAS_HXX_ */