cancom.h

Go to the documentation of this file.

/*! \file wx/canvas/cancom.h
    \brief a2dCanvasCommandProcessor for do, undo and redo changes in a a2dCanvasDocument

    Each specific Command to change a document is wrapped into class. This class knows what to do,
    in order to make the change to the document. The command procesor recieves such a command, stores 
    in the undo stack and tells it to do the command. Undo-ing is reversing the change done,
    which the command class is able to do, since it stores the situation before the change, or it knows
    how to get back in that state.

    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: cancom.h,v 1.89 2009/10/01 19:22:35 titato Exp $
*/

#ifndef __WXCANCOM_H__
#define __WXCANCOM_H__

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/cmdproc.h"

#include "wx/canvas/canglob.h"
#include "wx/canvas/candoc.h"
#include "wx/canvas/tools.h"
#include "wx/docview/doccom.h"
#include "wx/canvas/booloper.h"
#include "wx/canvas/canvas.h"
#include "wx/canvas/canimage.h"
#include <wx/tokenzr.h>
#include <wx/uri.h>
#include <wx/numdlg.h>

#if wxART2D_USE_GDSIO
#include "wx/gdsio/gdsio.h"
#endif //wxART2D_USE_GDSIO

#if wxART2D_USE_KEYIO
#include "wx/keyio/keyio.h"
#endif //wxART2D_USE_KEYIO

#define  CMDP  (((a2dCanvasDocument*)GetCurrentDocument())->GetCanvasCommandProcessor())

extern const a2dMenuIdItem CmdMenu_ChangeCanvasObjectStyle;
extern const a2dMenuIdItem CmdMenu_ChangeCentralStyle;
extern const a2dMenuIdItem CmdMenu_SetLayer;
extern const a2dMenuIdItem CmdMenu_SetTarget;
extern const a2dMenuIdItem CmdMenu_SetDrawWireFrame; 
extern const a2dMenuIdItem CmdMenu_DrawGridLines; 
extern const a2dMenuIdItem CmdMenu_DrawGridAtFront;
extern const a2dMenuIdItem CmdMenu_SetYAxis;
extern const a2dMenuIdItem CmdMenu_Option_SplinePoly;
extern const a2dMenuIdItem CmdMenu_Option_CursorCrosshair;
extern const a2dMenuIdItem CmdMenu_Option_RescaleAtReSize;
extern const a2dMenuIdItem CmdMenu_Option_ReverseLayers;

extern const a2dMenuIdItem CmdMenu_Refresh;
extern const a2dMenuIdItem CmdMenu_ZoomOut;
extern const a2dMenuIdItem CmdMenu_ZoomOut2;
extern const a2dMenuIdItem CmdMenu_ZoomIn2;
extern const a2dMenuIdItem CmdMenu_EmptyShownObject;
extern const a2dMenuIdItem CmdMenu_DrawGrid;
extern const a2dMenuIdItem CmdMenu_SetSnap;
extern const a2dMenuIdItem CmdMenu_SetSnapFeatures;
extern const a2dMenuIdItem CmdMenu_SetSnapFeature;
extern const a2dMenuIdItem CmdMenu_SetStroke;
extern const a2dMenuIdItem CmdMenu_SetFill; 
extern const a2dMenuIdItem CmdMenu_SetStrokeColour;
extern const a2dMenuIdItem CmdMenu_SetFillColour; 
extern const a2dMenuIdItem CmdMenu_SetContourWidth; 
extern const a2dMenuIdItem CmdMenu_SetPathType; 
extern const a2dMenuIdItem CmdMenu_SetNormalizeFactor;

extern const a2dMenuIdItem CmdMenu_GdsIoSaveTextAsPolygon;
extern const a2dMenuIdItem CmdMenu_KeyIoSaveTextAsPolygon;
extern const a2dMenuIdItem CmdMenu_SetGdsIoSaveFromView;
extern const a2dMenuIdItem CmdMenu_SetKeyIoSaveFromView;

extern const a2dMenuIdItem CmdMenu_PushInto;
extern const a2dMenuIdItem CmdMenu_NewGroup;
extern const a2dMenuIdItem CmdMenu_NewPin;
extern const a2dMenuIdItem CmdMenu_SaveLayers;
extern const a2dMenuIdItem CmdMenu_SaveLayersHome;
extern const a2dMenuIdItem CmdMenu_SaveLayersLastDir;
extern const a2dMenuIdItem CmdMenu_SaveLayersCurrentDir;
extern const a2dMenuIdItem CmdMenu_LoadLayers;
extern const a2dMenuIdItem CmdMenu_LoadLayersHome;
extern const a2dMenuIdItem CmdMenu_LoadLayersLastDir;
extern const a2dMenuIdItem CmdMenu_LoadLayersCurrentDir;

extern const a2dMenuIdItem CmdMenu_SetCursor;
extern const a2dMenuIdItem CmdMenu_SetRelativeStart;
extern const a2dMenuIdItem CmdMenu_AddMeasurement;
extern const a2dMenuIdItem CmdMenu_ClearMeasurements;

extern const a2dMenuIdItem CmdMenu_GdsIoSaveFromView;
extern const a2dMenuIdItem CmdMenu_KeyIoSaveFromView;
extern const a2dMenuIdItem CmdMenu_SetLayersProperty;

extern const a2dMenuIdItem CmdMenu_Selected_SelectAll;
extern const a2dMenuIdItem CmdMenu_Selected_DeSelectAll;
extern const a2dMenuIdItem CmdMenu_Selected_Delete;
extern const a2dMenuIdItem CmdMenu_Selected_Group;
extern const a2dMenuIdItem CmdMenu_Selected_ImageToRectangles;
extern const a2dMenuIdItem CmdMenu_Selected_ToTop;
extern const a2dMenuIdItem CmdMenu_Selected_ToBack;
extern const a2dMenuIdItem CmdMenu_Selected_SetStyle;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertToPolygonPolylinesWithArcs;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertToPolygonPolylinesWithoutArcs;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertToPolylines;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertLinesArcs;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertToVPaths;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertPolygonToArcs;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertPolylineToArcs;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertPolygonToSurface;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertSurfaceToPolygon;
extern const a2dMenuIdItem CmdMenu_Selected_ConvertPathToPolygon;
extern const a2dMenuIdItem CmdMenu_Selected_UnGroup;
extern const a2dMenuIdItem CmdMenu_Selected_UnGroupDeep;
extern const a2dMenuIdItem CmdMenu_Selected_Merge;
extern const a2dMenuIdItem CmdMenu_Selected_Offset;
extern const a2dMenuIdItem CmdMenu_Selected_CreateRing;

extern const a2dMenuIdItem CmdMenu_GroupAB_Offset;
extern const a2dMenuIdItem CmdMenu_GroupAB_Smooth;
extern const a2dMenuIdItem CmdMenu_GroupAB_CreateRing;
extern const a2dMenuIdItem CmdMenu_GroupAB_Delete;
extern const a2dMenuIdItem CmdMenu_GroupAB_Move;
extern const a2dMenuIdItem CmdMenu_GroupAB_Copy;
extern const a2dMenuIdItem CmdMenu_GroupAB_ToArcs;
extern const a2dMenuIdItem CmdMenu_GroupAB_Or;
extern const a2dMenuIdItem CmdMenu_GroupAB_And;
extern const a2dMenuIdItem CmdMenu_GroupAB_Exor;
extern const a2dMenuIdItem CmdMenu_GroupAB_AsubB;
extern const a2dMenuIdItem CmdMenu_GroupAB_BsubA;
extern const a2dMenuIdItem CmdMenu_GroupAB_ConvertPolygonToSurface;
extern const a2dMenuIdItem CmdMenu_GroupAB_ConvertSurfaceToPolygon;


//! a command wrapper specially designed to work with wxArt2D docview classes and rest.
/*!
    This class wraps command string into functions for a a2dDocumentCommandProcessor. 

    \ingroup tools commands
*/
class A2DCANVASDLLEXP a2dCentralCanvasCommandProcessor : public a2dDocumentCommandProcessor
{
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    a2dInitCurrentSmartPointerOwner m_initCurrentSmartPointerOwner;
#endif

    A2D_DECLARE_EVENT_TABLE()
    DECLARE_CLASS(a2dCentralCanvasCommandProcessor)


public:

    friend class a2dCommand_GroupAB;

    //! \see a2dDocumentCommandProcessor
    a2dCentralCanvasCommandProcessor(long flags = a2dDEFAULT_DOCUMENT_FLAGS, 
                              bool initialize = true, 
                              int maxCommands = -1 );

    //! initilize with lower level command processor
    a2dCentralCanvasCommandProcessor( a2dDocumentCommandProcessor* other );

    //! destructor
    ~a2dCentralCanvasCommandProcessor();

    void OnUpdateMenu(wxUpdateUIEvent& event);

    //! All menu's a2dMenuIdItem using can be intercepted here
    void OnMenu( wxCommandEvent& event );

    //! return current document in the command processor
    a2dCanvasDocument* GetCanvasDocument() { return wxDynamicCast( m_currentDocument, a2dCanvasDocument ); }

    //! Get UnitScale of current document if set else returns 1
    double GetUnitsScaleOfDocument();

    //!set top object available in the a2dCanvasDocument to be used for adding other objects
    /*!
    \param obj: pointer to object to set as new parent a2dCanvasObject

    \remark the document will be searched to check if the object does exist,
    if not found, the rootobject of the document will be set as parent.

    \remark if obj is set to NULL, the rootobject of the document will be set.

    \return if the object is found and set return is true
    */
    bool SetParentObject( a2dCanvasObject* obj = 0 );

    //!return pointer of then current parent object
    //!\return: pointer to the current object that is used for adding other objects to.
    a2dCanvasObject* GetParentObject() { return m_parent; }

    void SetPopBeforePush( bool popBeforePush ) { m_popBeforePush = popBeforePush; } 

    bool GetPopBeforePush() { return m_popBeforePush; } 

    //! when set, tools are pushed in one shotmode in PushTool()
    void SetOneShotTools( bool oneShotTools ) { m_oneShotTools = oneShotTools; } 

    //! see SetOneShotTools()
    bool GetOneShotTools() { return m_oneShotTools; } 

    //! when set, drawing tools are going into edit mode after drawing 
    void SetEditAtEndTools( bool editAtEndTools ) { m_editAtEndTools = editAtEndTools; } 

    //! see SetEditAtEndTools
    bool GetEditAtEndTools() { return m_editAtEndTools; } 


    //! add the current canvas object to parent as child
    /*! First the current style is to the currentobject, and then it is added to the document.
        
          \param objectToAdd this is the object to add to the current parentobject
          \param withUndo if true a a2dCommand_AddObject will be used to have undo information
          \param setStyles the object added will get these styles that are currently set in the command processor
          \param parentObject when not NULL, this will become the current parent object.
    */
    a2dCanvasObject* AddCurrent( a2dCanvasObject* objectToAdd, bool withUndo = false, a2dPropertyIdList* setStyles = NULL, a2dCanvasObject* parentObject = NULL );

    bool CvgString( const wxString& cvgString );

    //! To set a property by to a certain object
    /*!
        \param objectname name of the object to set the property to.
            object name is:
            -# a2dBaseTool Sets a property on the a2dToolContr its FirstTool of the current a2dCanvasView.
            -# a2dToolContr Sets a property on the a2dToolContr of the current a2dCanvasView.
            -# a2dCanvasCommandProcessor Sets a property to this a2dCentralCanvasCommandProcessor
            -# a2dCentralCanvasCommandProcessor Sets a property on the current a2dCanvasDocument its wxCommandProcessor
        \param propertyname name of property
        \param value 
    */
    bool SetPropertyToObject(const wxString& objectname, const wxString& propertyname, const wxString& value = wxT("") );

    //! To set a property by to a certain object
    /*!
        \param objectname name of the object to set the property to.
            object name is:
            -# a2dBaseTool Sets a property on the a2dToolContr its FirstTool of the current a2dCanvasView.
            -# a2dToolContr Sets a property on the a2dToolContr of the current a2dCanvasView.
            -# a2dCanvasCommandProcessor Sets a property to this a2dCentralCanvasCommandProcessor
            -# a2dCentralCanvasCommandProcessor Sets a property on the current a2dCanvasDocument its wxCommandProcessor
        \param property the property to set
    */
    bool SetPropertyToObject( const wxString& objectname, a2dNamedProperty *property );

    //! set a layer property via command "setlayerproperty"
    /*!
        \param layer layer to add property to
        \param propertyname name of property
        \param value 
    */
    bool SetLayerProperty(long layer, const wxString &propertyname, const wxString& value );

    //! get the current canvas object to add to parent as child
    a2dCanvasObject* GetCurrentCanvasObject() { return m_currentobject; }

    //! set the current canvas object, which gets the change in style etc 
    /*!
        The current object is the object that gets the settings made on the commandprocessor
        and that do influence a a2dCanvasObject.
        Normally this is already set when a new object is added via commands.
        You must use NULL to reset the current object to not in use.

        When setting the current object, normally the object its properties are checked and the commandprocessor
        its internal chached properties or updated to that.

        \param currentcanvasobject the object to set current.
        \param takeOverProperties when true the internal chached properties are updated from the object.
    */
    void SetCurrentCanvasObject( a2dCanvasObject* currentcanvasobject, bool takeOverProperties = true );

    //!get the current stroke
    /*!
        Return the current stroke of the current document,
        if there is no document, return a2dBLACK_STROKE
    */
    const a2dStroke& GetStroke() const { return m_currentstroke; }

