grtool.h

Go to the documentation of this file.

/**
 * \file grtool.h <mi32/grtool.h>
 * \brief Definitions for GRTOOL Graphic Tool classes used with MFC
 *
 * \if NODOC
 * $Id: grtool.h_v 1.5 2004/07/12 20:07:13 mju Exp $
 *
 * $Log: grtool.h_v $
 * Revision 1.5  2004/07/12 20:07:13  mju
 * Use region2d.
 *
 * Revision 1.4  2004/03/01 16:58:17  mju
 * Update to newer mgui headers.
 *
 * Revision 1.3  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.1  2002/08/13 21:00:37  mju
 * Initial revision
 *
 * 
 * 13    12/31/01 11:35a Mju
 * Inherit from DLG_BASE.
 * 
 * 12    12/17/01 9:28a Mju
 * Use MGUI::DLG
 * 
 * 11    12/13/01 10:55a Mju
 * MGUI unificiation with X.
 * 
 * 10    11/05/01 10:57a Mju
 * Make GetPenColor non-inline.
 * Read pen color from INI in GetPenColor if not previously.
 * Write pen color to INI in SetPenColor.
 * 
 * 9     8/28/01 2:58p Mju
 * Define MGUI::FORM interface and have MGUI::CTRL inherit from it.
 * 
 * 8     8/17/01 4:43p Mju
 * Use MGUI namespace
 * 
 * 1     12/21/00 11:48a Mju
 * Definitions for GRTOOL Graphic Tool classes.
 * \endif
**/

#ifndef  INC_MI32_GRTOOL_H
#define  INC_MI32_GRTOOL_H

#ifndef  INC_MI32_STDAFX_H
   #include <mi32/stdafx.h>
#endif

#ifndef INC_MGUI_DLGBASE_H
   #include <mgui/dlgbase.h>
#endif

#ifndef INC_MGUI_COMMAND_H
   #include <mgui/command.h>
#endif

#ifndef INC_MI32_TRANS2DC_H
   #include <mi32/trans2dc.h>
#endif

#ifndef INC_MI32_REGION2D_H
   #include <mi32/region2d.h>
#endif

#ifndef INC_MI32_DOUBLEAR_H
   #include <mi32/doublear.h>
#endif

#ifndef INC_MI32_ELEMSTYL_H
   #include <mi32/elemstyl.h>
#endif

#include <list>

namespace MicroImages {

class GRTOOLVIEW;    //!< Forward declaration



//!
//!   GRTOOL - Base class for graphic tools
//!
class GRTOOL {
   public:

      //! Adjustment flags for Move() and Resize() methods.
      enum ADJUSTFLAGS {
         ADJUST_Default =        0x00,       //!< Values are relative tool coordinates
         ADJUST_Absolute =       0x01,       //!< Adjustment values are absolute
         ADJUST_ScreenCoords =   0x02,       //!< Adjustment values are in screen pixels
         ADJUST_Notify =         0x80        //!< Send notification message
         };

      enum CTRLOPT {
         CTRLOPT_Default =       0x00,
         CTRLOPT_Manual =        0x01,    //!< Include "manual" controls if available
         CTRLOPT_GPS =           0x02,    //!< Include "gps" controls if supported
         CTRLOPT_SnapGrid =      0x04,    //!< Include "snap to grid" toggle if supported
         CTRLOPT_NoManualProj =  0x08     //!< Don't allow manual projection / distance controls
         };

      enum MOVESEQ {
         MOVESEQ_Begin =            1,
         MOVESEQ_Continue =         2,
         MOVESEQ_End =              3,
         MOVESEQ_Cancel =           4
         };

      enum MOVETYPE {
         MOVETYPE_None =            0,
         MOVETYPE_Shift =           1,
         MOVETYPE_Resize =          2,
         MOVETYPE_Rotate =          3,
         MOVETYPE_Shear =           4,
         MOVETYPE_Edit =            5,
         MOVETYPE_Create =          6,
         MOVETYPE_Clear =           7
         };

      //! Marker types, not all types are supported by all tools.
      enum MARKER {
         MARKER_X =           0,
         MARKER_Plus =        1,
         MARKER_ArrowIn =     2,             //!< Arrow pointing in for line endpoint
         MARKER_ArrowOut =    3,             //!< Arrow pointing out for line endpoint
         MARKER_None =        4,
         MARKER_Circle =      5,
         MARKER_Flat =        6,             //!< Flat line endpoint
         MARKER_Square =      7,
         };

