mgui/toolbase.h

Go to the documentation of this file.

#ifndef  INC_MGUI_TOOLBASE_H
#define  INC_MGUI_TOOLBASE_H

#ifndef  INC_MGUI_TOOLCANVAS_H
   #include <mgui/toolcanvas.h>
#endif

#ifndef  INC_MGUI_FORMBTXT_H
   #include <mgui/formbtxt.h>
#endif

#ifndef  INC_MI32_TRANS2AFFINE_H
   #include <mi32/trans2daffine.h>
#endif

#ifndef  INC_MI32_TRANS2MAPGEN_H
   #include <mi32/trans2dmapgen.h>
#endif

#ifndef  INC_MI32_MG2ENUMS_H
   #include <mi32/mg2enums.h>
#endif

#ifndef  INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class REGION2D;
namespace MGD {
   class CONTEXT;
   }
#endif


namespace MGUI {

//=====================================================================================================================

class TOOL_BASE {
   public:

      enum ADJUSTFLAGS {
         ADJUST_Default =        0x00,       
         ADJUST_Absolute =       0x01,       
         ADJUST_ScreenCoords =   0x02,       
         ADJUST_Notify =         0x80        
         };

      enum CTRLOPT {
         CTRLOPT_Default =       0x0000,
         CTRLOPT_Manual =        0x0001,  
         CTRLOPT_GPS =           0x0002,  
         CTRLOPT_SnapGrid =      0x0004,  
         CTRLOPT_NoManualProj =  0x0008,  
         CTRLOPT_NoEditZ =       0x0010,  
         CTRLOPT_NoBtnClear =    0x0020,  
         };

      enum CHANGESEQ {
         CHANGESEQ_None =     0,
         CHANGESEQ_Begin =    1,
         CHANGESEQ_Continue = 2,
         CHANGESEQ_End =      3,
         CHANGESEQ_Cancel =   4
         };

      enum CHANGETYPE {
         CHANGETYPE_None =          0,
         CHANGETYPE_Shift =         1,    
         CHANGETYPE_Resize =        2,    
         CHANGETYPE_Rotate =        3,    
         CHANGETYPE_Shear =         4,    
         CHANGETYPE_Edit =          5,    
         CHANGETYPE_Create =        6,    
         CHANGETYPE_Clear =         7,    
         CHANGETYPE_ActiveElement = 8,    
         CHANGETYPE_Other =         20    
         };

      enum MARKER {
         MARKER_X =              0,    
         MARKER_Plus =           1,    
         MARKER_ArrowIn =        2,    
         MARKER_ArrowOut =       3,    
         MARKER_None =           4,    
         MARKER_Circle =         5,    
         MARKER_Flat =           6,    
         MARKER_Square =         7,    
         MARKER_Diamond =        8,    
         MARKER_Diamond_Tall =   9,    
         MARKER_Diamond_Wide =   10,   
         };

      enum PENCOLOR {
         PENCOLOR_Primary,          
         PENCOLOR_Inactive,         
         PENCOLOR_Highlight,        
         PENCOLOR_COUNT             
         };

      class SNAPGRID {
         public:

            SNAPGRID (
               );

            explicit SNAPGRID (
               const DPOINT2D& interval
               );

            SNAPGRID (
               const DPOINT2D& interval,
               const TRANS2D_AFFINE& trans      
               );

            void Adjust (
               DPOINT2D& pt                     
               ) const;

            const DPOINT2D& GetInterval (
               ) const { return (m_interval); }

            const TRANS2D_AFFINE& GetTrans (
               ) const { return (m_trans); }

            bool IsValid (
               ) const { return (m_interval.x > 0 && m_interval.y > 0); }

            void SetInterval (
               const DPOINT2D& interval
               ) { m_interval = interval; }

