canglob.h

Go to the documentation of this file.

/*! \file wx/canvas/canglob.h
    \brief general canvas module declarations and classes

    The event classes for an a2dCanvasObject are here.
    And a2dCanvasGlobal holds settings for the canvas module. 
    Storing layers settings as a template for layer settings of new documents is a 
    typical use of wxCanvasGlobals.

    a2dTimer, is a wxTimes special for a2dCanvasObject

    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    Classes, functions and enumration for use in all othere files, are located here.

    RCS-ID: $Id: canglob.h,v 1.58 2009/09/03 20:09:53 titato Exp $
*/

#ifndef __WXCANGLOB_H__
#define __WXCANGLOB_H__

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

#include <map>

using namespace std;

#include "wx/geometry.h"

#include <wx/module.h>

#include <wx/general/gen.h>
#include <wx/docview/doccom.h>
#include <wx/artbase/drawer2d.h>

#include "wx/canvas/candefs.h"

#include "wx/canvas/restrict.h"
#include "wx/canvas/canprim.h"
#include "wx/canvas/layerinf.h"
#include "wx/canvas/cantext.h"
#include "wx/canvas/objlist.h"

//! OR-ing a2dDocumentRenderStyle is allowed

inline a2dDocumentRenderStyle operator | ( a2dDocumentRenderStyle a, a2dDocumentRenderStyle b )
{
    return (a2dDocumentRenderStyle) ( (int) a | (int) b );
}

//--------------------------------------------------------------------
// a2dLayerGroup
//--------------------------------------------------------------------

//! holds a list of layers numbers
class a2dLayerGroup: public a2dlist< wxUint16 >
{
public:

    //! constructor
    a2dLayerGroup() {}

    //! return true if layer is part of the group
    //! if group eqauls wxLAYER_ALL it return true always
    bool InGroup( wxUint16 layer );
};

class A2DARTBASEDLLEXP a2dAffineMatrix;
class A2DCANVASDLLEXP a2dCentralCanvasCommandProcessor;

//--------------------------------------------------------------------
// a2dCanvasModule
//--------------------------------------------------------------------

//! initiation module for the wxArt2D library
/*!
    One instance of is used to initiate global settings.

    Like a2dCanvasGlobals and a2dCanvasInitializeStockObjects()

    \ingroup global 
*/
class A2DCANVASDLLEXP a2dCanvasModule : public wxModule
{
public:

    a2dCanvasModule();

    virtual bool OnInit();
    virtual void OnExit();

private:
    DECLARE_DYNAMIC_CLASS(a2dCanvasModule)

    a2dSmrtPtr<a2dDocumentCommandProcessor> m_prevCmdProc;
    a2dSmrtPtr<a2dCentralCanvasCommandProcessor> m_currentCmdProc;
};

class A2DCANVASDLLEXP a2dIterC;
class A2DCANVASDLLEXP a2dCanvasObject;
class A2DCANVASDLLEXP a2dCanvasObjectList;

class A2DARTBASEDLLEXP a2dAffineMatrix;
class A2DDOCVIEWDLLEXP a2dWalkerIOHandler;
class A2DCANVASDLLEXP a2dText;


BEGIN_DECLARE_EVENT_TYPES()
    //!see a2dCanvasObjectMouseEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DCANVASDLLEXP, wxEVT_CANVASOBJECT_MOUSE_EVENT, 1 )
    //!see a2dCanvasObjectEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DCANVASDLLEXP, wxEVT_CANVASOBJECT_ENTER_EVENT, 1 )
    //!see a2dCanvasObjectEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DCANVASDLLEXP, wxEVT_CANVASOBJECT_LEAVE_EVENT, 1 )
    //! see a2dHandleMouseEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DCANVASDLLEXP, wxEVT_CANVASHANDLE_MOUSE_EVENT, 1)
    //!see a2dCanvasObjectEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DCANVASDLLEXP, wxEVT_CANVASOBJECT_RESIZE_EVENT, 1 )
    //!see a2dCanvasObjectEvent \ingroup eventid
    DECLARE_EXPORTED_EVENT_TYPE( A2DCANVASDLLEXP, wxEVT_CANVASOBJECT_POPUPMENU_EVENT, 1 )    
END_DECLARE_EVENT_TYPES()