    //!get the current fill
    /*!
        Return the current fill of the current document,
        if there is no document, return a2dBLACK_FILL
    */
    const a2dFill& GetFill() const { return m_currentfill; }

    //!used for new objects etc. to set the stroke
    void SetStroke( const a2dStroke& stroke );

    //!used for new objects etc. to set the stroke
    void SetStroke(const unsigned char red, const unsigned char green, const unsigned char blue);
   
    //!used for new objects etc. to set the fill
    /*!
        \param fill to set, if NULL a2dNullFILL will be used
    */
    void SetFill( const a2dFill& fill );

    //!used for new objects etc. to set the fill
    void SetFill(const unsigned char red, const unsigned char green, const unsigned char blue);

    //!certain drawing tools like polygon drawing use this setting
    bool GetSpline() const {return m_spline;}

    void SetSpline( bool spline ){ m_spline = spline; }

    //!get current line begin object for line and polyline.
    /*!\return NULL if not set. */
    a2dCanvasObject* GetLineBegin() const { return m_currentBegin;}

    //!get current line end object for line and polyline. 
    /*!\return NULL if not set. */
    a2dCanvasObject* GetLineEnd() const { return m_currentEnd;}

    //!set current line begin object for line and polyline.
    void SetLineBegin( a2dCanvasObject* begin ){ m_currentBegin = begin; }

    //!set current line end object for line and polyline. 
    void SetLineEnd( a2dCanvasObject* end ){ m_currentEnd = end; }

    //!scaling in X for begin and end objects of lines and polylines
    void SetEndScaleX(double xs) { m_currentXscale = xs; }

    //!scaling in Y for begin and end objects of lines and polylines
    void SetEndScaleY(double ys) { m_currentYscale = ys; }

    //!get scaling in X for begin and end objects of lines and polylines
    double GetEndScaleX() const {return m_currentXscale;}

    //!get scaling in Y for begin and end objects of lines and polylines
    double GetEndScaleY() const {return m_currentYscale;}

    //!set the Contour width of shapes defined in database units
    /*
        m_currentContourWidth is always defined in meters, on the basis of the current document,
        it will be converted from databasunits.
    */
    void SetContourWidthInDataBaseUnits( double width );

    //!set the Contour width of shapes 
    /*
    */
    void SetContourWidth( const a2dDoMu& currentContourWidth );

    //!get the Contour width of shapes in the document its units
    /*
        m_currentContourWidth is always defined in meters, on the basis of the current document,
        it will be converted to databasunits.
    */
    double GetContourWidthInDataBaseUnits() const;

    //!get the Contour width of shapes in meters
    const a2dDoMu& GetContourWidth() const  { return m_currentContourWidth; }

    //! Set when m_contourwidth != 0 what is the end of the line should be.
    void SetPathType( a2dPATH_END_TYPE pathtype ) { m_pathtype = pathtype; }

    //! get when m_contourwidth != 0 what is the end of the line looks like.
    a2dPATH_END_TYPE GetPathType() { return m_pathtype; }

    //!used for new text objects etc. to set the font
    void SetFont( const a2dFont& font );

    //! get current font active font ( like used in text tool ).
    const a2dFont& GetFont() const { return m_font; }

    //!layer to be set for new objects.
    //!Default is layer wxLAYER_DEFAULT (colours etc taken from layer list)
    void SetLayer( wxUint16 layer, bool setStyleOfLayer = false );

    //!layer set for new objects.
    inline wxUint16 GetLayer() const { return m_layer; }

    //! returns the current active tool in the current active view
    /*! If the view is of type a2dCanvasView, then if a a2dToolContr is set for it,
        the first tool on its tool stack is returned.
    */
    a2dBaseTool* GetActiveTool();

    //! pop a tool from the tool stack of the current active a2dCanvasView
    /*!

    */
    a2dBaseTool* PopTool();

    //! set show object using index of child
    bool SetShowObject(int index);

    //! zoom into this area
    bool Zoom( double x1,double y1, double x2, double y2, bool upp );

    //! force an update of information on the currently active view
    bool Update();

    //! select this area
    bool Select( double x1,double y1, double x2, double y2 );

    //! de select this area
    bool DeSelect( double x1,double y1, double x2, double y2 );

    //! is a view with a2dCanvasView active
    a2dCanvasView* CheckDrawer() const;

    //! is a view with a2dCanvasView active and does it have a document
    a2dCanvasDocument* CheckCanvasDocument() const;

    //! get commandprocessor of document
    a2dCanvasCommandProcessor* GetDocCmdh() 
    { 
        wxASSERT_MSG( CheckCanvasDocument(), wxT("current document needs to be  a a2dCanvasDocument") );
        return  CheckCanvasDocument()->GetCanvasCommandProcessor(); 
    }

    //! sets operand A in layer operation
    void SetGroupA( const a2dLayerGroup& groupA ) { m_groupA = groupA; }

    //! sets operand B in layer operation
    void SetGroupB( const a2dLayerGroup& groupB ) { m_groupB = groupB; }

    //! return group A layers
    a2dLayerGroup& GetGroupA() { return m_groupA; }

    //! return group B layers
    a2dLayerGroup& GetGroupB() { return m_groupB; }

    //! add layer to group A layers
    void AddGroupA( wxUint16 layer ) { m_groupA.push_back( layer ); }

    //! add layer to group B layers
    void AddGroupB( wxUint16 layer ) { m_groupB.push_back( layer ); }

    //! set target layer in operation
    void SetTarget( wxUint16 target ) { m_target = target; }

    //! get target layer in operation
    wxUint16 GetTarget() { return m_target; }

    //! set selectedOnlyA in group operations
    void SetSelectedOnlyA( bool selectedOnlyA ) { m_selectedOnlyA = selectedOnlyA; }  
    
    //! get selectedOnlyA in group operations
    bool GetSelectedOnlyA() const { return m_selectedOnlyA; }
    
    //! set selectedOnlyB in group operations
    void SetSelectedOnlyB( bool selectedOnlyB ) { m_selectedOnlyB = selectedOnlyB; }   

    //! get selectedOnlyB in group operations
    bool GetSelectedOnlyB() const { return m_selectedOnlyB; }   

    //! boolean engine setting
    void SetBooleanEngineMarge( const a2dDoMu& marge ) { m_MARGE = marge; }
    //! boolean engine setting
    void SetBooleanEngineGrid( long grid ) { m_GRID = grid; }
    //! boolean engine setting
    void SetBooleanEngineDGrid( double dgrid ) { m_DGRID = dgrid; }
    //! boolean engine setting
    void SetBooleanEngineCorrectionAber( const a2dDoMu& aber ) { m_CORRECTIONABER = aber; }
    //! boolean engine setting
    void SetBooleanEngineCorrectionFactor( const a2dDoMu& aber ) { m_CORRECTIONFACTOR = aber; }
    //! boolean engine setting
    void SetBooleanEngineMaxlinemerge( const a2dDoMu& maxline ) { m_MAXLINEMERGE = maxline; }
    //! boolean engine setting
    void SetBooleanEngineWindingRule( bool rule ) { m_WINDINGRULE = rule; }
    //! boolean engine setting
    void SetBooleanEngineRoundfactor( double roundfac ) { m_ROUNDFACTOR = roundfac; }
    void SetBooleanEngineSmoothAber( const a2dDoMu& aber ) { m_SmoothAber = aber; }
    void SetBooleanEngineLinkHoles( bool doLinkHoles ) { m_LinkHoles = doLinkHoles; }
    //! Polygon/polyline to Arc Minimum radius to test
    void SetRadiusMin( const a2dDoMu& radiusMin ) { m_radiusMin = radiusMin; }
    //! Polygon/polyline to Arc Maximum radius to test
    void SetRadiusMax( const a2dDoMu& radiusMax ) { m_radiusMax = radiusMax; }
    //! Polygon/polyline to Arc Maximum abberation
    void SetAberPolyToArc( const a2dDoMu& aber );
    //! Arc to Polygon/polyline Maximum abberation
    void SetAberArcToPoly( const a2dDoMu& aber );
    //! detection of small object, smaller than this
    void SetSmall( const a2dDoMu& smallest );

    bool GdsIoSaveTextAsPolygon( bool onOff ); 
    bool KeyIoSaveTextAsPolygon( bool onOff ); 

    //! Polygon/polyline to Arc Minimum radius to test
    const a2dDoMu&  GetRadiusMin() const { return m_radiusMin; }
    //! Polygon/polyline to Arc Maximum radius to test
    const a2dDoMu& GetRadiusMax() const { return m_radiusMax; }
    //! Polygon/polyline to Arc Maximum abberation
    const a2dDoMu& GetAberPolyToArc() const { return m_AberPolyToArc; }
    //! Arc to Polygon/polyline Maximum abberation
    const a2dDoMu& GetAberArcToPoly() const { return m_AberArcToPoly; }
    //! detection of small object, smaller than this
    const a2dDoMu& GetSmall() const { return m_small; }

    //! grid setting X
    void SetGridX( const a2dDoMu& gridX );
    //! grid setting Y
    void SetGridY( const a2dDoMu& gridY );

    //! boolean engine setting
    const a2dDoMu& GetBooleanEngineMarge() const { return m_MARGE; }
    //! boolean engine setting
    long GetBooleanEngineGrid() const { return m_GRID; }
    //! boolean engine setting
    double GetBooleanEngineDGrid() const { return m_DGRID; }
    //! boolean engine setting
    const a2dDoMu& GetBooleanEngineCorrectionAber() const { return m_CORRECTIONABER; }
    //! boolean engine setting
    const a2dDoMu& GetBooleanEngineCorrectionFactor() const { return m_CORRECTIONFACTOR; }
    //! boolean engine setting
    const a2dDoMu& GetBooleanEngineMaxlinemerge() const  { return m_MAXLINEMERGE; }
    //! boolean engine setting
    bool GetBooleanEngineWindingRule() const  { return m_WINDINGRULE; }
    //! boolean engine setting
    double GetBooleanEngineRoundfactor() const  { return m_ROUNDFACTOR; }
    //! boolean engine setting
    const a2dDoMu& GetBooleanEngineSmoothAber() const  { return m_SmoothAber; }
    //! boolean engine setting
    bool GetBooleanEngineLinkHoles() const  { return m_LinkHoles; }

    //! set last mouse X position in world coordinates, as set by tools.
    /*!
        This position is used to set cursor position relative to the last entered position.
        The position can be set by drawing tools, when it makes sence to draw a next coordinates
        relative to the current/last entered coordinate.
    */
    void SetLastXyEntry( double x, double y ) { m_lastX = x; m_lastY = y; }

    //! holds last mouse X position in world coordinates, as set by tools.
    double GetLastXEntry() const { return m_lastX; }
    //! holds last mouse Y position in world coordinates, as set by tools.
    double GetLastYEntry() const { return m_lastY; }

    //! set RelativeStart measurement X and Y position in world coordinates
    /*!
        The RelativeStart start is used when mesuring using a tool, or from the commandline.
    */
    void SetRelativeStart( double x, double y ) { m_RelativeStartX = x; m_RelativeStartY = y; }

    //! holds last RelativeStart measurement X position in world coordinates
    double GetRelativeStartX() const { return m_RelativeStartX; }
    //! holds last RelativeStart measurement Y position in world coordinates
    double GetRelativeStartY() const { return m_RelativeStartY; }

    //! set clear of target in group operations
    /*!
        if set, in boolean operation the target layer will be cleared before adding results ot it.
    */
    void SetClearTarget( bool clearTarget ) { m_clearTarget = clearTarget; }   

    //! get clear of target in group operations
    bool GetClearTarget() const { return m_clearTarget; }   

    //! add specific object
    a2dCanvasObject* Add_a2dCanvasObject( double x = 0, double y = 0);

    //! add specific object
    a2dCanvasObjectReference* Add_a2dCanvasObjectReference( double x, double y, a2dCanvasObject* obj );

    //a2dNameReference* Add_a2dNameReference( double x, double y, a2dCanvasObject* obj, const wxString &text, double size, double angle );

    //! add specific object
    a2dOrigin* Add_a2dOrigin( double w, double h );

    //! add specific object
    a2dHandle* Add_a2dHandle( double xc, double yc, int w, int h, double angle = 0 , int radius = 0 );

    //! add specific object
    a2dRectC* Add_a2dRectC( double xc, double yc, double w, double h, double angle =0 , double radius=0 );

    //! add specific object
    a2dArrow* Add_a2dArrow( double xt, double yt, double l1, double l2, double b, bool spline = false );

    //! add specific object
    a2dRect* Add_a2dRect( double x, double y, double w, double h , double radius=0 );

    //! add specific object
    a2dCircle* Add_a2dCircle( double x, double y, double radius );

    //! add specific object
    a2dEllipse* Add_a2dEllipse( double xc, double yc, double width, double height );

    //! add specific object
    a2dEllipticArc* Add_a2dEllipticArc( double xc, double yc, double width, double height, double start, double end );

    //! add specific object
    a2dArc* Add_a2dArc( double xc, double yc, double radius, double start, double end );

    //! add specific object
    a2dSLine* Add_a2dSLine( double x1, double y1, double x2, double y2 );

    //! add specific object
    a2dEndsLine* Add_a2dEndsLine( double x1, double y1, double x2, double y2 );

    //! add specific object
    a2dImage* Add_a2dImage( const wxImage &image, double xc, double yc, double w, double h );

    //! add specific object
    a2dImage* Add_a2dImage( const wxString &imagefile, wxBitmapType type, double xc, double yc, double w, double h );

    //! add specific object
    a2dText* Add_a2dText( const wxString &text, double x, double y, double angle, const a2dFont& font );