      enum PENCOLOR {
         PENCOLOR_Primary,                   //!< Primary tool drawing color
         PENCOLOR_Inactive,                  //!< Color for inactive elements (eg in POLYLINE tool)
         PENCOLOR_Highlight,                 //!< Color for highlighting
         PENCOLOR_COUNT                      //!< Number of pens, always last
         };

      struct SNAPGRIDPARMS {
         DPOINT3D BasePt;        //!< Base point of snap grid
         double xsize;           //!< X direction size
         double ysize;           //!< Y direction size
         double zsize;           //!< Z direction size
         double rotate;          //!< Rotation angle (snap grid)
         MAT3X3 OtoS, StoO;      //!< Translation to/from snap grid coordinates
         };

      //! Get global tool pen color reference.
      //! @return Color reference.
      static DWORD GetPenColor (
         PENCOLOR pencolor
         );

      //! Set global tool pen color.
      static void SetPenColor (
         PENCOLOR pencolor,
         DWORD ColorRef                      //!< Color reference
         );

      //! Destructor
      virtual ~GRTOOL () = 0;

      //! Activate the tool.
      //! If another tool is currently active in the view it will be automatically deactivated.
      void Activate (
         );

      //! Clear current tool position, erasing all graphics.
      void ClearPosition (
         );

      //! Create "form" with tool-specific controls.
      virtual MGUI::CTRL* CreateControlForm (
         MGUI::LAYOUT_PANE_BASE& ParentPane, //!< Parent pane
         CTRLOPT ctrlopt                     //!< Control options
         );

      //! Create "form" with tool-specific manual-entry controls.
      virtual MGUI::CTRL* CreateManualForm (
         MGUI::LAYOUT_PANE_BASE& ParentPane, //!< Parent pane
         CTRLOPT ctrlopt                     //!< Control options
         );

      //! Deactivate this tool.
      void Deactivate (
         );

      //! Generate region from tool.
      //! @return TRUE if region generated, FALSE if not, < 0 if error.
      virtual int GenerateRegion (
         REGION2D& region
         ) const;

      //! Get movement values associated with arrow keys.
      //! @return Values in "tool" coordinates.
      const DPOINT2D& GetArrowKeyDeltas (
         ) const { return (m_ArrowDelta); }

      //! Get current control options settings.
      CTRLOPT GetControlOptions (
         ) const { return (m_ctrlopt); }

      //! Get transformation between "tool" and "window" coordinates.
      const TRANS2D_AFFINE& GetTransToWindow (
         ) const { return (m_ToolToWindow); }

      //! Get "view" associated with tool.
      GRTOOLVIEW* GetView (
         ) const { return (m_view); }

      //! Get extents of view.
      inline const DRECT2D& GetViewExtents (
         ) const;

      //! Determine if tool controls available.
      bool HasControls (
         ) const { return (m_ControlNeed != CONTROLNEED_None); }

      //! Determine if has manual data entry controls.
      bool HasManualControls (
         ) const { return (m_HasManualControls); };

      //! Check if tool is currently "active".
      bool IsActive (
         ) const { return (m_IsActive); }

      //! Determine if tool is "resizable".
      bool IsResizable (
         ) const { return (m_Resizable); }

      //! Determine if tool is "rotatable".
      bool IsRotatable (
         ) const { return (m_Rotatable); }

      //! Check if tool is "suspended"
      bool IsSuspended (
         ) const { return (m_SuspendCount > 0); }

      //! Check if tool has a valid position set
      bool HasPosition (
         ) const { return (m_PosnSet); }

      //! Move the tool by the specified amount.
      void Move (
         double dx,
         double dy,
         ADJUSTFLAGS flags
         );

      //! Resize the tool.
      void Resize (
         double dx,
         double dy,
         ADJUSTFLAGS flags
         );

      //! Resume the tool after performing drawing operation on the view.
      void Resume (
         );

      //! Set movement amounts associated with arrow keys.
      void SetArrowKeyDeltas (
         double dx,
         double dy
         );

      //! Set whether user can start drawing a "new" tool.
      void SetCanStartNew (
         bool canstartnew
         ) { m_CanStartNew = canstartnew; return; }

      //! Set controls to appear on dialog when shown.
      //! If used, this must be called before tool is first activated.
      void SetControlOptions (
         CTRLOPT ctrlopt                        //!< Control settings
         ) { m_ctrlopt = ctrlopt; return; }

      //! Set whether tool is resizable.
      void SetResizable (
         bool resizable
         ) { m_Resizable = resizable; return; }

      //! Set whether tool is rotatable.
      void SetRotatable (
         bool rotatable
         ) { m_Rotatable = rotatable; return; }