            void SetTrans (
               const TRANS2D_AFFINE& trans      
               ) { m_trans = trans; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            DPOINT2D m_interval;
            TRANS2D_AFFINE m_trans;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      typedef fastdelegate::FastDelegate<void(CHANGESEQ, CHANGETYPE)> DELEGATE_ONCHANGE;

      typedef fastdelegate::FastDelegate<bool(MGUI::POINT, MGUI::KEYSTATE)> DELEGATE_ONPOINTER;

      static const COLOR& GetPenColor (
         PENCOLOR pencolor = PENCOLOR_Primary
         );

      static INT8 GetPenWidthShared ();

      static void SetPenColor (
         PENCOLOR pencolor,
         const COLOR& color
         );

      static void SetPenWidthShared (
         INT8 PenWidth
         );

      virtual ~TOOL_BASE () = 0;

      void Activate ();

      void ClearPosition ();

      MGUI::FORM* CreateControlForm (
         MGUI::LAYOUT_PANE_BASE& ParentPane, 
         CTRLOPT ctrlopt                     
         ) { return (v_CreateControlForm(ParentPane,ctrlopt)); }

      MGUI::FORM* CreateManualForm (
         MGUI::LAYOUT_PANE_BASE& ParentPane, 
         CTRLOPT ctrlopt                     
         );

      void Deactivate ();

      ERRVALUE GenerateRegion (
         REGION2D& region                 
         ) const { return (v_GenerateRegion(region)); }

      const DPOINT2D& GetArrowKeyDeltas (
         ) const { return (m_ArrowDelta); }

      CTRLOPT GetControlOptions (
         ) const { return (m_ctrlopt); }

      TOOLCANVAS* GetCanvas (
         ) const { return (m_pCanvas); }

      void GetCanvasExtents (
         DRECT2D& extents                 
         ) const;

      void GetCanvasExtents (
         LRECT2D& extents                 
         ) const;

      KEYSTATE GetKeyState () const
         { return (m_KeyState); }

      const TRANS2D_MAPGEN& GetTransToMap (
         ) const { return (m_ToolToMapCRS); }

      const TRANS2D_AFFINE& GetTransToWindow (
         ) const { return (m_ToolToWindow); }

      bool HasControls (
         ) const { return (m_ControlNeed != CONTROLNEED_None); }

      bool HasManualControls (
         ) const { return ((m_capability & CAPABILITY_ManualControls) != 0); };

      bool Is3D () const
         { return (m_Is3D); }

      bool IsActive (
         ) const { return (m_IsActive); }

      bool IsResizable (
         ) const { return (m_Resizable); }

      bool IsRotatable (
         ) const { return (m_Rotatable); }

      bool IsSuspended (
         ) const { return (m_SuspendCount > 0); }

      bool HasPosition (
         ) const { return (m_PosnSet); }

      void Move (
         double dx,
         double dy,
         ADJUSTFLAGS flags
         );

      void NotifyChange (
         CHANGESEQ changeseq,                
         CHANGETYPE changetype               
         );

      void Resize (
         double dx,
         double dy,
         ADJUSTFLAGS flags
         );

      void Resume ();

      void Set3D (
         bool is3D = true
         );

      void SetArrowKeyDeltas (
         double dx,
         double dy
         );

      void SetCanStartNew (
         bool canstartnew
         ) { m_CanStartNew = canstartnew; }

      void SetControlOptions (
         CTRLOPT ctrlopt                        
         ) { m_ctrlopt = ctrlopt; }

      void SetDelegateOnChange (
         DELEGATE_ONCHANGE delegate
         ) { m_DelegateOnChange = delegate; }

      void SetDelegateOnDestroy (
         DELEGATE_VOID_NOPARMS delegate
         ) { m_DelegateOnDestroy = delegate; }

      void SetDelegateOnRightButtonDown (
         DELEGATE_ONPOINTER delegate
         ) { m_DelegateOnRightButtonDown = delegate; }

      void SetDelegateOnRightButtonUp (
         DELEGATE_ONPOINTER delegate
         ) { m_DelegateOnRightButtonUp = delegate; }

      void SetPenWidth (
         INT8 PenWidth                       
         );

      void SetResizable (
         bool resizable
         ) { m_Resizable = resizable; }

      void SetRotatable (
         bool rotatable
         ) { m_Rotatable = rotatable; }

      void SetTransToMap (
         const TRANS2D_MAPGEN& TransToMap    
         );

      void SetTransToWindow (
         const TRANS2D_AFFINE& trans
         );

      bool SnapGridIsActive (
         ) const { return (m_UseSnapGrid && m_pSnapGrid != 0); }

      void SnapGridSet (
         const SNAPGRID& snapgrid
         );

      void SnapGridSetActive (
         bool active
         ) { m_UseSnapGrid = active; }

      void StereoEnable (
         bool enable             
         );

      bool StereoIsEnabled () const;

      void Suspend ();

   protected:

      enum CONTROLNEED {
         CONTROLNEED_None,
         CONTROLNEED_Optional,
         CONTROLNEED_Required
         };

      enum CAPABILITY {
         CAPABILITY_Default =          0,
         CAPABILITY_ManualControls =   0x01,    
         CAPABILITY_Stereo =           0x02,    
         CAPABILITY_UsePixmap =        0x04,    
         };

      class MANUAL_BASE : public MGUI::FORM_COMPOSITE {
         public:
            MANUAL_BASE ();

            virtual ~MANUAL_BASE () = 0;

            void Create (
               MGUI::LAYOUT_PANE_BASE &ParentPane,
               TOOL_BASE::CTRLOPT ctrlopt
               );

            void NotifyChange (
               CHANGESEQ changeseq,                
               CHANGETYPE changetype               
               ) { v_OnNotifyChange(changeseq, changetype); }
               
            void SetTransToolToMapCRS (
               const TRANS2D_MAPGEN& ToolToMapCRS
               );

         protected:
            const TRANS2D_MAPGEN& GetToolToDisplayCRS (
               ) const { return (m_ToolToDisplayCRS); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            TRANS2D_MAPGEN m_ToolToDisplayCRS;
            FORM_BUTTONTEXT m_BtxCoordRefSys;
            bool m_UserSetCRS;

            void OnBtnCoordRefSys ();
            #endif      // GENERATING_DOXYGEN_OUTPUT

            virtual void v_CreateContent (
               MGUI::LAYOUT_PANE_BASE &ParentPane
               ) = 0;

            virtual void v_OnDisplayCoordRefSysChange () = 0;

            virtual void v_OnNotifyChange (
               CHANGESEQ changeseq,                
               CHANGETYPE changetype               
               );
         };

      explicit TOOL_BASE (
         TOOLCANVAS *pCanvas,                         
         CONTROLNEED ControlNeed = CONTROLNEED_None,  
         CAPABILITY capability = CAPABILITY_Default   
         );

      void AdjustBegin (CHANGETYPE changetype, bool redraw = true);

      void AdjustEnd (bool releasecapture = true, bool cancel = false);

      void ApplyMoveDeltas (
         DPOINT2D& point,
         double dx,
         double dy,
         ADJUSTFLAGS flags
         ) const;

      void ApplySnap (
         DPOINT2D& point                     
         ) const;

      void CalcMarkerRectTool (
         const DPOINT2D& ptTool,             
         UINT16 size,                        
         LRECT2D& rectCanvas,                
         bool AddLineWidth = true            
         ) const;

      void CalcMarkerRectTool (
         const DPOINT3D& ptTool,             
         UINT16 size,                        
         LRECT2D& rectCanvas,                
         bool AddLineWidth = true            
         ) const;

      bool CanUsePixmap () const;

      bool CanStartNew () const
         { return (m_CanStartNew); }

      void DrawLineTool (
         const POLYLINE& plTool,                
         const COLOR *pColor = 0,               
         const double *DashArray = 0,           
         int DashArraySize = 0,                 
         bool UsePixmap = false                 
         ) const;

      void DrawMarker (
         const DPOINT2D& ptCanvasCenter,        
         const DPOINT2D& ptCanvasDir,           
         MARKER marker,                         
         UINT16 size,                           
         const COLOR *pColor = 0,               
         bool UsePixmap = false                 
         ) const;

      void DrawMarker (
         const LPOINT2D& ptCanvasCenter,        
         const LPOINT2D& ptCanvasDir,           
         MARKER marker,                         
         UINT16 size,                           
         const COLOR *pColor = 0,               
         bool UsePixmap = false                 
         ) const;

      void DrawMarkerTool (
         const DPOINT3D& ptTool,                
         MARKER marker,                         
         UINT16 size,                           
         const COLOR *pColor = 0,               
         bool UsePixmap = false                 
         ) const;

      void DrawMarkerTool (
         const DPOINT3D& ptToolCenter,          
         const DPOINT2D& ptToolDir,             
         MARKER marker,                         
         UINT16 size,                           
         const COLOR *pColor = 0,               
         bool UsePixmap = false                 
         ) const;

      void DrawSegmentTool (
         const DPOINT3D& ptTool0,               
         const DPOINT3D& ptTool1,               
         const COLOR *pColor = 0,               
         const double *DashArray = 0,           
         int DashArraySize = 0,                 
         bool UsePixmap = false                 
         ) const;

      void DrawSegmentWindow (
         const DPOINT3D& ptTool0,               
         const DPOINT3D& ptTool1,               
         const COLOR *pColor = 0,               
         const double *DashArray = 0,           
         int DashArraySize = 0,                 
         bool UsePixmap = false                 
         ) const;

      bool GetArrowDeltas (KEYCODE, double*, double*);

      MGD::CONTEXT* GetDrawingContext (
         STEREOVIEW StereoView,                    
         const COLOR *pColor,                      
         bool UsePixmap = false                    
         ) const;

      MGD::CONTEXT* GetDrawingContext (
         STEREOVIEW StereoView = STEREOVIEW_None,  
         bool UsePixmap = false                    
         ) const;

      CHANGETYPE GetChangeType (
         ) const { return (m_ChangeType); }
         
      MANUAL_BASE* GetManualBase (
         ) { return (m_pManualBase); }

      INT8 GetPenWidth () const;

      bool IsPointerCaptured () const;

      bool IsUserModifying (
         ) const { return (m_IsUserModifying); }

      void RestoreBackground (
         bool UsePixmap = false              
         ) const;

      void RestoreBackground (
         const LRECT2D& rect,                
         bool AddLineWidth = true,           
         bool UsePixmap = false              
         ) const;

      void SetAutoPixelFunction (
         bool AutoPixelFunction
         ) { m_AutoPixelFunction = AutoPixelFunction; }

      void SetCursor (
         CURSORID cursorid
         ) const { m_pCanvas->SetCursor(cursorid); }

      void SetHasPosition (
         bool PosnValid = true               
         ) { m_PosnSet = PosnValid; }

      void SetPixelFunction (
         MGD::PIXELFUNC PixelFunc            
         );

      LPOINT2D TransToolToWindow (
         const DPOINT2D& ptTool
         ) const;

      void TransToolToWindow (
         const DPOINT2D& ptTool,
         DPOINT2D& ptCanvas
         ) const { ptCanvas = m_ToolToWindow.ConvertForward(ptTool); }

      bool TransToolToWindow (
         const DPOINT2D& ptTool,             
         DPOINT3D& ptCanvas                  
         ) const;

      bool TransToolToWindow (
         const DPOINT3D& ptTool,             
         DPOINT3D& ptCanvas                  
         ) const;

      DPOINT2D TransWindowToTool (
         MGUI::POINT point
         ) const { return (m_ToolToWindow.ConvertInverse(point.m_x,point.m_y)); }

      DPOINT2D TransWindowToTool (
         const LPOINT2D& point
         ) const { return (m_ToolToWindow.ConvertInverse(point.x,point.y)); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class TOOLDLG;

      // Static members
      static COLOR s_PenColor[PENCOLOR_COUNT];
      static INT8 s_PenWidthShared;

      // Explicitly initialized
      TOOLCANVAS *m_pCanvas;
      MGD::CONTEXT *XXXdelete_dc;
      MANUAL_BASE *m_pManualBase;
      TOOLDLG *m_pToolDlg;
      SNAPGRID *m_pSnapGrid;              // Snap grid information structure
      DPOINT2D m_ArrowDelta;              // Increments for arrow key movement, tool coords
      INT32 m_SuspendCount;               // Number of times that this tool has been suspended
      CONTROLNEED m_ControlNeed;          // Need for controls
      CHANGETYPE m_ChangeType;            // Change type for use with button-up
      KEYSTATE m_KeyState;                // Key state for access in OnChange
      CTRLOPT m_ctrlopt;
      CAPABILITY m_capability;
      INT8 m_PenWidth;                    // Tool pen width, < 0 to use shared value (default)
      mutable bool m_InRestoreBG;
      bool m_InDeactivateFunc;            // Deactivate() is called, avoid doing redraws
      bool m_IsActive;                    // Tool is in use, Activate() has been called
      bool m_PosnSet;                     // Tool graphic has a position and is viewable
      bool m_UseSnapGrid;                 // Use snap grid
      bool m_HasArrowDeltas;              // Deltas for arrow key movement is set
      bool m_IsUserModifying;             // Is user modifying tool position
      bool m_CanStartNew;                 // User can start drawing new tool, default=true
      bool m_Resizable;                   // Tool is resizable, default=true
      bool m_Rotatable;                   // Tool is rotatable, default=true
      bool m_StereoEnabled;
      bool m_Is3D;                        // Tool has own 3D coordinates
      bool m_AutoPixelFunction;
      bool m_InDrawTool;
      // Self initializing
      DELEGATE_VOID_NOPARMS m_DelegateOnDestroy;
      DELEGATE_ONCHANGE m_DelegateOnChange;
      DELEGATE_ONPOINTER m_DelegateOnRightButtonDown;
      DELEGATE_ONPOINTER m_DelegateOnRightButtonUp;
      TRANS2D_AFFINE m_ToolToWindow;      // Tool <--> Window transformation
      TRANS2D_MAPGEN m_ToolToMapCRS;      // Tool <--> MapCRS transformation

      void CalcMarkerRectCanvas (const DPOINT3D& ptCanvas, UINT16 size, LRECT2D& rectCanvas, bool AddLineWidth, bool HasValidZ) const;
      void CreateToolDlg ();
      void DrawMarkerLow (MGD::CONTEXT*, const DPOINT2D& ptCanvasCenter, const DPOINT2D& ptCanvasDir, MARKER marker, UINT16 size) const;
      void DrawTool ();
      void DrawTool (UINT32);
      bool OnKey (MGUI::POINT point, MGUI::KEYCODE, KEYSTATE);
      bool OnPointerButtonDown (MGUI::POINT point, POINTERBUTTON button, KEYSTATE keystate);
      bool OnPointerButtonUp (MGUI::POINT point, POINTERBUTTON button, KEYSTATE keystate);
      void SetCanvas (TOOLCANVAS *canvas) { m_pCanvas = canvas; }

      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables

      virtual MGUI::FORM* v_CreateControlForm (
         MGUI::LAYOUT_PANE_BASE& ParentPane, 
         CTRLOPT ctrlopt                     
         );

      virtual MANUAL_BASE* v_CreateManualBase (
         );

      virtual void v_DoDraw ();

      virtual void v_DoMove (double x, double y, ADJUSTFLAGS);

      virtual void v_DoSize (double x, double y, ADJUSTFLAGS);

      virtual int v_GenerateRegion (
         REGION2D& region                    
         ) const;

      virtual MISTRING v_GetDialogTitle (
         ) const;

      virtual void v_OnActivate ();

      virtual void v_OnClear ();

      virtual void v_OnDeactivate ();

      virtual bool v_OnKey (MGUI::POINT point, MGUI::KEYCODE, KEYSTATE);

      virtual void v_OnNotifyChange (
         CHANGESEQ changeseq,                
         CHANGETYPE changetype               
         );

      virtual bool v_OnPointerButtonDown (MGUI::POINT point, POINTERBUTTON button, KEYSTATE keystate) = 0;

      virtual bool v_OnPointerButtonUp (MGUI::POINT point, POINTERBUTTON button, KEYSTATE keystate);

      virtual void v_OnPointerEnter ();

      virtual void v_OnPointerLeave ();

      virtual void v_OnPointerMove (MGUI::POINT point, POINTERBUTTON button, KEYSTATE keystate);

      virtual void v_OnResume ();

      virtual void v_OnSet3D ();

      virtual void v_OnSetTransToMap ();

      virtual void v_OnSetTransToWindow ();

      virtual void v_OnSizeCanvas ();

      virtual void v_OnSuspend ();

   friend class TOOLCANVAS::PRIV;
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(TOOL_BASE::ADJUSTFLAGS)
DEFINE_ENUM_OP_BITWISE(TOOL_BASE::CTRLOPT)
#endif

//=====================================================================================================================

class TOOL_LIMITED : public TOOL_BASE {
   public:

      virtual ~TOOL_LIMITED ();

      void SetLimits (
         const DRECT2D& rect                    
         );

      void SetLimitsEnforced (
         bool enforced = true                   
         );

   protected:

      explicit TOOL_LIMITED (
         TOOLCANVAS *canvas,
         CONTROLNEED ControlNeed = CONTROLNEED_None,  
         CAPABILITY capability = CAPABILITY_Default   
         );

      const DRECT2D& GetLimits (
         ) const { return (m_Limits); }

      bool IsLimitsEnforced (
         ) const { return (m_LimitsEnforced); }

      virtual void v_OnActivate ();

      virtual void v_OnSetTransToWindow ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      typedef TOOL_BASE BASECLASS;

      bool m_LimitsEnforced;              
      bool m_LimitsSet;                   
      DRECT2D m_Limits;                   

      // TOOL_BASE overrides.
      virtual void v_OnSizeCanvas ();

      // Called when limits are changed.
      virtual void v_OnChangeLimits ();

      void UpdateLimits ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

}  // End namespace MGUI

#endif   // INC_MGUI_TOOLBASE_H

---