//! general event sent from a2dCanvasObject to itself
/*!
    It contains the accumulated matrix to reach the position etc. of the object.
    This is important for editing childobjects of a2dCanvasObject directly.

    Currently the following Id's:

*/
class A2DCANVASDLLEXP a2dCanvasObjectEvent : public wxEvent
{
public:

    //! constructor
    a2dCanvasObjectEvent( a2dIterC* ic, wxEventType type, a2dCanvasObject* object, double x, double y, int id = 0 );

    a2dCanvasObjectEvent( a2dCanvasObject* object, const a2dBoundingBox& box, int id = 0 );

    a2dCanvasObjectEvent( const a2dCanvasObjectEvent& other );

    //! clone the event
    virtual wxEvent *Clone() const { return new a2dCanvasObjectEvent(*this); }

    a2dCanvasObject* GetCanvasObject() { return (a2dCanvasObject*) GetEventObject(); } 

    double GetX() { return m_x; }
    double GetY() { return m_y; }

    //! in case of wxEVT_CANVASOBJECT_RESIZE_EVENT event get boundingbox which was sent
    a2dBoundingBox& GetBbox() { return m_box; }

    a2dIterC* GetIterC() { return m_ic; }
    // This is used when sending a2dCanvasObjectEvent's from a simple (handle less) tool
    void SetIterC( a2dIterC* ic) { wxASSERT( !m_ic ); m_ic=ic; }

private:

    DECLARE_CLASS(a2dCanvasObjectEvent)

    //! x position of event 
    double m_x;

    //! y position of event 
    double m_y;

    //! the interative context, for getting matrix for conversion to absolute
    a2dIterC* m_ic;

    //! for storing info used in wxEVT_CANVASOBJECT_RESIZE_EVENT
    a2dBoundingBox m_box;
};

//! mouse event sent from a2dCanvasObject to itself
/*!
    It contains the accumulated matrix to reach the position etc. of the object.
    This is important for editing childobjects of a2dCanvasObject directly.
    The original mouse event ( e.g. as sent from the a2dCanvasView its a2dCanvas ),
    is also stored as part of the event.

    Currently the following Id's:

    - ::wxEVT_CANVASOBJECT_MOUSE_EVENT 

    - ::wxEVT_CANVASOBJECT_ENTER_EVENT when entering a a2dCanvasObject (also children)

    - ::wxEVT_CANVASOBJECT_LEAVE_EVENT when leaving a a2dCanvasObject (also children)

    - ::wxEVT_CANVASOBJECT_POPUPMENU_EVENT Right Mouse Down default handling

    \ingroup events
*/
class A2DCANVASDLLEXP a2dCanvasObjectMouseEvent : public a2dCanvasObjectEvent
{
public:

    //! constructor
    a2dCanvasObjectMouseEvent( a2dIterC* ic, a2dCanvasObject* object, a2dHit& how, double x, double y, const wxMouseEvent& event );

    //! constructor
    a2dCanvasObjectMouseEvent( a2dIterC* ic, a2dCanvasObject* object, wxEventType type, double x, double y, const wxMouseEvent& event );

    //! constructor
    a2dCanvasObjectMouseEvent( const a2dCanvasObjectMouseEvent& other );

    //! clone the event
    virtual wxEvent *Clone( bool WXUNUSED(deep) = true ) const { return new a2dCanvasObjectMouseEvent(*this); }

    //! return the object hit
    a2dCanvasObject* GetCanvasObject() { return (a2dCanvasObject*) GetEventObject(); } 

    //! return the original mouse event that was redirected to the a2dCanvasObject
    wxMouseEvent& GetMouseEvent() { return m_mouseevent; } 

    //! in what manner the a2dCanvasObject was hit.
    a2dHit& GetHow() { return m_how; }

private:

    DECLARE_CLASS(a2dCanvasObjectMouseEvent)

    //! original mouse event
    wxMouseEvent m_mouseevent;

    //! in what manner the a2dCanvasObject was hit.
    a2dHit m_how;
};

//! general event sent from a2dHandle to its parent a2dCanvasObject
/*!
    This event can be intercepted, to implement an action when a a2dHandle is hit.
    The original mouse event ( e.g. as sent from the a2dCanvasView its a2dCanvas ),
    is also stored as part of the event.

    Currently the following Id's:

    - ::wxEVT_CANVASHANDLE_MOUSE_EVENT 

  \ingroup events
*/
class A2DCANVASDLLEXP a2dHandleMouseEvent : public a2dCanvasObjectEvent
{
public:

    //! constructor
    a2dHandleMouseEvent( a2dIterC* ic, a2dHandle* handle, double x, double y, const wxMouseEvent& event );

    //! constructor
    a2dHandleMouseEvent( const a2dHandleMouseEvent& other );

    //! clone the event
    virtual wxEvent *Clone( bool WXUNUSED(deep) = true ) const { return new a2dHandleMouseEvent(*this); }

    //! return the handle object hit
    a2dHandle* GetCanvasHandle() { return (a2dHandle*) GetEventObject(); } 

    //! return the original mouse event that was redirected to the a2dHandle
    wxMouseEvent& GetMouseEvent() { return m_mouseevent; } 

private:

    DECLARE_CLASS(a2dHandleMouseEvent)

    //! original mouse event
    wxMouseEvent m_mouseevent;
};

//! event function for  a2dCanvasObjectEvent
typedef void ( a2dEvtHandler::*a2dCanvasObjectEventFunction ) ( a2dCanvasObjectEvent& );
//! event function for  a2dHandleMouseEvent
typedef void ( a2dEvtHandler::*a2dCanvasHandleMouseEventFunction ) ( a2dHandleMouseEvent& );
//! event function for  a2dCanvasObjectMouseEvent
typedef void ( a2dEvtHandler::*a2dCanvasObjectMouseEventFunction ) ( a2dCanvasObjectMouseEvent& );

/*! \addtogroup eventhandlers
*  @{
*/

//! static event table macro for a2dCanvasObject mouse event
#define A2D_EVT_CANVASOBJECT_MOUSE_EVENT(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CANVASOBJECT_MOUSE_EVENT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCanvasObjectMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! static event table macro for a2dCanvasObject mouse enter event
#define A2D_EVT_CANVASOBJECT_ENTER_EVENT(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CANVASOBJECT_ENTER_EVENT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCanvasObjectMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! static event table macro for a2dCanvasObject mouse leave event
#define A2D_EVT_CANVASOBJECT_LEAVE_EVENT(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CANVASOBJECT_LEAVE_EVENT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCanvasObjectMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! static event table macro for a2dHandle mouse event
#define A2D_EVT_CANVASHANDLE_MOUSE_EVENT(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CANVASHANDLE_MOUSE_EVENT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCanvasHandleMouseEventFunction > ( & func ), (wxObject *) NULL ),
//! static event table macro for a2dCanvasObject mouse Right Down event
#define A2D_EVT_CANVASOBJECT_POPUPMENU_EVENT(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CANVASOBJECT_POPUPMENU_EVENT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCanvasObjectMouseEventFunction > ( & func ), (wxObject *) NULL ),

//! static event table macro for a2dCanvasObject resize event
#define A2D_EVT_CANVASOBJECT_RESIZE_EVENT(func) A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_CANVASOBJECT_RESIZE_EVENT, wxID_ANY, wxID_ANY, (a2dObjectEventFunction) static_cast < a2dCanvasObjectEventFunction > ( & func ), (wxObject *) NULL ),

//!  @} eventhandlers

typedef unsigned int a2dCursorId;
typedef unsigned int a2dImageId;

A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_NONE;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_ARROW;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_RIGHT_ARROW;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_BULLSEYE;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_CHAR;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_CROSS;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_HAND;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_IBEAM;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_LEFT_BUTTON;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_MAGNIFIER;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_MIDDLE_BUTTON;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_NO_ENTRY;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_PAINT_BRUSH;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_PENCIL;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_POINT_LEFT;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_POINT_RIGHT;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_QUESTION_ARROW;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_RIGHT_BUTTON;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_SIZENESW;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_SIZENS;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_SIZENWSE;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_SIZEWE;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_SIZING;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_SPRAYCAN;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_WAIT;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_WATCH;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_BLANK;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_ARROWWAIT;

A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_Select;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_Zoom;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_Drag;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_Move;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_Copy;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_DrawWire;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditWire;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditWireVertex;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditWireSegment;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditWireSegmentHorizontal;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditWireSegmentVertical;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_WireSegmentInsert;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_Edit;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditVertex;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditSegment;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditSegmentHorizontal;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_EditSegmentVertical;
A2DCANVASDLLEXP extern const a2dCursorId a2dCURSOR_SegmentInsert;