      //! Set transformation between "tool" and "window" coordinates.
      void SetTransToWindow (
         const TRANS2D_AFFINE& trans
         );

      //! Determine if snap grid is currently in use.
      bool SnapGridIsActive (
         ) const { return (m_UseSnapGrid); }

      //! Get snap grid settings.
      const SNAPGRIDPARMS& SnapGridGet (
         ) const { return (m_sgparms); }

      //! Set snap grid parameters.
      void SnapGridSet (
         SNAPGRIDPARMS& parms
         );

      //! Set whether to use snap grid or not.
      void SnapGridSetActive (
         bool active
         ) { m_UseSnapGrid = active; }

      //! Suspend tool prior to performing a drawing operation on the view.
      void Suspend (
         );

   protected:

      enum CONTROLNEED {
         CONTROLNEED_None,
         CONTROLNEED_Optional,
         CONTROLNEED_Required
         };

      enum PENSTYLE {
         PENSTYLE_Solid,
         PENSTYLE_Dash,
         PENSTYLE_COUNT
         };

      //! Get pen for drawing tool.
      //! @return Pointer to CPen so can use directly in CDC::SelectObject().
      static CPen* GetPen (
         PENCOLOR PenColor = PENCOLOR_Primary,
         PENSTYLE PenStyle = PENSTYLE_Solid
         );

      //! Constructor
      explicit GRTOOL (
         GRTOOLVIEW *view,
         CONTROLNEED ControlNeed,         //!< Need for control dialog or form
         bool HasManualControls           //!< Optional manual controls available
         );

      // Methods used to notify subclasses of changes to tool.

      //! Called when tool is "activated".
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnActivate (
         );

      //! Called when user performs "Cancel" action with tool.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnCancel (
         );