    //! add specific object
    a2dPolygonL* Add_a2dPolygonL(a2dVertexList* points, bool spline = false );

    //! add specific object
    a2dPolylineL* Add_a2dPolylineL(a2dVertexList* points, bool spline = false );

    //! add a point to the current a2dCanvasObject
    bool Add_Point( double x, double y );

    //! add a point to the current a2dCanvasObject
    bool Move_Point( int index ,double x, double y );

    void FillLibraryPoints();
    
    a2dCanvasDocument* GetLibraryPoints() const { return m_librarypoints.Get(); }  
       
protected:

    const a2dFill& MX_GetFill() const { return m_currentfill; }
    void MX_SetFill( const a2dFill& value ) { m_currentfill = value; }
    const a2dStroke& MX_GetStroke() const { return m_currentstroke; }
    void MX_SetStroke( const a2dStroke& value ) { m_currentstroke = value; }
    const a2dFont& MX_GetFont() const { return m_font; }
    void MX_SetFont( const a2dFont& value ) { m_font = value; }

    //! next to calling base class a2dDocumentCommandProcessor::OnActivateView(), calls
    /*!
        SetParentObject() when the view is a a2dCanvasView view
    */
    void OnActivateView( a2dViewEvent& viewevent );

    //! do this at command start
    void OnBusyBegin( a2dCommandProcessorEvent& WXUNUSED(event) );

    //! do this at command end
    void OnBusyEnd( a2dCommandProcessorEvent& WXUNUSED(event) );

    void OnChangedDocument( a2dCommandEvent& event );

    //! pop a tool before a new one is pushed
    bool m_popBeforePush;

    //! tools only do one action then they are poped
    bool m_oneShotTools;

    //! drawing tools and with directly pushing the edit tool.
    bool m_editAtEndTools;

    //! for operation on groups of layers
    a2dLayerGroup m_groupA;

    //! for operation on groups of layers
    a2dLayerGroup m_groupB;

    //! target layer in operations
    wxUint16 m_target;

    //! operations on m_groupA but only selected objects
    bool m_selectedOnlyA;
    //! operations on m_groupB but only selected objects
    bool m_selectedOnlyB;
    //! clear target layer before adding results of an operation
    bool m_clearTarget;
    //! boolean operation setting
    a2dDoMu m_MARGE;
    //! boolean operation setting
    long   m_GRID;
    //! boolean operation setting
    double m_DGRID;
    //! boolean operation setting
    a2dDoMu m_CORRECTIONABER;
    //! boolean operation setting
    a2dDoMu m_CORRECTIONFACTOR;
    //! boolean operation setting
    a2dDoMu m_SMOOTHABER;
    //! boolean operation setting
    a2dDoMu m_MAXLINEMERGE;
    //! boolean operation setting
    bool   m_WINDINGRULE;
    //! boolean operation setting
    double m_ROUNDFACTOR;
    //! boolean operation setting
    a2dDoMu m_SmoothAber;
    //! boolean operation setting
    bool m_LinkHoles;
    //! Polygon/polyline to Arc Minimum radius to test
    a2dDoMu m_radiusMin;
    //! Polygon/polyline to Arc Maximum radius to test
    a2dDoMu m_radiusMax;
    //! Polygon/polyline to Arc Maximum abberation
    a2dDoMu m_AberPolyToArc;
    //! Arc to Polygon/polyline Maximum abberation
    a2dDoMu m_AberArcToPoly;
    //! detect samll objects
    a2dDoMu m_small;

    //! canvas default grid in X
    a2dDoMu m_gridX;
    //! canvas default grid in Y
    a2dDoMu m_gridY;

    //! current parent object to which new objects will be added as childs
    //! this is also the ShowObject of the Active a2dCanvasView when apropriate.
    a2dCanvasObjectPtr m_parent;

    //! last added object
    a2dCanvasObjectPtr m_currentobject;

    //! fill to be set for new objects
    a2dFill m_currentfill;

    //! stroke to be set for new objects
    a2dStroke m_currentstroke;

    //! current beginobject for lines and polylines
    a2dCanvasObjectPtr m_currentBegin;

    //! current endobject for lines and polylines
    a2dCanvasObjectPtr m_currentEnd;

    //! spline polygons
    bool m_spline;

    //!begin point scaling
    double  m_currentXscale;

    //!end point scaling
    double  m_currentYscale;

    //! current contour width e.g for polyline with width.
    a2dDoMu m_currentContourWidth;

    //! when m_contourwidth != 0 what is the end of the line/polyline.
    a2dPATH_END_TYPE m_pathtype;

    //! layer to be set for new objects
    wxUint16 m_layer;

    //! add in front of parent childs or add end
    bool m_AppendOrPrepend;

    //!current font set
    a2dFont m_font;

    //! holds last mouse X position in world coordinates, as set by tools.
    double m_lastX;
    //! holds last mouse Y position in world coordinates, as set by tools.
    double m_lastY;

    //! The RelativeStart start is used when mesuring using a tool, or from the commandline.
    double m_RelativeStartX;

    //! The RelativeStart start is used when mesuring using a tool, or from the commandline.
    double m_RelativeStartY;

    bool m_keySaveTextAsPolygon;
    bool m_gdsiiSaveTextAsPolygon;
    bool m_keySaveFromView;
    bool m_gdsiiSaveFromView;
    
    a2dSmrtPtr<a2dCanvasDocument> m_librarypoints;  

public:
    // member ids

    static a2dPropertyIdCanvasObject* PROPID_Begin;
    static a2dPropertyIdCanvasObject* PROPID_End;
    static a2dPropertyIdDouble* PROPID_EndScaleX;
    static a2dPropertyIdDouble* PROPID_EndScaleY;
    static a2dPropertyIdBool* PROPID_Spline;

    static a2dPropertyIdFill* PROPID_Fill;
    static a2dPropertyIdStroke* PROPID_Stroke;
    static a2dPropertyIdFont* PROPID_Font;
    static a2dPropertyIdUint16* PROPID_Layer;

    static a2dPropertyIdBool* PROPID_PopBeforePush;
    static a2dPropertyIdBool* PROPID_OneShotTools;
    static a2dPropertyIdBool* PROPID_EditAtEndTools;
    static a2dPropertyIdBool* PROPID_Snap;

    DECLARE_PROPERTIES()
};

A2DCANVASDLLEXP extern a2dDrawer2D *a2dGetDrawer2D();

A2DCANVASDLLEXP extern a2dCentralCanvasCommandProcessor* a2dGetCmdh(); 



//! a command processor specially designed to work with a a2dCanvasDocument
/*!
    This command processor allows you to add object to the document and
    takes care of undo redo.

    \ingroup tools commands
*/
class A2DCANVASDLLEXP a2dCanvasCommandProcessor : public a2dCommandProcessor
{

public:
    a2dCanvasCommandProcessor( a2dCanvasDocument* doc, int maxCommands = -1);
    ~a2dCanvasCommandProcessor();

    //* next to the base class submit, it sets the document and commandprocessor for
    /*!
        a2dDocumentCommand
    */
    virtual bool Submit(a2dCommand* command, bool storeIt = true);

    //! submit a command template with multiple objects
    virtual bool SubmitMultiple( a2dCommand* command, a2dCanvasObjectList *objects, bool storeIt = true );

    a2dCanvasDocument* GetCanvasDocument() { return m_doc; }

    //! convert canvasobject to a list of polygons.
    //! But only for simple primitive objects.
    //! first a2dCanvasObject::GetAsCanvasVpaths() is used to convert to vector paths,
    //! and next the vector path is translated into polygons.
    a2dCanvasObjectList* ConvertToPolygons( a2dCanvasObject* canvasobject, bool transform );

    //! convert canvasobject to a list of Vpath.
    //! But only for simple primitive objects.
    //! first a2dCanvasObject::GetAsCanvasVpaths() is used to convert to vector paths,
    a2dCanvasObjectList* ConvertToVpath( a2dCanvasObject* canvasobject, bool transform );

    //! sets current style object to current canvas object
    /*!
        For the property id's in the list, copy the current settings in the command processor
        to the current object.

        \param setStyles lit of property id which will be set if available in the command processor.
    */
    //void SetStyle(  a2dPropertyIdList* setStyles );

    DECLARE_CLASS(a2dCanvasCommandProcessor);


protected:

    //! command processed for this document
    /*! This cannot be a smart pointer, because the document owns command processor */
    a2dCanvasDocument *m_doc;
};

//! used to add object to a a2dCanvasDocument in the current parent
/*!

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_AddObject: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_AddObject)

public:
    //! used to add object to a a2dCanvasDocument in the current parent
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_AddObject() { m_canvasobject = NULL; m_parent = NULL; }

    a2dCommand_AddObject( a2dCanvasObject* parent, a2dCanvasObject* object );

    ~a2dCommand_AddObject(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObject *GetCanvasObject() { return m_canvasobject; }
    a2dCanvasObject *GetParent() { return m_parent; }

protected:
    a2dCanvasObjectPtr m_canvasobject;
    a2dCanvasObjectPtr m_parent;
};

//! used to release object from a a2dCanvasDocument in the current parent
/*!

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ReleaseObject: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ReleaseObject)

public:

    //! used to release object from a a2dCanvasDocument in the current parent
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_ReleaseObject() { m_canvasobject = NULL; m_parent = NULL; m_index = 0; m_now = true; }

    a2dCommand_ReleaseObject( a2dCanvasObject* parent,  a2dCanvasObject* object, bool now = true );

    ~a2dCommand_ReleaseObject(void);

    bool Do();
    bool Undo();

    a2dCanvasObject *GetCanvasObject() { return m_canvasobject; }
    a2dCanvasObject *GetParent() { return m_parent; }

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dCanvasObjectPtr m_canvasobject;
    a2dCanvasObjectPtr m_parent;
    int m_index;
    bool m_now;
};

//! used to replace an object in a a2dCanvasDocument in the current parent
/*!

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ReplaceObject: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ReplaceObject)

public:
    //! used to replace an object in a a2dCanvasDocument in the current parent
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_ReplaceObject() { m_canvasobject = NULL;  m_canvasobject2 = NULL; m_parent = NULL; }

    a2dCommand_ReplaceObject( a2dCanvasObject* parent, a2dCanvasObject* oldobject, a2dCanvasObject* newobject );

    ~a2dCommand_ReplaceObject(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dCanvasObjectPtr m_canvasobject;
    a2dCanvasObjectPtr m_canvasobject2;
    a2dCanvasObjectPtr m_parent;
};

//! for changing boolean values inside a rectangle of the current parent object.
/*!
*/
class A2DCANVASDLLEXP a2dCommand_SetFlags: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetFlags)
public:

    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_SetFlags() { m_parent = NULL; }

    //! given flags of objects within the rectangle are set to value
    a2dCommand_SetFlags( a2dCanvasObject* parent, a2dCanvasObjectFlagsMask which, bool value, const a2dBoundingBox& bbox = wxNonValidBbox );

    ~a2dCommand_SetFlags(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dBoundingBox m_bbox;

    a2dCanvasObjectFlagsMask m_mask;

    a2dCanvasObjectList* m_objects;
    a2dlist< a2dCanvasObjectFlagsMask > m_objectOldMask;

    a2dCanvasObjectPtr m_parent;

    bool m_bool;
};

//! for changing boolean values inside canvas objects
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetFlag: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetFlag)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_SetFlag() { m_canvasobject = NULL; }

    //! given flag of object set to value
    a2dCommand_SetFlag( a2dCanvasObject* object, a2dCanvasObjectFlagsMask which, bool value );

    ~a2dCommand_SetFlag(void);

    virtual a2dCommand* CloneAndBind( a2dPropObject *object );

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dCanvasObjectPtr m_canvasobject;

    a2dCanvasObjectFlagsMask m_which;

    bool m_bool;
};

//! for changing boolean select flag values inside canvas objects
/*!
    This command takes into account the layer settings of the a2dCanvasDocument,
    if there the layer is set non selectable, nothing will be done.

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetSelectFlag: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetSelectFlag)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_SetSelectFlag() { m_canvasobject = NULL; }

    //! given select flag of object set to value
    a2dCommand_SetSelectFlag( a2dCanvasObject* object, bool value );

    ~a2dCommand_SetSelectFlag(void);

    virtual a2dCommand* CloneAndBind( a2dPropObject *object );

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dCanvasObjectPtr m_canvasobject;

    bool m_bool;
};

#include <wx/listimpl.cpp>

//! used as part of a a2dCommand_TransformMask to store the matrix 
//! of a a2dCanvasObject, in order to Undo/Redo the command
class A2DCANVASDLLEXP a2dCommandMatrixData 
{

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommandMatrixData( a2dCanvasObject* WXUNUSED(parent), a2dCanvasObject* object, const a2dAffineMatrix& transform )
    {
        m_object = (a2dCanvasObject*) object;
        m_transform = transform;
    }

    ~a2dCommandMatrixData()
    {
    }

    a2dCanvasObjectPtr m_parent;

    a2dCanvasObjectPtr m_object;
    a2dAffineMatrix m_transform;
};

typedef a2dlist< a2dCommandMatrixData > a2dObjectMatrixList;

//! for changing only the matrix of objects for which a certain mask was set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_TransformMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_TransformMask)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_TransformMask() { m_parent = NULL; }

    a2dCommand_TransformMask( const a2dAffineMatrix& newtransform, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL );

    ~a2dCommand_TransformMask(void);

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_TransformMask( m_transform, m_which, m_parent );
    }

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dCanvasObjectPtr m_parent;

    a2dObjectMatrixList m_objectsMatrix; 

    a2dCanvasObjectFlagsMask m_which;

    a2dAffineMatrix m_transform;
};

//! used to add points to polygon objects 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_AddPoint: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_AddPoint)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_AddPoint() { m_canvasobject = NULL; }

    a2dCommand_AddPoint( a2dCanvasObject* object, double x, double y, int index, bool afterinversion = true );
    a2dCommand_AddPoint( a2dCanvasObject* object, double x, double y, a2dLineSegmentPtr seg, bool afterinversion = true );
    ~a2dCommand_AddPoint(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    // x of point
    double m_x;

    // y of point
    double m_y;

    a2dLineSegmentPtr m_seg;

    bool m_afterinversion;

    a2dCanvasObjectPtr m_canvasobject;

};

//! used to move points in polygon objects 
/*!
*/
class A2DCANVASDLLEXP a2dCommand_MoveSegment: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_MoveSegment)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_MoveSegment() { m_canvasobject = NULL; }

    a2dCommand_MoveSegment( a2dCanvasObject* object, double x, double y, int index, bool afterinversion = true );
    a2dCommand_MoveSegment( a2dCanvasObject* object, double x, double y, a2dLineSegmentPtr seg, bool afterinversion = true );
    ~a2dCommand_MoveSegment(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    // x of point
    double m_x;

    // y of point
    double m_y;

    a2dLineSegmentPtr m_seg;

    bool m_afterinversion;

    a2dCanvasObjectPtr m_canvasobject;

};