A2DCANVASDLLEXP extern const a2dImageId a2dBitmap_EditRectangleFill;

//! provide cursors etc.
class A2DCANVASDLLEXP a2dArtProvider : public wxObject
{
public:

    a2dArtProvider();

    ~a2dArtProvider();

    virtual wxCursor& GetCursor( a2dCursorId id );

    virtual wxBitmap& GetImage( a2dImageId id );

    // when a cursor is not in here it will be loaded and stored in here for caching.
    map<a2dCursorId,wxCursor> m_cursorsLoaded;

    // when a bitmap is not in here it will be loaded and stored in here for caching.
    map<a2dImageId,wxBitmap> m_imageLoaded;

};

//! contains global settings for the a2dCanvas library
/*!
    Settings and function using those settings or stored here.
    There is only ONE a2dCanvasGlobals instance for the whole a2dCanvas Library.

    \ingroup global

*/
class A2DCANVASDLLEXP a2dCanvasGlobal: public a2dGeneralGlobal
{

    DECLARE_CLASS(a2dCanvasGlobal)

public:
    a2dCanvasGlobal();
    virtual ~a2dCanvasGlobal();

    //! to set up layers above id wxLAYER_RESERVED
    /*!
        Layers above wxLAYER_RESERVED are reserved for special purposes,
        and must always be available.
    */
    virtual void SetupReservedLayers();

    wxPoint m_initialDocChildFramePos;
    wxSize m_initialDocChildFrameSize;
    long m_initialDocChildFrameStyle;
    long m_initialWorldCanvasStyle;

    bool WINDINGRULE;

    //!how accurate is the drawing
    double USERUNITS();
    //!how many meters is 1 unit in the database
    double PHYSUNITS();

    //!how accurate is the drawing
    void USERUNITS(double userunit);
    //!how many meters is 1 unit in the database
    void PHYSUNITS(double physicalunit);

    //!entry of data
    double ENTRYUNITS();

    double POLYTOARCRMIN();
    double POLYTOARCRMAX();
    double POLYTOARCABER();

    double ARCTOPOLYABER();

    double ACCUR();

    //!Get the central layersettings for the canvas library.
    /*!
        New a2dCanvasDocument's are initialized with this layer settings.
        A default Layer Setting is created in the constructor,
        but this one can be changed.
    */
    a2dLayers* GetLayerSetup() { return m_layersetup; }

    //!set the layersettings for the canvas library.
    /*! old layer setting will be deleted, and new one is owned.
    */
    void SetLayerSetup( a2dLayers* layersetup );

    //! load a layer set in CVG format from a file, which will be used as a template 
    //! for a2dCanvasDocument's its layer settings
    bool LoadLayers( const wxString& filename );

    //! set default pin for graph like structure
    void SetPin( a2dPin* newpin );

    //! get default pin for graph like structure
    a2dPin* GetPin();

    //! \see  GetPinCanConnect()
    void SetPinCanConnect( a2dPin* newpin );

    //! represents the pin styles for pins that can connect right now
    /*! This pin is usually bigger than the default pin and green */
    a2dPin* GetPinCanConnect();

    //! \see  GetPinCannotConnect()
    void SetPinCannotConnect( a2dPin* newpin );

    //! represnts the pin styles for pins that cannot connect right now
    /*! This pin is usually smaller than the default pin and red */
    a2dPin* GetPinCannotConnect();

    //! set default handle for editing
    void SetHandle( a2dHandle* newhandle );

    //! get default handle for editing
    a2dHandle* GetHandle();

    //! default text for displaying properties.
    a2dText* GetPropertyText();

    //! Get Stroke to use for Highlighted a2dCanvasObject's 
    a2dStroke& GetHighLightStroke();

    //! Get Fill to use for Highlighted a2dCanvasObject's 
    a2dFill& GetHighLightFill();

    //! Set Stroke to use for Highlighted a2dCanvasObject's 
    void SetHighLightStroke( const a2dStroke& stroke );

    //! Set Fill to use for Highlighted a2dCanvasObject's 
    void SetHighLightFill( const a2dFill& fill );

    //! Get Stroke to use for Selected a2dCanvasObject's 
    a2dStroke& GetSelectStroke();

    //! Get Fill to use for Selected a2dCanvasObject's 
    a2dFill& GetSelectFill();

    //! Set Stroke to use for Selected a2dCanvasObject's 
    void SetSelectStroke( const a2dStroke& stroke );