      //! Called when tool is "cleared" by user action, usually on control dialog.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnClear (
         );

      //! Called when tool is deactivated.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnDeactivate (
         );

      //! Called when user alters tool position, shape, size, etc.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnMove (
         MOVESEQ moveseq,                 //!< Movement sequence
         MOVETYPE movetype                //!< Movement type
         );

      //! Called when right mouse button pressed.
      //! Usually overridden to show a popup menu.
      //! Default implementation does nothing.
      virtual void OnRButtonDown (UINT nFlags, const CPoint& mpoint);

      //! Called when right mouse button released.
      //! Usually overridden to perform an 'apply' action.
      //! Default implementation does nothing.
      virtual void OnRButtonUp (UINT nFlags, const CPoint& mpoint);

      //! Called when tool is "resumed" after being suspended.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnResume (
         );

      //! Called when tool to window transformation is set.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnSetTransToWindow (
         );

      // Methods called by the GRTOOL base class.
      // Will be private in tool implementation subclass.
      virtual void DoDraw (CDC*) = 0;
      virtual void DoMove (double, double, ADJUSTFLAGS);
      virtual void DoResize (double, double, ADJUSTFLAGS);

      // Methods called directly by the equivalent GRTOOLVIEW method.
      // Will be private in tool implementation subclass.

      virtual void OnCaptureChanged (CWnd *pWnd);

      //! Called when key pressed/released.
      //! @return 'true' if key handled, 'false' if not.
      virtual bool OnKey (UINT nChar, UINT nRepCnt, UINT nFlags);

      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint) = 0;
      virtual void OnLButtonUp (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint) = 0;
      virtual void OnSize ();

      //! Utility methods for use by tool implementation.

      virtual void AdjustBegin (MOVETYPE movetype, bool redraw = true);

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

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

      //! Snap point to current snap grid, if no snapping enabled point unchanged.
      void ApplySnap (
         DPOINT2D& point                     //!< Point to adjust
         ) const;

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

      //! Check rectangle against tool limits
      int CheckBounds (const DRECT2D&, DRECT2D*) const;

      //! Draw a marker (MARKER...) in the position and size specified.
      void DrawMarker (CDC* pDC, const POINT& centerpoint, const POINT& dirpoint, MARKER marker, UINT16 size) const;

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

      CDC *GetDC ();

      MOVETYPE GetMoveType (
         ) const { return (m_MoveType); }

      inline bool IsMouseCaptured (
         ) const;

      inline void ReleaseDC (CDC* pDC);

      //! Restore background for entire tool view window.
      void RestoreBackground () const;

      //! Restore background for specified rectangle.
      void RestoreBackground (
         const LRECT2D& rect,
         bool AddLineWidth = true            //!< Expand rectangle by 'LineWidth+1'
         ) const;

      void SetHasPosition (
         bool HasPosition = true
         ) { m_PosnSet = HasPosition; return; }

      //! Transform DPOINT2D from "tool" to "window" coordinates.
      POINT TransToolToWindow (
         const DPOINT2D& point
         ) const;

      //! Transform DPOINT3D from "tool" to "window" coordinates.
      POINT TransToolToWindow (
         const DPOINT3D& point
         ) const;

      //! Transform point in "window" to "tool" coordinates.
      DPOINT2D TransWindowToTool (
         const POINT& point
         ) const { return (m_ToolToWindow.ConvertInverse(point.x,point.y)); }


   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class TOOLDLG : public MGUI::DLG_BASE {
         public:
            TOOLDLG (GRTOOL& tool);
            virtual const char* GetDialogHelpID () const;
            virtual const char* GetDialogName () const;
            virtual ERRVALUE OnInitDialog ();
            class PAGECONTROLS : public MGUI::LAYOUT_PAGE {
               public:
                  PAGECONTROLS (TOOLDLG& dlg): m_dlg(dlg) { }
                  virtual ~PAGECONTROLS () { }
               protected:
                  virtual void OnInitPage ();
               private:
                  TOOLDLG& m_dlg;
               };
            class PAGEMANUAL : public MGUI::LAYOUT_PAGE {
               public:
                  PAGEMANUAL (TOOLDLG& dlg): m_dlg(dlg) { }
                  virtual ~PAGEMANUAL () { }
               protected:
                  virtual void OnInitPage ();
               private:
                  TOOLDLG& m_dlg;
               };
            GRTOOL& m_tool;
            MGUI::LAYOUT_BOOK m_TabBook;
            PAGECONTROLS m_PageControls;
            PAGECONTROLS m_PageManual;
         };

      // STATIC MEMBERS

      static DWORD s_PenColor[PENCOLOR_COUNT];
      static CPen s_Pen[PENCOLOR_COUNT*PENSTYLE_COUNT];

      // Explicitly initialized
      GRTOOLVIEW *m_view;
      CONTROLNEED m_ControlNeed;          //!< Need for controls
      bool m_HasManualControls;           //!< Tool supports manual controls
      INT8 m_LineWidth;                   //!< Tool line width
      DPOINT2D m_ArrowDelta;              //!< Increments for arrow key movement, tool coords
      INT32 m_SuspendCount;               //!< Number of times that this tool has been suspended
      MOVETYPE m_MoveType;                //!< Movement type for use with button-up
      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_HasSnapGrid;                 //!< Has a snap grid to use
      bool m_HasArrowDeltas;              //!< Deltas for arrow key movement is set
      bool m_IsUserModifying;             //!< Is user modifying tool position
      bool m_InDeactivateFunc;            //!< Deactivate() is called, avoid doing redraws
      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
      CTRLOPT m_ctrlopt;
      TOOLDLG m_ToolDlg;

      // Self-initializing
      TRANS2D_AFFINE m_ToolToWindow;      //!< Tool <--> Window transformation
      SNAPGRIDPARMS m_sgparms;            //!< Snap grid information structure

      void CreateToolDlg ();
      void DrawTool (CDC*);
      void DrawTool (CDC*, UINT32);
      void DrawTool (UINT32);
      void SetView (GRTOOLVIEW *newview) { m_view = newview; return; }

   friend class GRTOOL::TOOLDLG;
   friend class GRTOOLVIEW;
   #endif // GENERATING_DOXYGEN_OUTPUT
   };
DEFINE_ENUM_OPERATORS(GRTOOL::ADJUSTFLAGS);
DEFINE_ENUM_OPERATORS(GRTOOL::CTRLOPT);


//!
//! GRTOOL_LIMITED - Tool with limit support
//!
class GRTOOL_LIMITED : public GRTOOL {
   public:

      //! Destructor
      virtual ~GRTOOL_LIMITED ();

      //! Set coordinate limits.
      void SetLimits (
         const DRECT2D& rect                    //!< Limits to set
         );

      //! Set whether limits are enforced.
      //! If SetLimits() has not been called then the tool will be limited to the visible view extent.
      void SetLimitsEnforced (
         bool enforced = true                   //!< Set if limits are enforced
         );

   protected:

      //! Constructor
      explicit GRTOOL_LIMITED (
         GRTOOLVIEW *view,
         CONTROLNEED ControlNeed,         //!< Need for control dialog or form
         bool HasManualControls           //!< Optional manual controls available
         );

      //! Get limits.
      const DRECT2D& GetLimits (
         ) const { return (m_Limits); }

      //! Determine if limits are enforced.
      bool IsLimitsEnforced (
         ) const { return (m_LimitsEnforced); }