//! used to move points in polygon objects 
/*!
*/
class A2DCANVASDLLEXP a2dCommand_MoveMidSegment: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_MoveMidSegment)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_MoveMidSegment() { m_canvasobject = NULL; }

    a2dCommand_MoveMidSegment( a2dCanvasObject* object, double x, double y, int index, bool afterinversion = true );
    a2dCommand_MoveMidSegment( a2dCanvasObject* object, double x, double y, a2dLineSegmentPtr seg, bool afterinversion = true );
    ~a2dCommand_MoveMidSegment(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    // x of point
    double m_x;

    // y of point
    double m_y;

    bool m_afterinversion;

    a2dLineSegmentPtr m_seg;

    a2dCanvasObjectPtr m_canvasobject;

};

//! used to remove points from polygon objects 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_RemoveSegment: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_RemoveSegment)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_RemoveSegment() { m_canvasobject = NULL; }

    a2dCommand_RemoveSegment( a2dCanvasObject* object, int index );
    a2dCommand_RemoveSegment( a2dCanvasObject* object, a2dLineSegmentPtr seg );
    ~a2dCommand_RemoveSegment(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    //! where did we remove it, in order to insert there in case of undo
    unsigned int m_index;

    //! segment removed
    a2dLineSegmentPtr m_seg;

    a2dCanvasObjectPtr m_canvasobject;
};

//! used to set the complete Segment list/array of polygons
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetSegments: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetSegments)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_SetSegments() { m_canvasobject = NULL; }

    a2dCommand_SetSegments( a2dCanvasObject* object, a2dVertexList *segments, bool afterinversion );
    ~a2dCommand_SetSegments(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    // Segment list
    a2dSmrtPtr<a2dVertexList> m_segments;

    a2dCanvasObjectPtr m_canvasobject;
};

//! used to change text and caret of canvas text objects in a a2dCanvasDocument
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ChangeText: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ChangeText)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_ChangeText() { m_canvasobject = NULL; }

    a2dCommand_ChangeText( a2dText* object, wxString text, 
            int caret, const a2dFont& font, double linespace, unsigned int textflags );
    ~a2dCommand_ChangeText(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    wxString m_text;
    int m_caret;
    a2dFont m_font;
    double m_linespace;
    unsigned int m_textflags;
    a2dSmrtPtr<a2dText> m_canvasobject;
};

//! used to change style of canvas objects in a a2dCanvasDocument
/*!
*/
class A2DCANVASDLLEXP a2dCommand_ChangeCanvasObjectStyle: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ChangeCanvasObjectStyle)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    //! non info.
    static const a2dCommandId sm_SetFillStyleCommand;
    static const a2dCommandId sm_SetStrokeStyleCommand;
    static const a2dCommandId sm_SetStyleCommand;

    a2dCommand_ChangeCanvasObjectStyle() { m_propObject = NULL; }

    a2dCommand_ChangeCanvasObjectStyle( a2dPropObject* object, const a2dFill& fill );
    a2dCommand_ChangeCanvasObjectStyle( a2dPropObject* object, const a2dStroke& stroke );
    a2dCommand_ChangeCanvasObjectStyle( a2dPropObject* object, const a2dFill& fill, const a2dStroke& stroke );
                              
    ~a2dCommand_ChangeCanvasObjectStyle(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dSmrtPtr< a2dPropObject > m_propObject;

    a2dFill m_fill;

    a2dStroke m_stroke;

};

//! used to change style of canvas objects in a a2dCanvasDocument
/*!
*/
class A2DCANVASDLLEXP a2dCommand_ChangeCentralStyle: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ChangeCentralStyle)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    //! non info.
    static const a2dCommandId sm_SetFillStyleCommand;
    static const a2dCommandId sm_SetStrokeStyleCommand;
    static const a2dCommandId sm_SetStyleCommand;

    a2dCommand_ChangeCentralStyle() { m_propObject = NULL; }

    a2dCommand_ChangeCentralStyle( a2dPropObject* object, const a2dFill& fill );
    a2dCommand_ChangeCentralStyle( a2dPropObject* object, const a2dStroke& stroke );
    a2dCommand_ChangeCentralStyle( a2dPropObject* object, const a2dFill& fill, const a2dStroke& stroke );
                              
    ~a2dCommand_ChangeCentralStyle(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dSmrtPtr< a2dPropObject > m_propObject;

    a2dFill m_fill;

    a2dStroke m_stroke;
};

//! used to change a property on objects
/*!
    A a2dObject property is set on the a2dPropObject, and the first property 
    on the a2dPropObject with the same name is used for undo.
    If the property was not yet set for the object, in Undo the new property is just removed, else
    the old value is restored.
*/
class A2DCANVASDLLEXP a2dCommand_SetCanvasProperty: public a2dCommand_SetProperty
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetCanvasProperty)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_SetCanvasProperty(){}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.
        
       \param object the canvas object to set the property on.
       \param property the property to set
    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, a2dNamedProperty* property )
        :a2dCommand_SetProperty( object, property ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.
    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdRefObject* id, a2dObject *value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.

    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdString* id, const wxString& value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.

    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdBool* id, bool value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.

    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdInt16* id, wxInt16 value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.

    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdUint16* id, wxUint16 value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.

    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdInt32* id, wxInt32 value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.

    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdUint32* id, wxUint32 value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param object the canvas object to set the property on.
        \param id the name of the property to set.
        \param value the value to set the property to.

    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdDouble* id, double value )
        :a2dCommand_SetProperty( object, id, value ) {}

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param id the name of the property to set.
        \param value the value to set the property to.
        \param object the canvas object to set the property on.
    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdCanvasObject* id, a2dCanvasObject* value );
    
    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param id the name of the property to set.
        \param value the value to set the property to.
        \param object the canvas object to set the property on.
    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdMatrix* id, const a2dAffineMatrix& value );

    //! Set property on object 
    /*!
        The property its name is used for undo, and restore the old value if available.

        \param id the name of the property to set.
        \param point the point for the internal a2dPoint2DProperty
        \param index the index for the internal a2dPoint2DProperty
        \param afterinversion the afterinversion for the internal a2dPoint2DProperty
        \param object the canvas object to set the property on.
    */
    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdPoint2D* id, const a2dPoint2D& point, int index = -1, bool afterinversion = true );

    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdFill* id, const a2dFill& fill = *a2dNullFILL );

    a2dCommand_SetCanvasProperty( a2dPropObject* object, const a2dPropertyIdStroke* id, const a2dStroke& stroke = *a2dNullSTROKE );

    ~a2dCommand_SetCanvasProperty(void);

    virtual a2dCommand* CloneAndBind( a2dPropObject *object );

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }
};


//! used to connect two pins
/*!

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ConnectPins: public a2dCommand
{

    DECLARE_DYNAMIC_CLASS(a2dCommand_ConnectPins)

public:
    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_ConnectPins() {}

    a2dCommand_ConnectPins( a2dPin* pin1, a2dPin* pin2 );

    ~a2dCommand_ConnectPins(void);

    bool Do();
    bool Undo();

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectPtr m_pin1;
    a2dCanvasObjectPtr m_pin2;
    a2dCanvasObjectPtr m_pin1oldtarget;
    a2dCanvasObjectPtr m_pin2oldtarget;
};

//===========================================================================================
// commands 
//===========================================================================================


//! command on selected objects
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_Select: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_Select)

public:


    //! Print the current document or view
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    //! defines what to do
    /*! 
    */
    enum a2dDoWhat
    {
        SelectAll,      //!< select all objects
        DeSelectAll,    //!< de-select all objects
        SelectRect,     //!< select objects in a rectangle area
        DeSelectRect    //!< de-select objects in a rectangle area
    };

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.what = false;
            argSet.layer = false;
            argSet.x1 = false;
            argSet.y1 = false;
            argSet.x2 = false;
            argSet.y2 = false;
            argValue.layer = 0;
            argValue.x1 = 0;
            argValue.y1 = 0;
            argValue.x2 = 0;
            argValue.y2 = 0;
            argValue.layervisible = true;
            argValue.layerselectable = true;
        }

        A2D_ARGUMENT_SETTER( a2dDoWhat, what )            
        A2D_ARGUMENT_SETTER( wxUint16, layer )            
        A2D_ARGUMENT_SETTER( double, x1 )            
        A2D_ARGUMENT_SETTER( double, y1 )  
        A2D_ARGUMENT_SETTER( double, x2 )            
        A2D_ARGUMENT_SETTER( double, y2 )  
        A2D_ARGUMENT_SETTER( bool, layervisible )            
        A2D_ARGUMENT_SETTER( bool, layerselectable )  

        struct argValue
        {
            a2dDoWhat what;
            wxUint16 layer;
            double x1;
            double y1;
            double x2;
            double y2;            
            bool layervisible;
            bool layerselectable;
        } argValue;

        struct argSet
        {
            bool what;
            bool layer;
            bool x1;
            bool y1;
            bool x2;
            bool y2;
            bool layervisible;
            bool layerselectable;
        } argSet;
    };

    a2dCommand_Select() {}

    a2dCommand_Select( const Args& args, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    {       
        m_args = args;
        m_parent = parent;
        m_oldobjects = wxNullCanvasObjectList;
    }

    ~a2dCommand_Select() 
    { 
        if ( m_oldobjects != wxNullCanvasObjectList )
            delete m_oldobjects;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_Select( m_args, m_parent );
    }

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

private:

    Args m_args;
    a2dCanvasObjectList* m_oldobjects;
    a2dlist< bool > m_oldobjectsSelected;

    a2dCanvasObjectPtr m_parent;

    virtual bool Do();

    virtual bool Undo();

};


//! command to zoom in view
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_Zoom: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_Zoom)
public:

    //! Print the current document or view
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    //! defines what to do
    /*! 
    */
    enum a2dDoWhat
    {
        ZoomOut, //!< zoom to whole, drawing in current view
        Zoom,    //!< zoom to rectangle in drawing in current view
    };

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.what = false;
            argSet.x1 = false;
            argSet.y1 = false;
            argSet.x2 = false;
            argSet.y2 = false;
            argSet.upp = false;
            argValue.x1 = 0;
            argValue.y1 = 0;
            argValue.x2 = 0;
            argValue.y2 = 0;
            argValue.upp = true;
        }

        A2D_ARGUMENT_SETTER( a2dDoWhat, what )            
        A2D_ARGUMENT_SETTER( double, x1 )            
        A2D_ARGUMENT_SETTER( double, y1 )  
        A2D_ARGUMENT_SETTER( double, x2 )            
        A2D_ARGUMENT_SETTER( double, y2 )  
        A2D_ARGUMENT_SETTER( bool, upp )  

        struct argValue
        {
            a2dDoWhat what;
            double x1;
            double y1;
            double x2;
            double y2;
            bool upp;
        } argValue;

        struct argSet
        {
            bool what;
            bool x1;
            bool y1;
            bool x2;
            bool y2;
            bool upp;
        } argSet;
    };

    a2dCommand_Zoom( a2dDoWhat what = ZoomOut ): a2dCommand( false, Id )
    {       
        m_args.what( what );
    }

    a2dCommand_Zoom( const Args& args ): a2dCommand( false, Id )
    {       
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_Zoom( m_args );
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

private:

    Args m_args;

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;

        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        if ( m_args.argValue.what == Zoom )
        {
            return GetCanvasCmp()->Zoom( m_args.argValue.x1, m_args.argValue.y1, m_args.argValue.x2, m_args.argValue.y2, m_args.argValue.upp );
        }
        else if ( m_args.argValue.what == ZoomOut )
        {
            if ( drawer->GetCanvas() )
                drawer->GetCanvas()->SetMappingShowAll();
            else    
                drawer->SetMappingShowAll();
        }
        else
            return false;
        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};