    //! Set Fill to use for Selected a2dCanvasObject's 
    void SetSelectFill( const a2dFill& fill );

    //! sets draw style to be used for selected object
    void SetSelectDrawStyle( a2dDocumentRenderStyle drawstyle ) { m_SelectDrawStyle = drawstyle; }

    //! returns draw style to be used for selected object
    a2dDocumentRenderStyle GetSelectDrawStyle() const { return m_SelectDrawStyle; }

    //! Set restriction engine (grid snapping) used normally
    void SetRestrictionEngine( a2dRestrictionEngine *restrict ) { m_restrictionEngine = restrict; }

    //! Get restriction engine (grid snapping) 
    a2dRestrictionEngine *GetRestrictionEngine(); 

    //! Set class for generating new connection objects between object and pins
    void SetConnectionGenerator( a2dConnectionGenerator *connectionGenerator ) { m_connectionGenerator = connectionGenerator; };

    //! Get class for generating new connection objects between object and pins
    a2dConnectionGenerator* GetConnectionGenerator() const { return m_connectionGenerator; }

    //! hit marging in pixels.
    /*! This is used in editing, where a drawer is known and conversion from
        pixels to world units is possible.
        a2dCanvasView copies this value in its constructor and it can be changes
        in a2dCanvasView as well
    */
    wxUint16 GetHitMarginDevice() const { return m_hitmargin_device; }

    //! hit marging in pixels.
    /*! \see GetHitMarginDevice */
    void SetHitMarginDevice( wxUint16 val ) { m_hitmargin_device = val; }

    //! hit marging in world units.
    /*! This is used during command processing, where a drawer is not known.
    */
    double GetHitMarginWorld() const { return m_hitmargin_world; }

    //! hit marging in world units.
    /*! \see GetHitMarginWorld */
    void SetHitMarginWorld( double val ) { m_hitmargin_world = val; }

    //! get minimum distance of copied object from original
    double GetCopyMinDistance() const { return m_copymindistance; }

    //! set minimum distance of copied object from original
    void SetCopyMinDistance( double val ) { m_copymindistance = val; }

    //! coordinates below this distance will be trated as equal
    /*! This is used e.g. to check if two pins have the same location.
        This should be the machine presition with the used coordinate resolution
    */
    double GetCoordinateEpsilon() const { return m_coordinateepsilon; }

    //! \see GetCoordinateEpsilon
    void SetCoordinateEpsilon( double val ) { m_coordinateepsilon = val; }

    //!Set to draw layers in reverse order
    void SetReverseOrder(bool reverse_order) { m_reverse_order = reverse_order; }

    //!Get Setting for draw layers in reverse order
    bool GetReverseOrder() const  { return m_reverse_order; }

    //! set true result in having straight lines rerouted between begin and end pin
    void SetRouteOneLine( bool oneLine ) { m_oneLine = oneLine; }

    //! see SetRouteOneLine()
    bool GetRouteOneLine() const { return m_oneLine; }

    //! Path for Icons and small bitmaps    
    a2dPathList& GetLayersPathList() const { return m_layersPath; }

    a2dArtProvider& GetArtProvider() { return m_artProvider; }

    void SetArtProvider( a2dArtProvider& artProvider ) { m_artProvider = artProvider; }

    wxCursor& GetCursor( a2dCursorId id ) { return m_artProvider.GetCursor( id ); }

private:

    a2dArtProvider m_artProvider;

    static a2dPathList m_layersPath;

    //!default setup for layers in a2dCanvasDocument's
    a2dSmrtPtr<a2dLayers>  m_layersetup;

    a2dPinPtr m_defPin;
    a2dPinPtr m_defCanConnectPin;
    a2dPinPtr m_defCannotConnectPin;

    a2dHandlePtr m_defHandle;

    a2dSmrtPtr<a2dText> m_propertytext;

    double m_userunits;
    double m_physicalunits;
    double m_default_acc;
    double m_displayaberration;
    double m_arc2polyaber;
    double m_poly2arcMin;
    double m_poly2arcMax;
    double m_poly2arcAber;

    //! Stroke to use for Highlighted a2dCanvasObject's 
    a2dStroke m_HighLightStroke;

    //! Fill to use for Highlighted a2dCanvasObject's 
    a2dFill   m_HighLightFill;

    //! Stroke to use for selected a2dCanvasObject's 
    a2dStroke m_SelectStroke;