      //! Called when tool is "activated".
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnActivate (
         );

      //! Called when limits are changed.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnChangeLimits (
         );

      //! Called when tool to window transformation is set.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnSetTransToWindow (
         );

   private:
      bool m_LimitsEnforced;              //!< Limits are enforced
      bool m_LimitsSet;                   //!< Limits have been set, otherwise defaults to window extents
      DRECT2D m_Limits;                   //!< Position ranges, default to entire parent window range

      virtual void OnSize ();
      void UpdateLimits ();
   };


//!
//!   GRTOOL_SELECTPOINT - Point selection tool (no visible graphics)
//!
class GRTOOL_SELECTPOINT : public GRTOOL_LIMITED {
   public:

      //! Constructor.
      explicit GRTOOL_SELECTPOINT (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_SELECTPOINT ();

      //! Get tool point.
      const DPOINT2D& GetPoint (
         ) const { return (m_point); }

   private:
      //! Enumeration constants
      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         };

      class CONTROLFORM : public MGUI::CTRL {
         public:
            CONTROLFORM (
               );
            virtual ~CONTROLFORM (
               );
         private:
         };

      //! Tool position values
      DPOINT2D m_point;                //!< Tool position

      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone

      //! Methods called by the GRTOOL base class
      virtual void DoDraw (CDC*);
      virtual void DoMove (double dx, double dy, ADJUSTFLAGS flags);
      //! Methods called directly by the equivalent GRTOOLVIEW method
      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint);

      //! Methods
      void ComputeCursorZone (const DPOINT2D&);
      void UpdateCursor () const;
   };


//!
//! GRTOOL_POINT - Point tool
//!
class GRTOOL_POINT : public GRTOOL_LIMITED {
   public:

      //! Constructor.
      explicit GRTOOL_POINT (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_POINT ();

      //! Assignment from DPOINT2D.
      GRTOOL_POINT& operator= (
         const DPOINT2D& rhs
         );

      //! Assigment from DPOINT3D.
      GRTOOL_POINT& operator= (
         const DPOINT3D& rhs
         );

      //! Get current tool point coordinates.
      const DPOINT3D& GetPoint (
         ) const { return (m_point); }

      //! Set marker type and size.
      //! The default marker is MARKER_Plus with a size of 9 pixels.
      void SetMarker (
         MARKER marker,                      //!< New marker type
         UINT16 size = 0                     //!< New marker size, 0 to retain current size
         );

   private:
      //! Enumeration constants
      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         };
      //! Tool settings
      MARKER m_marker;
      UINT16 m_markersize;
      //! Tool position values
      DPOINT3D m_point;                //!< Tool position
      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone

      //! Methods called by the GRTOOL base class
      virtual void DoDraw (CDC*);
      virtual void DoMove (double dx, double dy, ADJUSTFLAGS flags);
      //! Methods called directly by the equivalent GRTOOLVIEW method
      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint);

      //! Methods
      void ComputeCursorZone (const DPOINT2D&);
      void UpdateCursor () const;
   };


//!
//! GRTOOL_MULTIPOINT - Multi-Point tool
//!
class GRTOOL_MULTIPOINT : public GRTOOL {
   public:

      //! Constructor.
      explicit GRTOOL_MULTIPOINT (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_MULTIPOINT ();

      //! Create "form" with tool-specific controls.
      virtual MGUI::CTRL* CreateControlForm (
         MGUI::LAYOUT_PANE_BASE& ParentPane, //!< Parent pane
         CTRLOPT ctrlopt                     //!< Control options
         );

      //! Get active point coordinates.
      const DPOINT3D& GetActivePoint (
         ) const { return (m_Points[m_ActiveIndex]); }

      //! Get number of points.
      int GetNumPoints (
         ) const { return (m_Points.GetNumItems()); }

      //! Get single point.
      //! If the index is out of range the results are unpredictable.
      const DPOINT3D& GetPoint (
         int index                           //!< Zero-based index of point to retrieve
         ) const { return (m_Points[index]); }

      //! Get points.
      const DOUBLE_ARRAY<DPOINT3D> GetPoints (
         ) const { return (m_Points); }

      //! Determine if "active" point is valid.
      bool IsActiveValid (
         ) const { return (m_ActiveIndex >= 0 && m_ActiveIndex < m_Points.GetNumItems()); }

      //! Set marker type and size.
      //! The default marker is MARKER_Plus with a size of 9 pixels.
      void SetMarker (
         MARKER marker,                      //!< New marker type
         UINT16 size = 0                     //!< New marker size, 0 to retain current size
         );

   protected:

      //! Called when "active element" changed.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnChangeActiveElem (
         );