//! command on selected objects
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_GroupAB: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_GroupAB)
public:

    //! Print the current document or view
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    //! defines what to do
    /*! 
    */
    enum a2dDoWhat
    {
        DeleteGroupA,      //!<  delete group A objects
        MoveGroupA,        //!<  move   group A objects
        CopyGroupA,        //!<  copy   group A objects
        ConvertToArcs, //!<  convert segments in polygon/polyline objects in group A to Arcs where possible
        ConvertToPolygonPolylinesWithArcs, //!<  convert to simple polygons and polylines
        ConvertToPolygonPolylinesWithoutArcs, //!<  convert to simple polygons and polylines
        ConvertPolygonToArcs,   //!<  convert segments in polygon/polyline with width objects in group A to Arcs where possible
        ConvertPolylineToArcs,   //!<  convert segments in polyline objects in group A to Arcs where possible
        ConvertToVPaths, //!<  convert shapes to vector paths
        ConvertLinesArcs, //!< convert shapes to seperate lines and arcs
        ConvertToPolylines, //!< convert shapes to polylines even if polygons
        DetectSmall, //! < generate a report of small objects
        RemoveRedundant,    //! remove redundant segment
        Boolean_OR, /*!< boolean OR operation */
        Boolean_AND, /*!< boolean AND operation */
        Boolean_EXOR, /*!< boolean EX_OR operation */
        Boolean_A_SUB_B, /*!< boolean Group A - Group B operation */
        Boolean_B_SUB_A, /*!< boolean Group B - Group A operation */
        Boolean_CORRECTION, /*!< polygon correction/offset operation */
        Boolean_SMOOTHEN, /*!< smooth operation */
        Boolean_MAKERING, /*!< create a ring on all polygons */
        Boolean_Polygon2Surface, /*!< convert polygon shapes to surfaces */
        Boolean_Surface2Polygon /*!< convert surfaces shapes to polygons */
    };

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.what = false;
            argSet.target = false;
            argSet.clearTarget = false;
            argSet.selectedA = false;
            argSet.selectedB = false;
            argSet.fileNameOut = false;
            argSet.detectCircle = false;
            argValue.target = 0;
            argValue.clearTarget = false;
            argValue.selectedA = false;
            argValue.selectedB = false;
            argValue.detectCircle = false;
        }

        A2D_ARGUMENT_SETTER( a2dDoWhat, what )            
        A2D_ARGUMENT_SETTER( wxUint16, target )            
        A2D_ARGUMENT_SETTER( bool, clearTarget )            
        A2D_ARGUMENT_SETTER( bool, selectedA )  
        A2D_ARGUMENT_SETTER( bool, selectedB )  
        A2D_ARGUMENT_SETTER( wxString, fileNameOut )  
        A2D_ARGUMENT_SETTER( bool, detectCircle )  

        struct argValue
        {
            a2dDoWhat what;            
            wxUint16 target;            
            bool clearTarget;            
            bool selectedA;  
            bool selectedB;  
            bool detectCircle;
            wxString fileNameOut; 
        } argValue;

        struct argSet
        {
            bool what;
            bool target;
            bool clearTarget;            
            bool selectedA;  
            bool selectedB;  
            bool detectCircle;
            bool fileNameOut; 
        } argSet;
    };

    a2dCommand_GroupAB( const Args& args = Args() ): a2dCommand( false, Id )
    {       
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_GroupAB( m_args );
    }

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

private:

    virtual bool Do();

    virtual bool Undo();

    Args m_args;

};

//! layer group A and B commands
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetLayerGroup: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetLayerGroup)
public:

    //!  layer group A and B command
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    //! defines what to do
    /*! 
    */
    enum a2dDoWhat
    {
        SetGroupA,      //!< add a layer to a operation group A
        SetGroupB,      //!< add a layer to a operation group B
        AddGroupA,      //!< add a layer to a operation group A
        AddGroupB,      //!< add a layer to a operation group B
        ClearGroupA,      //!< clear all layers in operation group A
        ClearGroupB,      //!< clear all layers in operation group B
    };

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.what = false;
            argSet.layer = false;
            argSet.group = false;
            argValue.layer = 0;
        }

        A2D_ARGUMENT_SETTER( a2dDoWhat, what )            
        A2D_ARGUMENT_SETTER( wxUint16, layer )            
        A2D_ARGUMENT_SETTER( a2dLayerGroup, group )            

        struct argValue
        {
            a2dDoWhat what;
            wxUint16 layer;
            a2dLayerGroup group;
        } argValue;

        struct argSet
        {
            bool what;
            bool layer;
            bool group;
        } argSet;
    };

    a2dCommand_SetLayerGroup( const Args& args  = Args() ): a2dCommand( false, Id )
    {       
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetLayerGroup( m_args );
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

    Args m_args;

protected:

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;

        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        if ( m_args.argValue.what == SetGroupA )
        {
            GetCanvasCmp()->GetGroupA() = m_args.argValue.group;
        }
        else if ( m_args.argValue.what == SetGroupB )
        {
            GetCanvasCmp()->GetGroupB() = m_args.argValue.group;
        }
        else if ( m_args.argValue.what == AddGroupA )
        {
            GetCanvasCmp()->GetGroupA().push_back( m_args.argValue.layer );
        }
        else if ( m_args.argValue.what == AddGroupB )
        {
            GetCanvasCmp()->GetGroupB().push_back( m_args.argValue.layer );
        }
        else if ( m_args.argValue.what == ClearGroupA )
        {
            GetCanvasCmp()->GetGroupA().clear();
        }
        else if ( m_args.argValue.what == ClearGroupB )
        {
            GetCanvasCmp()->GetGroupB().clear();
        }
        return false;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! set layer
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetLayer: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetLayer)
public:
    static const a2dCommandId Id;

    a2dCommand_SetLayer( wxUint16 set = 0, bool setStyleOfLayer = false ): a2dCommand( true, Id )
    { 
        m_value = set; 
        m_setStyleOfLayer = setStyleOfLayer;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetLayer( m_value, m_setStyleOfLayer );
    }

    bool Do(void) 
    { 
        wxUint16 val = GetCanvasCmp()->GetLayer(); 
        GetCanvasCmp()->SetLayer( m_value, m_setStyleOfLayer ); m_value = val;
        return true;       
    }
    bool Undo(void) 
    { 
        return Do();
    }
    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

    wxUint16 m_value;
    bool m_setStyleOfLayer;
};

//! set layer
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetTarget: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetTarget)

public:
    static const a2dCommandId Id;

    a2dCommand_SetTarget( wxUint16 set = 0 ): a2dCommand( true, Id )
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetTarget( m_value );
    }

    bool Do(void) 
    { 
        wxUint16 val = GetCanvasCmp()->GetTarget(); 
        GetCanvasCmp()->SetTarget( m_value ); m_value = val; 
        return true;
    }
    bool Undo(void) 
    { 
        return Do();
    }
    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

    wxUint16 m_value;
};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetDrawWireFrame: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetDrawWireFrame)
public:
    static const a2dCommandId Id;

    a2dCommand_SetDrawWireFrame( wxUint16 set = 0 ): a2dCommand( true, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetDrawWireFrame( m_value );
    }