    //! Fill to use for selected a2dCanvasObject's 
    a2dFill   m_SelectFill;

    //! draw style to be used for selected object
    a2dDocumentRenderStyle m_SelectDrawStyle;

    //! restriction engine to be used usually (if zero don't restrict)
    a2dRestrictionEnginePtr m_restrictionEngine;

    //! generator for new connections
    a2dConnectionGeneratorPtr m_connectionGenerator;

    //! hit marging in pixels.
    /*! This is used in editing, where a drawer is known and conversion from
        pixels to world units is possible.
        a2dCanvasView copies this value in its constructor and it can be changes
        in a2dCanvasView as well
    */
    wxUint16 m_hitmargin_device;

    //! hit marging in world units.
    /*! This is used during command processing, where a drawer is not known.
    */
    double m_hitmargin_world;

    //! the minimum distance in world units of a copied object from the original
    double m_copymindistance;

    //! \see GetCoordinateEpsilon
    double m_coordinateepsilon;

    //!draw document in reverse order if set, used as default value for a2dCanvasDocument.
    bool m_reverse_order;

    //! used in routing wires to be straight or manhatten
    bool m_oneLine;

public:

    static const a2dPropertyIdPathList PROPID_layerPathList;

public: // all methods a2dDocviewGlobal

    //! Gets a2dDocumentCommandProcessor pointer 
    a2dDocumentCommandProcessor* GetDocviewCommandProcessor() const 
    { return m_a2dDocviewGlobal->GetDocviewCommandProcessor(); }

    //! Normally the docview commandprocessor is set in the constructor when creating new a2dDocviewGlobal
    void SetDocviewCommandProcessor( a2dDocumentCommandProcessor* docviewCommandProcessor )
    { m_a2dDocviewGlobal->SetDocviewCommandProcessor( docviewCommandProcessor );    }

private:

    a2dDocviewGlobal* m_a2dDocviewGlobal;

};

//! global a2dCanvasGlobal to have easy access to global settings
A2DCANVASDLLEXP_DATA( extern a2dCanvasGlobal* ) a2dCanvasGlobals;

// ----------------------------------------------------------------------------
// 
// ----------------------------------------------------------------------------


//! a2dEvtHandler event function for wxTimerEvent
typedef void (a2dEvtHandler::*a2dCanvasObjectTimerEventFunction)(wxTimerEvent&);

/*! \addtogroup eventhandlers
*  @{
*/

//! timer event for a2dCanvasObject from a2dTimer
#define A2D_EVT_CANVASOBJECT_TIMER(timerid, func) \
    A2D_DECLARE_EVENT_TABLE_ENTRY( wxEVT_TIMER, timerid, -1, (a2dObjectEventFunction) wxStaticCastEvent( a2dCanvasObjectTimerEventFunction, & func ), NULL),

//!  @} eventhandlers

//! wxArt2D specific a2dTimer which notifies a2dCanvasObject's
/*!
    \ingroup events
*/
class a2dTimer : public wxTimer
{
public:
 
    a2dTimer() 
    { 
        Init(); 
        m_canvasObjectOwner = NULL; m_id = 0; 
    }

    //! constructor 
    /*!
        \param owner to which a2dCanvasObject/a2dEvtHandler should the event be sent. 
        \param id event id 
    */
    a2dTimer( a2dEvtHandler *owner, int id = -1 )
    {
        m_canvasObjectOwner = owner;
        m_id = id;
    }

    //! set object to recieve timer event.
    /*!
        \param owner to which a2dCanvasObject/a2dEvtHandler should the event be sent. 
        \param id event id 
    */
    void SetOwner(a2dEvtHandler *owner, int id = -1)
    {
        m_canvasObjectOwner = owner;
        m_id = id;
    }

    //! called by a2dTimer when time event is issued.
    //! This sents the event to the m_owner
    virtual void Notify()
    {
        wxCHECK_RET( m_canvasObjectOwner, _T("a2dTimer::Notify() should be overridden.") );

#if !wxCHECK_VERSION(2,9,0)
    wxTimerEvent event( m_id, m_milli );
#else
    wxTimerEvent event( *this );
#endif
        m_canvasObjectOwner->ProcessEvent(event);
    }

protected:

    unsigned long m_id;
    a2dEvtHandler *m_canvasObjectOwner;
};


#endif

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