      //! Called when tool is "cleared" by user action, usually on control dialog.
      //! Derived class must call superclass method BEFORE performing own processing.
      virtual void OnClear (
         );

   private:

      enum EDITMODE {
         EDITMODE_Automatic,                 //!< Auto select when near point, move if selected, add if not near point
         EDITMODE_Add,                       //!< Always add new point
         EDITMODE_Move,                      //!< Move selected point to cursor
         EDITMODE_Select                     //!< Select point by clicking
         };

      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         };

      //! Tool settings
      MARKER m_marker;
      UINT16 m_markersize;
      EDITMODE m_EditMode;
      //! Tool position values
      DOUBLE_ARRAY<DPOINT3D> m_Points;    //!< Points
      int m_ActiveIndex;                  //!< Index of active point
      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone
      DPOINT2D m_prevpt;
      bool m_NotifyChangeElem;

      void ActivateClosestPoint (const DPOINT2D&);
      void AddPoint (CDC*, const DPOINT2D&);
      void AdjustTool (DPOINT2D&, MOVESEQ);
      void ComputeCursorZone (const DPOINT2D&);
      void DeletePoint ();
      virtual void DoDraw (CDC*);
      virtual void DoMove (double dx, double dy, ADJUSTFLAGS flags);
      void DrawNeighborPoints (CDC*, const LRECT2D&) const;
      void DrawPoint (CDC*, int) const;
      void ErasePoint (CDC*, bool circleonly = false) const;
      int FindClosestPoint (const DPOINT2D&) const;
      virtual bool OnKey (UINT nChar, UINT nRepCnt, UINT nFlags);
      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint);
      virtual void OnLButtonUp (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint);
      void SetActiveIndex (int);
      void UpdateCursor () const;
   };


//!
//! GRTOOL_CROSSHAIR - Crosshair tool
//!
class GRTOOL_CROSSHAIR : public GRTOOL_LIMITED {
   public:

      //! Constructor.
      explicit GRTOOL_CROSSHAIR (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_CROSSHAIR ();

      //! Assignment from DPOINT2D.
      GRTOOL_CROSSHAIR& operator= (
         const DPOINT2D& rhs
         );

      //! Get current rotation angle.
      //! @return Rotation angle in RADIANS.
      double GetAngle (
         ) const { return (m_angle); }

      //! Get current crosshair position.
      const DPOINT2D& GetPoint (
         ) const { return (m_point); }

   private:
      //! Enumeration constants
      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         };
      //! Tool position values
      DPOINT2D m_point;                   //!< Tool position
      double m_angle;                     //!< Rotation angle
      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone

      //! Methods called by the GRTOOL base class
      virtual void DoDraw (CDC*);
      virtual void DoMove (double dx, double dy, ADJUSTFLAGS flags);
      //! Methods called directly by the equivalent GRTOOLVIEW method
      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint);

      //! Methods
      void ComputeCursorZone (const DPOINT2D&);
      void UpdateCursor () const;
   };


//!
//!   GRTOOL_SEGMENT - Segment tool
//!
class GRTOOL_SEGMENT : public GRTOOL_LIMITED {
   public:

      //! Constructor.
      explicit GRTOOL_SEGMENT (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_SEGMENT ();

      //! Get segment end point coordinates.
      const DPOINT2D& GetEnd (
         ) const { return (m_endpoint); }

      //! Get segment start point coordinates
      const DPOINT2D& GetStart (
         ) const { return (m_startpoint); }

      //! Set markers for start and end points.
      void SetMarkers (
         MARKER startmarker,                 //!< Starting point marker type
         MARKER endmarker,                   //!< Ending point marker type
         UINT16 startmarkersize = 0,         //!< Starting point marker size, 0 to retain current size
         UINT16 endmarkersize = 0            //!< Ending point marker size, 0 to retain current size
         );

   private:
      //! Enumeration constants
      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         ZONE_Inside,
         ZONE_Start,
         ZONE_End
         };
      //! Tool settings
      MARKER m_startmarker;
      MARKER m_endmarker;
      UINT16 m_startmarkersize;
      UINT16 m_endmarkersize;
      //! Tool position values
      DPOINT2D m_endpoint;
      DPOINT2D m_startpoint;
      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone
      DPOINT2D m_prevpt;                  //!< Previous point during button-down
      UINT8 m_AdjustMode;                 //!< Adjustment mode, 2=rotate, 1=everything else