protected:

    bool Do(void) 
    {   
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        wxUint16 val = drawer->GetDocumentDrawStyle(); 
        if ( !val )
            val = RenderLAYERED | RenderWIREFRAME_SELECT;       
        drawer->SetDocumentDrawStyle( m_value );
        m_value = val; 

        drawer->Update();

        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

protected:

    wxUint16 m_value;
};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_DrawGridLines: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_DrawGridLines)
public:
    static const a2dCommandId Id;

    a2dCommand_DrawGridLines( bool set = true ): a2dCommand( true, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_DrawGridLines( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        bool val = drawer->GetGridLines(); 
        drawer->SetGridLines( m_value );
        m_value = val; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_DrawGridAtFront: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_DrawGridAtFront)
public:
    static const a2dCommandId Id;

    a2dCommand_DrawGridAtFront( bool set = true ): a2dCommand( true, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_DrawGridAtFront( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        bool val = drawer->GetGridAtFront(); 
        drawer->SetGridAtFront( m_value );
        m_value = val; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_DrawGrid: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_DrawGrid)

public:
    static const a2dCommandId Id;

    a2dCommand_DrawGrid( bool set = true ): a2dCommand( true, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_DrawGrid( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        bool val = drawer->GetGrid(); 
        drawer->SetGrid( m_value );
        m_value = val; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set features
/*!
    The a2dRestrictionEngine taken from a2dCanvasGlobals->GetRestrictionEngine(),
    its snapping features will be set.
    All views share same snapping features.

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetSnapFeatures: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetSnapFeatures)
public:
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.snapTo = a2dRestrictionEngine::snapToNone;
        }

        A2D_ARGUMENT_SETTER( wxUint32, snapTo )

        struct argValue
        {
            wxUint32 snapTo;
        } argValue;

        struct argSet
        {
            bool snapTo;
        } argSet;
    };

    a2dCommand_SetSnapFeatures( wxUint32 snapTo ): a2dCommand( true, Id ) 
    { 
        m_args.snapTo( snapTo ); 
    }

    a2dCommand_SetSnapFeatures( const Args& args = Args() ): a2dCommand( false, Id )
    {
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetSnapFeatures( m_args );
    }

    Args m_args;

protected:

    bool Do(void) 
    {   
        wxUint32 oldSnapToFeatures = a2dCanvasGlobals->GetRestrictionEngine()->GetSnapToFeatures();
        a2dCanvasGlobals->GetRestrictionEngine()->SetSnapToFeatures( m_args.argValue.snapTo );
        m_args.snapTo( oldSnapToFeatures ); 
        return true;
    }
    bool Undo(void) 
    { 
        return Do();
    }
};

//! set one snapping feature
/*!
    The a2dRestrictionEngine taken from a2dCanvasGlobals->GetRestrictionEngine(),
    one of its snapping features will be set.
    All views share same snapping features.

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetSnapFeature: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetSnapFeature)
public:
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.snapTo = a2dRestrictionEngine::snapToNone;
            argSet.value = true;
        }

        A2D_ARGUMENT_SETTER( a2dRestrictionEngine::a2dSnapToWhat, snapTo )
        A2D_ARGUMENT_SETTER( bool, value )

        struct argValue
        {
            a2dRestrictionEngine::a2dSnapToWhat snapTo;
            bool value;
        } argValue;

        struct argSet
        {
            bool snapTo;
            bool value;
        } argSet;
    };

    a2dCommand_SetSnapFeature( a2dRestrictionEngine::a2dSnapToWhat snapTo, bool val = true ): a2dCommand( true, Id ) 
    { 
        m_args.snapTo( snapTo ); 
        m_args.value( val ); 
    }

    a2dCommand_SetSnapFeature( const Args& args = Args() ): a2dCommand( false, Id )
    {
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetSnapFeature( m_args );
    }

    Args m_args;

protected:

    bool Do(void) 
    {   
        bool oldSnapToFeature = a2dCanvasGlobals->GetRestrictionEngine()->GetSnapToFeature( m_args.argValue.snapTo );
        a2dCanvasGlobals->GetRestrictionEngine()->SetSnapToFeature( m_args.argValue.snapTo, m_args.argValue.value );
        m_args.argValue.value = oldSnapToFeature; 
        return true;
    }
    bool Undo(void) 
    { 
        return Do();
    }
};

//! set snapping for tools on or off.
/*!
    The a2dRestrictionEngine taken from a2dCanvasGlobals->GetRestrictionEngine(),
    will be set from a2dToolContr, making it possible to have snapping per view.

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetSnap: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetSnap)
public:
    static const a2dCommandId Id;

    a2dCommand_SetSnap( bool set = true ): a2dCommand( true, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetSnap( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( drawer && drawer->GetCanvasToolContr() )
        {
            bool val = drawer->GetCanvasToolContr()->GetSnap(); 
            drawer->GetCanvasToolContr()->SetSnap( m_value );
            m_value = val; 
        }
        return true;
    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }
};

//! set font
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetFont: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetFont)

public:
    static const a2dCommandId Id;

    a2dCommand_SetFont( const wxString& fontString  ): a2dCommand( true, Id ) 
    { 
        a2dFontInfo fontinfo;
        fontinfo.ParseString( fontString );
        a2dFont font = a2dFont::CreateFont( fontinfo );

        m_font = font; 
    }
    a2dCommand_SetFont( a2dFontInfo fontinfo ): a2dCommand( true, Id ) 
    { 
        a2dFont font = a2dFont::CreateFont( fontinfo );

        m_font = font; 
    }
    a2dCommand_SetFont(  const a2dFont& font = *a2dNullFONT ): a2dCommand( true, Id ) 
    { 
        m_font = font; 
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetFont( m_font );
    }
    a2dFont m_font;

protected:

    bool Do(void) 
    {   
        a2dFont val = GetCanvasCmp()->GetFont(); 
        GetCanvasCmp()->SetFont( m_font );
        m_font = val; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }
};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetStroke: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetStroke)
public:
    static const a2dCommandId Id;

    a2dCommand_SetStroke( const a2dStroke& stroke = *a2dNullSTROKE ): a2dCommand( true, Id ) 
    { 
        m_value = stroke; 
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetStroke( m_value );
    }

    a2dStroke m_value;

protected:

    bool Do(void) 
    {   
        m_value = GetCanvasCmp()->GetStroke(); 

        a2dStroke val = GetCanvasCmp()->GetStroke(); 
        GetCanvasCmp()->SetStroke( m_value );
        m_value = val; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetFill: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetFill)
public:
    static const a2dCommandId Id;

    a2dCommand_SetFill( const a2dFill& fill = *a2dNullFILL ): a2dCommand( true, Id ) 
    { 
        m_value = fill; 
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetFill( m_value );
    }

    bool Do(void) 
    {   
        a2dFill val = GetCanvasCmp()->GetFill(); 
        GetCanvasCmp()->SetFill( m_value );
        m_value = val; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

protected:

    a2dFill m_value;
};

class A2DCANVASDLLEXP a2dCommand_SetStrokeColour: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetStrokeColour)
public:
    static const a2dCommandId Id;

    a2dCommand_SetStrokeColour( const wxColour& colour = *wxBLACK ): a2dCommand( true, Id ) 
    { 
        m_value = colour;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetStrokeColour( m_value );
    }

    wxColour m_value;

protected:

    bool Do(void) 
    {   
        a2dStroke stroke = GetCanvasCmp()->GetStroke(); 
        wxColour old = stroke.GetColour();
        stroke.SetColour( m_value );
        m_value = old; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }
};

class A2DCANVASDLLEXP a2dCommand_SetFillColour: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetFillColour)
public:
    static const a2dCommandId Id;

    a2dCommand_SetFillColour( const wxColour& colour = *wxBLACK ): a2dCommand( true, Id ) 
    { 
        m_value = colour;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetFillColour( m_value );
    }

    wxColour m_value;

protected:

    bool Do(void) 
    {   
        a2dFill fill = GetCanvasCmp()->GetFill(); 
        wxColour old = fill.GetColour();
        fill.SetColour( m_value );
        m_value = old; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set SetContourWidth
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetContourWidth: public a2dCommand
{
public:
    static const a2dCommandId Id;

    a2dCommand_SetContourWidth( double width ): a2dCommand( true, Id ) 
    { 
        m_value = width; 
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetContourWidth( m_value );
    }

    double m_value;

protected:

    bool Do(void) 
    {   
        double old = GetCanvasCmp()->GetContourWidth(); 
        GetCanvasCmp()->SetContourWidth( m_value );
        m_value = old; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set SetPathType
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetPathType: public a2dCommand
{
public:
    static const a2dCommandId Id;

    a2dCommand_SetPathType( a2dPATH_END_TYPE type ): a2dCommand( true, Id ) 
    { 
        m_pathtype = type; 
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetPathType( m_pathtype );
    }

    a2dPATH_END_TYPE m_pathtype;

protected:

    bool Do(void) 
    {   
        a2dPATH_END_TYPE pathtype = GetCanvasCmp()->GetPathType(); 
        GetCanvasCmp()->SetPathType( m_pathtype );
        m_pathtype = pathtype; 
        return true;

    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_Refresh: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_Refresh)
public:
    static const a2dCommandId Id;

    a2dCommand_Refresh(): a2dCommand( false, Id ) 
    {}

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_Refresh();
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;
        doc->GetRootObject()->Update( a2dCanvasObject::updatemask_force );
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        drawer->Update( a2dCANVIEW_UPDATE_OLDNEW | a2dCANVIEW_UPDATE_ALL );

        return true;

    }
    bool Undo(void) 
    { 
        return false;
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_GdsIoSaveTextAsPolygon: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_GdsIoSaveTextAsPolygon)
public:
    static const a2dCommandId Id;

    a2dCommand_GdsIoSaveTextAsPolygon( bool set = true ): a2dCommand( false, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_GdsIoSaveTextAsPolygon( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        const_forEachIn( a2dDocumentTemplateList, &GetCanvasCmp()->GetDocTemplates() )
        {
            a2dDocumentTemplateList::value_type temp = *iter;
            if (temp->IsVisible() && wxT("GDS-II") == temp->GetDescription() )
            {
    #if wxART2D_USE_GDSIO
                 wxStaticCast( temp->GetDocumentIOHandlerStrOut(), a2dIOHandlerGDSOut )->SetSaveTextAsVpath( m_value );
    #endif //wxART2D_USE_GDSIO
            }
        }
        return true; 
    }
    bool Undo(void) 
    { 
        return false;
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_KeyIoSaveTextAsPolygon: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_KeyIoSaveTextAsPolygon)
public:
    static const a2dCommandId Id;

    a2dCommand_KeyIoSaveTextAsPolygon( bool set = true ): a2dCommand( false, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_KeyIoSaveTextAsPolygon( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        const_forEachIn( a2dDocumentTemplateList, &GetCanvasCmp()->GetDocTemplates() )
        {
            a2dDocumentTemplateList::value_type temp = *iter;
            if (temp->IsVisible() && wxT("KEY") == temp->GetDescription() )
            {
    #if wxART2D_USE_KEYIO
                 wxStaticCast( temp->GetDocumentIOHandlerStrOut(), a2dIOHandlerKeyOut )->SetSaveTextAsVpath( m_value );
    #endif //wxART2D_USE_KEYIO
            }
        }
        return true; 
    }
    bool Undo(void) 
    { 
        return false;
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! Export view as image 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ViewAsImage: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ViewImage)
public:

    //! Export a document to a file
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.file = false;
            argSet.btype = false;
            argValue.btype = wxBITMAP_TYPE_PNG;
        }

        A2D_ARGUMENT_SETTER( wxFileName, file )
        A2D_ARGUMENT_SETTER( wxBitmapType, btype )

        struct argValue
        {
            wxFileName file;
            wxBitmapType btype;
        } argValue;

        struct argSet
        {
            bool file;
            bool btype;
        } argSet;
    };

    a2dCommand_ViewAsImage( const Args& args = Args() ): a2dCommand( false, Id )
    {
        m_args = args;
        if ( args.argSet.file )
             m_args.file( args.argValue.file );
        else
             throw a2dCommandException( _( "file argument must be set" ) );
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_ViewAsImage( m_args );
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

    Args m_args;

protected:

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        a2dPathList path;
        path.Add( wxT(".") );
        wxString foundfile = m_args.argValue.file.GetFullPath();
        if ( !path.ExpandPath( foundfile ) )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), m_args.argValue.file.GetFullPath().c_str(),foundfile.c_str() ); 
            return false;
        }
        if ( foundfile.IsEmpty() )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _("Filename %s not in %s"), foundfile.c_str(), path.GetAsString().c_str() ); 
            return false;
        }

        drawer->GetDrawer2D()->GetBuffer().SaveFile( foundfile, m_args.argValue.btype, (wxPalette*)NULL );

        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! Export view as ViewAsSvg 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ViewAsSvg: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ViewAsSvg)
public:

    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.file = false;
        }

        A2D_ARGUMENT_SETTER( wxFileName, file )

        struct argValue
        {
            wxFileName file;
        } argValue;

        struct argSet
        {
            bool file;
        } argSet;
    };

    a2dCommand_ViewAsSvg( const Args& args = Args() ): a2dCommand( false, Id )
    {
        m_args = args;

        if ( args.argSet.file )
             m_args.file( args.argValue.file );
        else
             throw a2dCommandException( _( "file argument must be set" ) );
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_ViewAsSvg( m_args );
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

    Args m_args;

private:

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        a2dPathList path;
        path.Add( wxT(".") );
        wxString foundfile = m_args.argValue.file.GetFullPath();
        if ( !path.ExpandPath( foundfile ) )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), m_args.argValue.file.GetFullPath().c_str(),foundfile.c_str() ); 
            return false;
        }
        if ( foundfile.IsEmpty() )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _("Filename %s not in %s"), foundfile.c_str(), path.GetAsString().c_str() ); 
            return false;
        }

        doc->WriteSVG( drawer, foundfile, drawer->GetShowObject(), 10, 10, _T("cm") );

        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! create new group at x,y 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_NewGroup: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_NewGroup)
public:

    //! Print the current document or view
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.x = false;
            argSet.y = false;
            argSet.name = false; 
            argSet.layer = false; 
            argValue.x = 0;
            argValue.y = 0;
            argValue.layer = 0; 
        }

        A2D_ARGUMENT_SETTER( wxString, name )  
        A2D_ARGUMENT_SETTER( wxUint16, layer )            
        A2D_ARGUMENT_SETTER( double, x )            
        A2D_ARGUMENT_SETTER( double, y )  

        struct argValue
        {
            wxString name;
            wxUint16 layer;
            double x;
            double y;           
        } argValue;

        struct argSet
        {
            bool name;
            bool layer;
            bool x;
            bool y;
        } argSet;
    };

    a2dCommand_NewGroup( const Args& args = Args() ): a2dCommand( false, Id )
    {       
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_NewGroup( m_args );
    }

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    Args m_args;

private:

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
        if ( !doc )
            return false;

        a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
        if ( !drawer )
            return false;

        a2dCanvasObject* group = new a2dCanvasObject();
        group->CreateChildObjectList();

        wxString groupname = m_args.argValue.name;
        if ( groupname.IsEmpty() )
        {
            wxTextEntryDialog getname( NULL, wxT("Give group name:"), wxT("Group name"));
            if ( wxID_OK == getname.ShowModal() )
                groupname = getname.GetValue(); 
            else
                groupname = wxT("Not Specified"); 
        }

        group->SetName( groupname );
        group->SetLayer( m_args.argValue.layer );
        group->CreateChildObjectList();
        group->SetIgnoreLayer( true );
        a2dCanvasObjectReference* groupref = new a2dCanvasObjectReference( m_args.argValue.x, m_args.argValue.y, group );
        drawer->GetShowObject()->Prepend( groupref );

        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! create new group at x,y 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_NewPin: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_NewPin)
public:

    //! Print the current document or view
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.x = false;
            argSet.y = false;
            argSet.name = false; 
            argValue.x = 0;
            argValue.y = 0;
        }

        A2D_ARGUMENT_SETTER( wxString, name )  
        A2D_ARGUMENT_SETTER( double, x )            
        A2D_ARGUMENT_SETTER( double, y )  

        struct argValue
        {
            wxString name;
            double x;
            double y;           
        } argValue;

        struct argSet
        {
            bool name;
            bool x;
            bool y;
        } argSet;
    };

    a2dCommand_NewPin( const Args& args = Args() ): a2dCommand( false, Id )
    {       
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_NewPin( m_args );
    }

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    Args m_args;

private:

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
        if ( !doc )
            return false;

        a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
        if ( !drawer )
            return false;

        if ( !m_args.argSet.name )
            m_args.argValue.name = wxGetTextFromUser(_("give name of new pin:"));
        long ang = wxGetNumberFromUser(_("Give pin angle:"), _("angle:"), _("pin angle"),0,-360,360);

        a2dPin* pin = new a2dPin(drawer->GetShowObject(), m_args.argValue.name, a2dPinClass::Standard, m_args.argValue.x, m_args.argValue.y, ang );
        drawer->GetShowObject()->Prepend( pin );
        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetShowObject: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetShowObject)

public:

    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.canvasobject = false;
            argSet.index = false;
            argSet.selected = false;
            argSet.name = false;
            argValue.canvasobject = NULL;
            argValue.index = 0;
            argValue.selected = false;
        }

        A2D_ARGUMENT_SETTER( a2dCanvasObjectPtr, canvasobject )
        A2D_ARGUMENT_SETTER( wxInt32, index )
        A2D_ARGUMENT_SETTER( wxString, name )
        A2D_ARGUMENT_SETTER( bool, selected )

        struct argValue
        {
            a2dCanvasObjectPtr canvasobject;
            wxInt32 index;
            wxString name;
            bool selected;
        } argValue;

        struct argSet
        {
            bool canvasobject;
            bool name;
            bool index;
            bool selected;
        } argSet;
    };

    a2dCommand_SetShowObject( const Args& args = Args() ): a2dCommand( false, Id )
    {
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetShowObject( m_args );
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

    Args m_args;

protected:

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        a2dCanvasObject* g = NULL;
        if ( m_args.argSet.index )
        {
            g = drawer->GetCanvasDocument()->Find( _T(""), _T(""), m_args.argValue.index );
            if ( !g )
            {
                a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _T("No Object with id %d in a2dCentralCanvasCommandProcessor::SetShowObject()"), m_args.argValue.index );
                return false;
            }
        }
        else if ( m_args.argSet.name )
        {
            g = drawer->GetCanvasDocument()->Find( m_args.argValue.name, _T(""), -1 );
            if ( !g )
            {
                a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _T("No Object with id %d in a2dCentralCanvasCommandProcessor::SetShowObject()"), m_args.argValue.index );
                return false;
            }
        }
        else if ( m_args.argSet.selected )
            g = drawer->GetShowObject()->Find( wxT(""),  wxT(""), a2dCanvasOFlags::SELECTED );
        else if ( m_args.argSet.canvasobject )
            g = m_args.argValue.canvasobject;

        if ( g )
        {
            g->SetSelected( false );
            g->GetChildObjectList()->SetSpecificFlags( false, a2dCanvasOFlags::SELECTED );
            drawer->SetShowObject( g );
        }
        GetCanvasCmp()->SetLastXyEntry( 0, 0 ); 
        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! Save layer settings to a CVG file 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SaveLayers: public a2dCommand
{
public:

    //! Export a document to a file
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_SaveLayers( const wxFileName& file ): a2dCommand( false, Id )
    {
        m_fileName = file;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SaveLayers( m_fileName );
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

protected:
    
    wxFileName m_fileName;

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;

        a2dPathList path;
        path.Add( wxT(".") );
        wxString foundfile = m_fileName.GetFullPath();
        if ( !path.ExpandPath( foundfile ) )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), m_fileName.GetFullPath().c_str(),foundfile.c_str() ); 
            return false;
        }
        if ( foundfile.IsEmpty() )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _("Filename %s not in %s"), foundfile.c_str(), path.GetAsString().c_str() ); 
            return false;
        }

        if ( doc->GetLayerSetup() ) 
            doc->GetLayerSetup()->SaveLayers( foundfile );
        else
            a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _("Document does not have layer setup") ); 

        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! Load layer settings from a CVG file 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_LoadLayers: public a2dCommand
{
public:

    //! Export a document to a file
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_LoadLayers( const wxFileName& file ): a2dCommand( false, Id )
    {
        m_fileName = file;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_LoadLayers( m_fileName );
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

protected:
    
    wxFileName m_fileName;

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;

        a2dPathList path;
        path.Add( wxT(".") );
        wxString foundfile = m_fileName.GetFullPath();
        if ( !path.ExpandPath( foundfile ) )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_CouldNotEvaluatePath, _("Could not expand %s resulted in %s"), m_fileName.GetFullPath().c_str(),foundfile.c_str() ); 
            return false;
        }
        if ( foundfile.IsEmpty() )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_NotSpecified, _("Filename %s not in %s"), foundfile.c_str(), path.GetAsString().c_str() ); 
            return false;
        }

#if wxUSE_STD_IOSTREAM
        a2dDocumentFileInputStream store( foundfile.mb_str() );
        if (store.fail() || store.bad())
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_FileCouldNotOpen, _("Sorry, could not open file %s for import"), foundfile.c_str() ); 
            return false;
        }
#else
        wxFileInputStream storeUnbuf( foundfile );
        if ( !storeUnbuf.Ok() )
        {
            a2dDocviewGlobals->ReportErrorF( a2dError_FileCouldNotOpen, _("Sorry, could not open file %s for import"), foundfile.c_str() ); 
            return false;
        }
        wxBufferedInputStream store( storeUnbuf );
#endif

#if wxART2D_USE_CVGIO
        //assume it is the default CVG format.
        a2dIOHandlerCVGIn* handler = new a2dIOHandlerCVGIn();
        a2dLayers* layersetup = new a2dLayers();
        handler->LoadLayers( store, layersetup );

        delete handler;
#else
        wxFAIL_MSG( wxT("wxART2D_USE_CVGIO is needed to load object from a file CVG file") );
#endif //wxART2D_USE_CVGIO
    
        doc->SetLayerSetup( layersetup );
        return true;
    }

    virtual bool Undo()
    {
        return false;
    }
};

//! set cursor
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetCursor: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetCursor)

public:
    static const a2dCommandId Id;


    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argValue.x = 0;
            argValue.y = 0;
            argValue.polar = false;
            argValue.relative = false;
            argValue.snapped = false;

            argSet.x = false;
            argSet.y = false;
            argSet.polar = false;
            argSet.relative = false;
            argSet.snapped = false;
        }

        A2D_ARGUMENT_SETTER( double, x )
        A2D_ARGUMENT_SETTER( double, y )
        A2D_ARGUMENT_SETTER( bool, polar )
        A2D_ARGUMENT_SETTER( bool, relative )
        A2D_ARGUMENT_SETTER( bool, snapped )

        struct argValue
        {
            double x;
            double y;
            bool polar;
            bool relative;
            bool snapped;
        } argValue;

        struct argSet
        {
            bool x;
            bool y;
            bool polar;
            bool relative;
            bool snapped;
        } argSet;
    };

    a2dCommand_SetCursor( const Args& args = Args() ): a2dCommand( false, Id )
    {
        m_args = args;
    }

    a2dCommand_SetCursor( double x, double y ): a2dCommand( true, Id )
    { 
        m_args.x( x );
        m_args.y( y );
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetCursor( m_args );
    }

    bool Do(void) 
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        double x = m_args.argValue.x;
        double y = m_args.argValue.y;

        //get current position
        m_xold = GetCanvasCmp()->GetLastXEntry(); 
        m_yold = GetCanvasCmp()->GetLastYEntry(); 

        //get current position
        if ( m_args.argValue.relative )
        {
            if ( m_args.argValue.polar )
            {
                double radius = y;
                double ang = x;

                x = m_xold + radius * cos( wxDegToRad(ang) );
                y = m_yold + radius * sin( wxDegToRad(ang) );
            }
            else
            {
                x += m_xold;
                y += m_yold;
            }
        }
        else
        {
            if ( m_args.argValue.polar )
            {
                double radius = y;
                double ang = x;

                x = radius * cos( wxDegToRad(ang) );
                y = radius * sin( wxDegToRad(ang) );
            }
        }


        int dx = drawer->GetDrawer2D()->WorldToDeviceX(x);
        int dy = drawer->GetDrawer2D()->WorldToDeviceY(y);
        drawer->GetDisplayWindow()->WarpPointer( dx, dy );
        GetCanvasCmp()->SetLastXyEntry( x, y ); 

        return true;
    }
    bool Undo(void) 
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->CheckCanvasDocument();
        if ( !doc )
            return false;
        a2dCanvasView* drawer = GetCanvasCmp()->CheckDrawer();
        if ( !drawer )
            return false;

        int dx = drawer->GetDrawer2D()->WorldToDeviceX( m_xold );
        int dy = drawer->GetDrawer2D()->WorldToDeviceY( m_yold );
        drawer->GetDisplayWindow()->WarpPointer( dx, dy );
        return true;
    }
    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

    Args m_args;
    double m_xold,m_yold;
};

//! set releative measurement start
/*!
    Sets the start from where measurements wuill be done.

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetRelativeStart: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetRelativeStart)
public:
    static const a2dCommandId Id;

    a2dCommand_SetRelativeStart( double x = 0, double y = 0 ): a2dCommand( true, Id ) 
    { m_x = x; m_y = y; }

    double m_x;
    double m_y;

protected:

    bool Do(void) 
    {   
        double x = GetCanvasCmp()->GetRelativeStartX();
        double y = GetCanvasCmp()->GetRelativeStartY();

        GetCanvasCmp()->SetRelativeStart( m_x, m_y );
        m_x = x;
        m_y = y;
        return true;
    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }
};

//! add measurement
/*!
    adds another measurement relative to the start point.

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_AddMeasurement: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_AddMeasurement)
public:
    static const a2dCommandId Id;

    a2dCommand_AddMeasurement( double x = 0, double y = 0 ): a2dCommand( true, Id ) 
    { m_x = x; m_y = y; }

    double m_x;
    double m_y;

protected:

    bool Do(void) 
    {   
        // dialog uses commandId to detect this action
        return true;
    }
    bool Undo(void) 
    { 
        return Do();
    }
};

//! clear all measurements
/*!
    clear all measurements made sofar

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ClearMeasurements: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ClearMeasurements)
public:
    static const a2dCommandId Id;

    a2dCommand_ClearMeasurements(): a2dCommand( true, Id ) 
    {}

protected:

    bool Do(void) 
    {   
        // dialog uses commandId to detect this action
        return true;
    }
    bool Undo(void) 
    { 
        return Do();
    }
};

//! 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_PushInto: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_PushInto)
public:

    //! 
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.canvasobject = false;
            argSet.name = false;
            argSet.selected = false;
            argValue.selected = false;
            argValue.canvasobject = NULL;
        }

        A2D_ARGUMENT_SETTER( a2dCanvasObjectPtr, canvasobject )
        A2D_ARGUMENT_SETTER( wxString, name )
        A2D_ARGUMENT_SETTER( bool, selected )

        struct argValue
        {
            a2dCanvasObjectPtr canvasobject;
            wxString name;
            bool selected;
        } argValue;

        struct argSet
        {
            bool canvasobject;
            bool name;
            bool selected;
        } argSet;
    };

    a2dCommand_PushInto( const Args& args = Args() ): a2dCommand( true, Id )
    {
        m_args = args;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_PushInto( m_args );
    }

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    Args m_args;

private:

    virtual bool Do()
    { 
        a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
        if ( !doc )
            return false;
        a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
        if ( !drawer )
            return false;

        if ( m_args.argSet.name )
            m_pushIn = drawer->GetShowObject()->Find( m_args.argValue.name );
        else if ( m_args.argSet.selected )
            m_pushIn = drawer->GetShowObject()->Find( wxT(""),  wxT(""), a2dCanvasOFlags::SELECTED );
        else if ( m_args.argSet.canvasobject )
            m_pushIn = m_args.argValue.canvasobject;

        a2dCanvasObjectReference* obj = wxDynamicCast( m_pushIn.Get(), a2dCanvasObjectReference );
        if ( obj )
            m_pushIn = obj->GetCanvasObject();

        if (m_pushIn)
        {
            m_previous = drawer->GetShowObject();
            //let drawer follow document if needed.
            if ( doc->GetRootObject() != m_pushIn->GetCanvasDocument()->GetRootObject() )
                drawer->SetDocument(m_pushIn->GetCanvasDocument());
            m_pushIn->SetSelected( false );
            m_pushIn->GetChildObjectList()->SetSpecificFlags( false, a2dCanvasOFlags::SELECTED );
            drawer->SetShowObject( m_pushIn );
        }
        else
           (void)wxMessageBox( _("Does not contain a group, unable to push into"), _("push into"), wxICON_INFORMATION | wxOK );

        return true;
    }

    virtual bool Undo()
    {
        a2dCanvasDocument* doc = GetCanvasCmp()->GetCanvasDocument();
        if ( !doc )
            return false;
        a2dCanvasView* drawer = a2dGetCmdh()->CheckDrawer();
        if ( !drawer )
            return false;

        if (m_pushIn)
        {
            //let drawer follow document if needed.
            if ( doc->GetRootObject() != m_previous->GetCanvasDocument()->GetRootObject() )
                drawer->SetDocument( m_previous->GetCanvasDocument() );
            m_previous->SetSelected( false );
            m_previous->GetChildObjectList()->SetSpecificFlags( false, a2dCanvasOFlags::SELECTED );
            drawer->SetShowObject( m_previous );
            m_pushIn = m_previous;
            m_previous = 0;
            return true;
        }
        return false;
    }

    a2dCanvasObjectPtr m_previous;
    a2dCanvasObjectPtr m_pushIn;
};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_KeyIoSaveFromView: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_KeyIoSaveTextAsPolygon)
public:
    static const a2dCommandId Id;

    a2dCommand_KeyIoSaveFromView( bool set = true ): a2dCommand( false, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_KeyIoSaveFromView( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        const_forEachIn( a2dDocumentTemplateList, &GetCanvasCmp()->GetDocTemplates() )
        {
            a2dDocumentTemplateList::value_type temp = *iter;
            if (temp->IsVisible() && wxT("KEY") == temp->GetDescription() )
            {
    #if wxART2D_USE_KEYIO
                 a2dIOHandlerKeyOut* handler = wxStaticCast( temp->GetDocumentIOHandlerStrOut(), a2dIOHandlerKeyOut );
                 bool currentSetting = handler->GetFromViewAsTop();
                 handler->SetFromViewAsTop( m_value );
                 m_value = currentSetting;
    #endif //wxART2D_USE_KEYIO
            }
        }
        return true; 
    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_GdsIoSaveFromView: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_GdsIoSaveFromView)
public:
    static const a2dCommandId Id;

    a2dCommand_GdsIoSaveFromView( bool set = true ): a2dCommand( false, Id ) 
    { m_value = set; }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_GdsIoSaveFromView( m_value );
    }

    bool m_value;

protected:

    bool Do(void) 
    {   
        const_forEachIn( a2dDocumentTemplateList, &GetCanvasCmp()->GetDocTemplates() )
        {
            a2dDocumentTemplateList::value_type temp = *iter;
            if (temp->IsVisible() && wxT("GDS-II") == temp->GetDescription() )
            {
    #if wxART2D_USE_GDSIO
                 a2dIOHandlerGDSOut* handler = wxStaticCast( temp->GetDocumentIOHandlerStrOut(), a2dIOHandlerGDSOut );
                 bool currentSetting = handler->GetFromViewAsTop();
                 handler->SetFromViewAsTop( m_value );
                 m_value = currentSetting;
    #endif //wxART2D_USE_GDSIO
            }
        }
        return true; 
    }
    bool Undo(void) 
    { 
        return Do();
    }

    inline a2dCentralCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCentralCanvasCommandProcessor); }

};

//! set layer of objects which fit the mask
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetLayerMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetLayerMask)
public:
    static const a2dCommandId Id;

    a2dCommand_SetLayerMask( long set = -1, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_layer = set; 
        m_mask = mask;          
        m_objects = wxNullCanvasObjectList;
    }

    ~a2dCommand_SetLayerMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetLayerMask( m_layer, m_mask, m_parent );
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    long m_layer;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dLayerGroup m_objectOldLayers;

};

//! delete objects which fit the mask 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_DeleteMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_DeleteMask)
public:
    static const a2dCommandId Id;

    a2dCommand_DeleteMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_objects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_DeleteMask( m_mask, m_parent );
    }

    ~a2dCommand_DeleteMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask to top in parent (rendered last)
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ToTopMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ToTopMask)
public:
    static const a2dCommandId Id;

    a2dCommand_ToTopMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_objects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_ToTopMask( m_mask, m_parent );
    }

    ~a2dCommand_ToTopMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask to bottom in parent (rendered first)
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ToBackMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ToBackMask)
public:
    static const a2dCommandId Id;

    a2dCommand_ToBackMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_objects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_ToBackMask( m_mask, m_parent );
    }

    ~a2dCommand_ToBackMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are copied to target and translated 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_CopyMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_CopyMask)
public:
    static const a2dCommandId Id;

    a2dCommand_CopyMask( double x = 0, double y = 0, long target = -1, bool toTarget = false, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;   
        m_x = x;
        m_y = y;
        m_target = target; 
        m_toTarget = toTarget;
        m_objects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_CopyMask( m_x, m_y, m_target, m_toTarget, m_mask, m_parent );
    }

    ~a2dCommand_CopyMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    double m_x, m_y;
    long m_target;
    bool m_toTarget;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
};

//! objects which fit the mask are moved to target and translated 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_MoveMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_MoveMask)
public:
    static const a2dCommandId Id;

    a2dCommand_MoveMask( double x = 0, double y = 0, long target = -1, bool toTarget = false, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;   
        m_x = x;
        m_y = y;
        m_target = target; 
        m_toTarget = toTarget;
        m_objects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_MoveMask( m_x, m_y, m_target, m_toTarget, m_mask, m_parent );
    }

    ~a2dCommand_MoveMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    double m_x, m_y;
    long m_target;
    bool m_toTarget;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dLayerGroup m_objectOldLayers;
};

//! objects which fit the mask are grouped into a new object
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_GroupMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_GroupMask)
public:
    static const a2dCommandId Id;

    a2dCommand_GroupMask( const wxString& name = wxEmptyString, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_name = name;
        m_parent = parent;
        m_mask = mask;          
        m_objects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_GroupMask( m_name, m_mask, m_parent );
    }

    ~a2dCommand_GroupMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    wxString m_name;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dCanvasObjectPtr m_groupobject;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are grouped into a new object
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_UnGroupMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_UnGroupMask)
public:
    static const a2dCommandId Id;

    a2dCommand_UnGroupMask( bool deep = false, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;    
        m_deep = deep;
        m_objects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_UnGroupMask( m_deep, m_mask, m_parent );
    }

    ~a2dCommand_UnGroupMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectFlagsMask m_mask;
    bool m_deep;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are merge into one new object
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_MergeMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_MergeMask)
public:
    static const a2dCommandId Id;

    a2dCommand_MergeMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED,
        long target = -1, bool layerFirstObject = false, bool clearorg = true, 
        int depth = 20, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_takeLayerFirstObject = layerFirstObject;
        m_target = target;
        m_clearorg = clearorg;
        m_depth = depth;
        m_objects = wxNullCanvasObjectList;
        m_mergedObjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_MergeMask( m_mask, m_target, m_takeLayerFirstObject, m_clearorg, m_depth, m_parent );
    }

    ~a2dCommand_MergeMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
        if ( m_mergedObjects != wxNullCanvasObjectList )
            delete m_mergedObjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    long m_target;
    bool m_takeLayerFirstObject;
    bool m_clearorg;
    int m_depth;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dCanvasObjectList* m_mergedObjects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are offset corrected 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_OffsetMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_OffsetMask)
public:
    static const a2dCommandId Id;

    a2dCommand_OffsetMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED,
        long target = -1, bool layerFirstObject = false, bool clearorg = true, 
        int depth = 20, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_takeLayerFirstObject = layerFirstObject;
        m_target = target;
        m_clearorg = clearorg;
        m_depth = depth;
        m_objects = wxNullCanvasObjectList;
        m_offsetObjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_OffsetMask( m_mask, m_target, m_takeLayerFirstObject, m_clearorg, m_depth, m_parent );
    }

    ~a2dCommand_OffsetMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
        if ( m_offsetObjects != wxNullCanvasObjectList )
            delete m_offsetObjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    long m_target;
    bool m_takeLayerFirstObject;
    bool m_clearorg;
    int m_depth;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dCanvasObjectList* m_offsetObjects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are offset corrected 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_PolygonToSurfaceMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_PolygonToSurfaceMask)
public:
    static const a2dCommandId Id;

    a2dCommand_PolygonToSurfaceMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED,
        long target = -1, bool layerFirstObject = false, bool clearorg = true, 
        int depth = 20, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_takeLayerFirstObject = layerFirstObject;
        m_target = target;
        m_clearorg = clearorg;
        m_depth = depth;
        m_objects = wxNullCanvasObjectList;
        m_offsetObjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_PolygonToSurfaceMask( m_mask, m_target, m_takeLayerFirstObject, m_clearorg, m_depth, m_parent );
    }

    ~a2dCommand_PolygonToSurfaceMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
        if ( m_offsetObjects != wxNullCanvasObjectList )
            delete m_offsetObjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    long m_target;
    bool m_takeLayerFirstObject;
    bool m_clearorg;
    int m_depth;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dCanvasObjectList* m_offsetObjects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are offset corrected 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SurfaceToPolygonMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SurfaceToPolygonMask)
public:
    static const a2dCommandId Id;

    a2dCommand_SurfaceToPolygonMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED,
        long target = -1, bool layerFirstObject = false, bool clearorg = true, 
        int depth = 20, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_takeLayerFirstObject = layerFirstObject;
        m_target = target;
        m_clearorg = clearorg;
        m_depth = depth;
        m_objects = wxNullCanvasObjectList;
        m_offsetObjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SurfaceToPolygonMask( m_mask, m_target, m_takeLayerFirstObject, m_clearorg, m_depth, m_parent );
    }

    ~a2dCommand_SurfaceToPolygonMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
        if ( m_offsetObjects != wxNullCanvasObjectList )
            delete m_offsetObjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    long m_target;
    bool m_takeLayerFirstObject;
    bool m_clearorg;
    int m_depth;
    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_objects;
    a2dCanvasObjectList* m_offsetObjects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are given an Url property
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_UrlOnMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_UrlOnMask)
public:
    static const a2dCommandId Id;

    a2dCommand_UrlOnMask( wxURI uri = wxURI(), a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_uri = uri;
        m_objects = wxNullCanvasObjectList;
        m_oldobjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_UrlOnMask( m_uri, m_mask, m_parent );
    }

    ~a2dCommand_UrlOnMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
        if ( m_oldobjects != wxNullCanvasObjectList )
            delete m_oldobjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_oldobjects;
    a2dCanvasObjectList* m_objects;
    a2dlist< long > m_objectsIndex;
    wxURI m_uri;
};

//! objects which fit the mask are given a new fill and stroke style
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetFillStrokeMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetFillStrokeMask)
public:
    static const a2dCommandId Id;

    a2dCommand_SetFillStrokeMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_objects = wxNullCanvasObjectList;
        m_oldobjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetFillStrokeMask( m_mask, m_parent );
    }

    ~a2dCommand_SetFillStrokeMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
        if ( m_oldobjects != wxNullCanvasObjectList )
            delete m_oldobjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_oldobjects;
    a2dCanvasObjectList* m_objects;
    a2dlist< long > m_objectsIndex;
};

//! objects which fit the mask are converted to rectangles
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ImagesToRectMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ImagesToRectMask)
public:
    static const a2dCommandId Id;

    a2dCommand_ImagesToRectMask( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, a2dCanvasObject* parent = NULL ): a2dCommand( true, Id )
    { 
        m_parent = parent;
        m_mask = mask;          
        m_objects = wxNullCanvasObjectList;
        m_oldobjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_ImagesToRectMask( m_mask, m_parent );
    }

    ~a2dCommand_ImagesToRectMask()
    { 
        if ( m_objects != wxNullCanvasObjectList )
            delete m_objects;
        if ( m_oldobjects != wxNullCanvasObjectList )
            delete m_oldobjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    a2dCanvasObjectFlagsMask m_mask;
    a2dCanvasObjectPtr m_parent;
    a2dCanvasObjectList* m_oldobjects;
    a2dCanvasObjectList* m_objects;
    a2dlist< long > m_objectsIndex;
};

//! set all layers visible or not
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_SetLayersProperty: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_SetLayerMask)
public:
    static const a2dCommandId  Id;

    enum SetWhat{ visible, selectable, readable, filling };

    void DistributeEvent( wxEventType eventType );

    a2dCommand_SetLayersProperty( bool value = true, SetWhat what = visible ): a2dCommand( true, Id )
    { 
        m_value = value;
        m_setWhat = what;
    }

    ~a2dCommand_SetLayersProperty()
    { 
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_SetLayersProperty( m_value );
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    bool m_value;
    a2dlist< bool > m_oldLayersVisible;

    SetWhat m_setWhat;

};

//! objects which fit the mask are converted to polygons or vector paths 
/*!
    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ConvertMask: public a2dCommand
{
    DECLARE_DYNAMIC_CLASS(a2dCommand_ConvertMask)
public:
    static const a2dCommandId Id;

    //! defines what to do
    /*! 
    */
    enum a2dDoWhat
    {
        ConvertToPolygonPolylinesWithArcs, //!<  convert to simple polygons and polylines
        ConvertToPolygonPolylinesWithoutArcs, //!<  convert to simple polygons and polylines
        ConvertPolygonToArcs,   //!<  convert segments in polygon/polyline with width objects in group A to Arcs where possible
        ConvertPolylineToArcs,   //!<  convert segments in polyline objects in group A to Arcs where possible
        ConvertToVPaths, //!<  convert shapes to vector paths
        ConvertLinesArcs, //!< convert shapes to seperate lines and arcs
        ConvertToPolylines, //!< convert shapes to polylines even if polygons
    };

    class A2DCANVASDLLEXP Args 
    {
    public:
        Args()
        {
            argSet.what = false;
            argSet.target = false;
            argSet.clearTarget = false;
            argSet.mask = false;
            argSet.deleteOriginal = false;
            argSet.keepLayer = false;
            argSet.clearTarget = false;
            argSet.detectCircle = false;
            argSet.detectCircle = false;
            argSet.parent = false;
            argValue.what = ConvertToVPaths;
            argValue.target = -1;
            argValue.clearTarget = false;
            argValue.mask = a2dCanvasOFlags::SELECTED;
            argValue.deleteOriginal = true;
            argValue.keepLayer = true;
            argValue.clearTarget = false;
            argValue.detectCircle = false;
            argValue.parent = NULL;
        }

        A2D_ARGUMENT_SETTER( a2dDoWhat, what )            
        A2D_ARGUMENT_SETTER( long, target )            
        A2D_ARGUMENT_SETTER( a2dCanvasObjectFlagsMask, mask )  
        A2D_ARGUMENT_SETTER( bool, deleteOriginal )            
        A2D_ARGUMENT_SETTER( bool, keepLayer )            
        A2D_ARGUMENT_SETTER( bool, clearTarget )            
        A2D_ARGUMENT_SETTER( bool, detectCircle )
        A2D_ARGUMENT_SETTER( a2dCanvasObjectPtr, parent )
        
        struct argValue
        {
            a2dDoWhat what;
            long target;
            a2dCanvasObjectFlagsMask mask;
            bool deleteOriginal;
            bool keepLayer;
            bool clearTarget;            
            bool detectCircle;
            a2dCanvasObjectPtr parent;
        } argValue;

        struct argSet
        {
            bool what, target, mask, deleteOriginal, keepLayer, clearTarget, detectCircle, parent;
        } argSet;
    };

    a2dCommand_ConvertMask( const Args& args = Args() ): a2dCommand( true, Id )
    {       
        m_args = args;
        m_newobjects = wxNullCanvasObjectList;
        m_maskobjects = wxNullCanvasObjectList;
    }

    virtual a2dObject* Clone( CloneOptions options = clone_deep ) const
    {
        return new a2dCommand_ConvertMask( m_args );
    }

    a2dCommand_ConvertMask( a2dDoWhat what, 
                            long target = -1, a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::SELECTED, 
                            bool deleteOriginal = true, bool keepLayer = true )
                            : a2dCommand( true, Id )
    { 
        m_args.what( what ).target( target ).mask( mask ).deleteOriginal( deleteOriginal ).keepLayer( keepLayer);
        m_newobjects = wxNullCanvasObjectList;
        m_maskobjects = wxNullCanvasObjectList;
    }

    ~a2dCommand_ConvertMask()
    { 
        if ( m_newobjects != wxNullCanvasObjectList )
            delete m_newobjects;
        if ( m_maskobjects != wxNullCanvasObjectList )
            delete m_maskobjects;
    }

    bool Do(void); 

    bool Undo(void);
    
    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

    Args m_args;

    a2dCanvasObjectList* m_newobjects;
    a2dCanvasObjectList* m_maskobjects;
    a2dlist< long > m_objectsIndex;
};

// ----------------------------------------------------------------------------
// wxDoubleNumberEntryDialog
// ----------------------------------------------------------------------------

//! wxDoubleNumberEntryDialog: a dialog with spin control, [ok] and [cancel] buttons
class A2DCANVASDLLEXP wxDoubleNumberEntryDialog : public wxDialog
{
public:
    wxDoubleNumberEntryDialog(wxWindow *parent,
                        const wxString& message,
                        const wxString& prompt,
                        const wxString& caption,
                        double value, double min, double max,
                        const wxPoint& pos = wxDefaultPosition);

    //! get the double
    double GetValue() const { return m_value; }

    //! implementation only
    void OnOK(wxCommandEvent& event);
    //! implementation only
    void OnCancel(wxCommandEvent& event);

protected:

    //! the text control top get the double entry
    wxTextCtrl *m_textctrl;
    //! teh value of the double
    double m_value;
    //! min required
    double m_min;
    //! max required
    double m_max;

private:
    DECLARE_EVENT_TABLE()
    DECLARE_DYNAMIC_CLASS(wxDoubleNumberEntryDialog)
    DECLARE_NO_COPY_CLASS(wxDoubleNumberEntryDialog)
};

// ----------------------------------------------------------------------------
// function to get a number from user
// ----------------------------------------------------------------------------

//! get Double from user
double A2DCANVASDLLEXP
wxGetDoubleNumberFromUser(const wxString& message,
                    const wxString& prompt,
                    const wxString& caption,
                    double value = 0,
                    double min = 0,
                    double max = 100,
                    wxWindow *parent = (wxWindow *)NULL,
                    const wxPoint& pos = wxDefaultPosition);


#endif

cancom.h Source File -- Tue Aug 31 17:56:17 2010 -- 31 Aug 2010 -- 1.5.5 -- wxArt2D -- . -- Reference Documentation