      //! Methods called by the GRTOOL base class
      virtual void DoDraw (CDC*);
      virtual void DoMove (double dx, double dy, ADJUSTFLAGS flags);
      //! Methods called directly by the equivalent GRTOOLVIEW method
      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint);

      //! Methods
      void AdjustTool (const DPOINT2D&, bool firsttime=false);
      void ComputeCursorZone (const DPOINT2D&);
      void StartTool (const DPOINT2D&);
      void UpdateCursor () const;
   };


//!
//! GRTOOL_CIRCLE - Circle tool
//!
class GRTOOL_CIRCLE : public GRTOOL {
   public:

      //! Constructor.
      explicit GRTOOL_CIRCLE (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_CIRCLE ();

      //! Generate region from tool boundary.
      //! @return TRUE if region generated, FALSE if not, < 0 if error.
      virtual int GenerateRegion (
         REGION2D& region
         ) const;

      //! Get current rotation angle.
      double GetAngle (
         ) const { return (m_angle); }

      //! Get center position.
      const DPOINT2D& GetCenter (
         ) const { return (m_center); }

      //! Get radius.
      double GetRadius (
         ) const { return (m_radius); }

      //! Set rotation angle.
      //! The rotation will only be visible to the user if SetAngleVisible() has been used.
      void SetAngle (
         double angle                        //!< New rotation angle in RADIANS
         );

      //! Set whether rotation angle indicator is visible.
      //! The rotation angle is indicated by a line from the center to the boundary.
      void SetAngleVisible (
         bool anglevisible = true
         );

      //! Set circle center coordinates.
      void SetCenter (
         const DPOINT2D& center
         );

      //! Set marker type and size.
      //! The default marker is MARKER_Plus with a size of 9 pixels.
      void SetMarker (
         MARKER marker,                      //!< New marker type
         UINT16 size = 0                     //!< New marker size, 0 to retain current size
         );

      //! Set radius.
      void SetRadius (
         double radius
         );

      //! Set allowed radius range.
      void SetRadiusRange (
         double minradius,                   //!< Minimum radius in tool units
         double maxradius                    //!< Maximum radius, <= 0 for no maximum
         );

   private:
      //! Enumeration constants
      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         ZONE_Inside,
         ZONE_Perimeter,
         ZONE_SetCenter,
         ZONE_Rotate,
         };
      //! Tool settings
      MARKER m_marker;
      UINT16 m_markersize;
      double m_minradius;                 //!< Minimum radius
      double m_maxradius;                 //!< Maximum radius, 0 if no maximum
      bool m_anglevisible;             //!< Visibility of rotation angle indicator
      //! Tool position values
      DPOINT2D m_center;                  //!< Center
      double m_radius;
      double m_angle;
      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone
      DPOINT2D m_prevpt;                  //!< Previous point during button-down

      //! Methods called by the GRTOOL base class
      virtual void DoDraw (CDC*);
      virtual void DoMove (double dx, double dy, ADJUSTFLAGS flags);
      //! Methods called directly by the equivalent GRTOOLVIEW method
      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint);

      //! Methods
      void AdjustTool (const DPOINT2D&, bool firsttime=false);
      void ComputeCursorZone (const DPOINT2D&);
      void StartTool (const DPOINT2D&);
      void UpdateCursor (const DPOINT2D&) const;
   };


//!
//! GRTOOL_ELLIPSE - Ellipse tool
//!
class GRTOOL_ELLIPSE : public GRTOOL {
   public:

      //! Constructor.
      explicit GRTOOL_ELLIPSE (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_ELLIPSE ();

      //! Generate region from tool boundary.
      //! @return TRUE if region generated, FALSE if not, < 0 if error.
      virtual int GenerateRegion (
         REGION2D& region
         ) const;

      //! Get current rotation angle.
      double GetAngle (
         ) const { return (m_angle); }

      //! Get center position.
      const DPOINT2D& GetCenter (
         ) const { return (m_center); }

      //! Get radius.
      const DPOINT2D& GetRadius (
         ) const { return (m_radius); }

      //! Set rotation angle.
      void SetAngle (
         double angle                        //!< New rotation angle in RADIANS
         );

      //! Set whether rotation angle indicator is visible.
      //! The rotation angle is indicated by a line from the center to the boundary.
      void SetAngleVisible (
         bool anglevisible = true
         );

      //! Set center coordinates.
      void SetCenter (
         const DPOINT2D& center
         );

      //! Set marker type and size.
      //! The default marker is MARKER_Plus with a size of 9 pixels.
      void SetMarker (
         MARKER marker,                      //!< New marker type
         UINT16 size = 0                     //!< New marker size, 0 to retain current size
         );

      //! Set radius.
      void SetRadius (
         DPOINT2D& radius
         );

      //! Set allowed radius range.
      void SetRadiusRange (
         double minradius,                   //!< Minimum radius in tool units
         double maxradius                    //!< Maximum radius, <= 0 for no maximum
         );

   private:
      //! Enumeration constants
      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         ZONE_Inside,
         ZONE_ResizeX,
         ZONE_ResizeY,
         ZONE_Perimeter,
         ZONE_SetCenter,
         ZONE_Rotate,
         };
      //! Tool settings
      MARKER m_marker;
      UINT16 m_markersize;
      double m_minradius;                 //!< Minimum radius
      double m_maxradius;                 //!< Maximum radius, 0 if no maximum
      bool m_anglevisible;                //!< Visibility of rotation angle indicator
      //! Tool position values
      DPOINT2D m_center;                  //!< Center
      DPOINT2D m_radius;
      double m_angle;
      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone
      DPOINT2D m_prevpt;                  //!< Previous point during button-down
      TRANS2D_AFFINE m_trans;             //!< Transformation to apply size,rotation,center

      //! Methods called by the GRTOOL base class
      virtual void DoDraw (CDC*);
      virtual void DoMove (double dx, double dy, ADJUSTFLAGS flags);
      //! Methods called directly by the equivalent GRTOOLVIEW method
      virtual void OnLButtonDown (UINT nFlags, const CPoint& mpoint);
      virtual void OnMouseMove (UINT nFlags, const CPoint& mpoint);

      //! Methods
      void AdjustTool (const DPOINT2D&, bool firsttime=false);
      void ComputeCursorZone (const DPOINT2D&);
      void StartTool (const DPOINT2D&);
      void UpdateCursor (const DPOINT2D&) const;
   };


//!
//! GRTOOL_ARC - Circular arc tool
//!
class GRTOOL_ARC : public GRTOOL {
   public:

      enum CLOSURE {
         CLOSURE_None,
         CLOSURE_Chord,
         CLOSURE_Wedge
         };

      //! Constructor.
      explicit GRTOOL_ARC (
         GRTOOLVIEW *view
         );

      //! Destructor.
      virtual ~GRTOOL_ARC ();

      //! Generate region from tool boundary.
      //! @return TRUE if region generated, FALSE if not, < 0 if error.
      virtual int GenerateRegion (
         REGION2D& region
         ) const;

      //! Get center position.
      const DPOINT2D& GetCenter (
         ) const { return (m_center); }

      //! Get closure type.
      CLOSURE GetClosure (
         ) const { return (m_closure); }

      //! Get radius.
      double GetRadius (
         ) const { return (m_radius); }

      //! Get starting angle.
      //! @return Starting angle in radians.
      double GetStartAngle (
         ) const { return (m_StartAngle); }

      //! Get sweep angle.
      //! @return Sweep angle in radians.
      double GetSweepAngle (
         ) const { return (m_SweepAngle); }

      //! Set center of arc.
      void SetCenter (
         const DPOINT2D& newcenter
         );

      //! Set closure type.
      void SetClosure (
         CLOSURE closure
         );

      //! Set marker type and size.
      //! The default marker is MARKER_Plus with a size of 9 pixels.
      void SetMarker (
         MARKER marker,                      //!< New marker type
         UINT16 size = 0                     //!< New marker size, 0 to retain current size
         );

      void SetRadius (
         double newradius
         );

      void SetRadiusRange (
         double newminradius,
         double newmaxradius
         );

      //! Set starting angle.
      void SetStartAngle (
         double startangle                   //!< Starting angle in radians
         );

      //! Set sweep angle
      void SetSweepAngle (
         double sweepangle                   //!< Sweep angle in radians
         );

   private:
      //! Enumeration constants
      enum ZONE {
         ZONE_NoFunction = 0,
         ZONE_Outside,
         ZONE_Inside,
         ZONE_Perimeter,
         ZONE_SetCenter,
         ZONE_Start,
         ZONE_End
         };
      //! Tool settings
      MARKER m_marker;
      UINT16 m_markersize;
      double m_minradius;                 //!< Minimum radius
      double m_maxradius;                 //!< Maximum radius, 0 if no maximum
      CLOSURE m_closure;
      //! Tool position values
      DPOINT2D m_center;                  //!< Center
      double m_radius;
      double m_StartAngle;
      double m_SweepAngle;
      //! Values used during interaction
      ZONE m_CursorZone;                  //!< Current cursor zone
      DPOINT2D m_prevpt;                  //!< Previous point during button-down

      //! Methods called by the GRTOOL base class
      virtual void