canprim.h

Go to the documentation of this file.

/*! \file wx/canvas/canprim.h
    \brief all basic primitives derived from a2dCanvasObject

    Circle rectangle arc line arrow etc. or placed in here.
    And Pins and pin classes to connect objects.

    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: canprim.h,v 1.37 2009/07/17 16:03:34 titato Exp $
*/

#ifndef __WXCANPRIM_H__
#define __WXCANPRIM_H__

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

#include "wx/image.h"
#include "wx/canvas/candefs.h"
#include "wx/canvas/canobj.h"

class A2DARTBASEDLLEXP a2dVpath;

//! a2dOrigin stays at World Coordinate Zero (0,0) not matter what.
/*! You can define width and Height of the cross.  \ingroup canvasobject */
class A2DCANVASDLLEXP a2dOrigin: public a2dCanvasObject
{
public:


    //! constructor
    a2dOrigin();

    //! constructor
    /*!
        \param w width in pixels of origin
        \param h height in pixels of origin
    */
    a2dOrigin( double w, double h);

    a2dOrigin( const a2dOrigin &other, CloneOptions options );

    ~a2dOrigin();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //!return width
    double  GetWidth() { return m_width; }

    //!return height
    double  GetHeight() { return m_height; }

    //!set width
    /*!
        \param width width of origin
    */
    void SetWidth( double width ) { m_width = width; SetPending(true); }

    //!set height
    /*!
        \param height height origin
    */
    void SetHeight( double height ) { m_height = height; SetPending(true); }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );
#endif //wxART2D_USE_CVGIO

    DECLARE_CLASS(a2dOrigin)

protected:
    void DoRender( a2dIterC& ic, OVERLAP clipparent );

    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;

    //! width in pixels
    double m_width;

    //! height in pixels
    double m_height;

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dOrigin( const a2dOrigin &other );
};

//! a2dHandle is used inside editing versions of a certain objects. 
/*! In that case instances of this object are used to draw dragging Handles.
\remark width and height are defined in pixels.

\ingroup canvasobject
 */
class A2DCANVASDLLEXP a2dHandle: public a2dCanvasObject
{

    A2D_DECLARE_EVENT_TABLE()

public:

    //! constructor
    a2dHandle();

    //! construct a handle
    /*!
        \param parent parent of handle 
        \param xc center x
        \param yc center y
        \param name name of handle
        \param w  width of handle rectangle
        \param h  height of handle rectangle
        \param angle angle of rotation of handle rectangle
        \param radius for a rounded handle rectangle
    */
    a2dHandle( a2dCanvasObject* parent, double xc, double yc, const wxString& name = wxT(""), int w = 0, int h = 0, double angle = 0 , int radius = 0 );
    a2dHandle( const a2dHandle& other, CloneOptions options );
    ~a2dHandle();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //!get the name given to the handle.
    wxString GetName() const { return m_name; }

    //! set the name of the handle (must be unique)
    void SetName(const wxString& name) { m_name=name; }

    //! set all parameters
    /*!
        \param xc center x
        \param yc center y
        \param w  width of handle rectangle
        \param h  height of handle rectangle
        \param angle angle of rotation of handle rectangle
        \param radius for a rounded handle rectangle
    */
    void Set(double xc, double yc, int w, int h, double angle = 0 , int radius = 0 );

    //! set basic parameters
    /*!
        \param xc center x
        \param yc center y
        \param name empty means leave name as is
    */
    void Set2( double xc, double yc, const wxString& name = wxT("") );

    //! set parent object of the pin
    void SetParent( a2dCanvasObject* parent );

    //! get parent object of the pin
    a2dEvtHandler* GetParentEvtHandler() { return m_parent; }

    a2dCanvasObject* GetParent() const { return m_parent; }

    //!return width
    int  GetWidth() const { return m_width; }

    //!return height
    int  GetHeight() const { return m_height; }

    //!return radius
    int  GetRadius() const { return m_radius; }

    void SetMode( int mode ) {
        m_mode = mode; SetPending( true ); }

    int GetMode() const { return m_mode; }

#if wxART2D_USE_CVGIO
    virtual void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );
#endif //wxART2D_USE_CVGIO
    virtual bool IsTemporary_DontSave() const;

    DECLARE_CLASS(a2dHandle)

protected:

    void OnEnterObject(a2dCanvasObjectMouseEvent &event);

    void OnLeaveObject(a2dCanvasObjectMouseEvent &event);

    void OnCanvasObjectMouseEvent( a2dCanvasObjectMouseEvent& event );

    void DoRender( a2dIterC& ic, OVERLAP clipparent );

    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );

    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;

    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    //! name of the handle
    wxString m_name;

    //!width in pixels
    int m_width;

    //!height in pixels
    int m_height;

    //!radius of rectangle that will be rendered
    int m_radius;

    //! modifies rendering
    int m_mode;

    //!what is the a2dCanvasObject that i am part of
    //* This is intentionally not a smart pointer to remove a reference loop */
    a2dCanvasObject* m_parent;

public:
    static a2dPropertyIdInt32* PROPID_Width;
    static a2dPropertyIdInt32* PROPID_Height;
    static a2dPropertyIdInt32* PROPID_Radius;

    DECLARE_PROPERTIES()

public:
    const static long sm_HandleNoHit;
    const static long sm_HandleHit;

    //static const a2dPropertyIdLineSegment PROPID_linesegment;


private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dHandle( const a2dHandle& other );
};

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DCANVASDLLEXP a2dSmrtPtr<a2dHandle>;
#endif

//! smart pointer for a2dHandle
typedef a2dSmrtPtr<a2dHandle> a2dHandlePtr;


class A2DCANVASDLLEXP a2dPinClass;
#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DCANVASDLLEXP std::allocator<a2dPinClass*>;
template class A2DCANVASDLLEXP std::allocator< std::_List_nod<a2dPinClass*, std::allocator<a2dPinClass* > >::_Node >;
template class A2DCANVASDLLEXP std::allocator< std::_List_ptr<a2dPinClass*, std::allocator<a2dPinClass* > >::_Nodeptr >;
template class A2DCANVASDLLEXP std::list< a2dPinClass* >;
#endif

//! a2dPin used in a2dCanvasObject to add pins to it.
/*! 
   This class is meant to be added as child object to a a2dCanvasObject, there it is treated in a special manner 
   to connect the parent a2dCanvasObject to other a2dCanvasObject's.
   Using pins one can create graph/diagram structures of connected a2dCanvasObjects.
   Pins can connect one canvas object to another via two connected pins.
   The Pin can only connect to one other Pin. 
   Special connection canvas objects like a2dWirePolylineL and a2dWires, 
   can be used to create wires between canvas objects. 
   The connection objects also have pins, which they use to connect the wires to other a2dCanvasObjects. 
   Those wire line objects do recalculate the wires when moving a connected a2dCanvasObject.
   This is often called rubberbanding. A wire connection object, can go as far as having dedicated reroute algorithms.
   a2dWirePolylineL is such an object, on of its modes is to reroute sets of wires.

   One can traverse a2dCanvasObject's via its pins, since the Pin has a parent pointer
   to the a2dCanvasObject it belongs to.

   a2dCanvasObject has member functions to manipulate the a2dPin's it has.
   A pin itself is created by its parent, and therefore parent object decides where pins are located,
   and what needs to happen when one wants to connect to one of its pins.
   This is/can be specific for each derived a2dCanvasObject and each of its pins.
   To achieve different behaviour for pins without deriving new pin classes, a pin has a a2dPinClass member.
   The a2dPinClass is used to specialize a pin for a certain connection purpose.
   Think of input and output pins on objects. One can for instance not connect an input pin of one object to 
   the input pin of anothere object.
   All these constraints can be stored in the pin its a2dPinClass.
   So in general there will be no need to derive your own MyCanvasPin, unless you want to e.g. change rendering. 

   a2dPinClass is not stored into CVG format, only its name is stored, the list of available 
   pinclasses is assumed to be specific to the application.

   A pin does have an angle, this make the relative angle to a connected Pin
   of another a2dCanvasObject well defined. Certain application require object to be connected at the same angles.

   \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dPin: public a2dHandle
{

    A2D_DECLARE_EVENT_TABLE()

public:

    enum a2dPinFlags
    {
        /*! no flag set */
        NON  = 0x0,

        /*! dynamic pins can walk along a line */
        dynamic = 0x0001,

        /*! temporary pins are created to indicate possible connection, and deleted or cloned when connected */
        temporary = 0x0002,

        /*! set when pin is on an object and not a wire or connect.*/
        objectPin = 0x0004,

        /*! true when pin is internal to object border. */
        internal  = 0x0008,
        
        /*! temporary and objectPin set */
        temporaryObjectPin = temporary | objectPin,

        /*! For Xor ing and all set */
        ALLSET  = 0xFFFFFFFF
    };

    //! constructor
    a2dPin();

    //! constructor
    a2dPin( a2dCanvasObject* parent, const wxString& name, a2dPinClass* pinclass,  double xc, double yc, double angle = 0 , int w = 0, int h = 0,  int radius = 0 );

    //! copy constructor
    a2dPin( const a2dPin &other, CloneOptions options );

    //! destructor
    ~a2dPin();

    //! flag to render connected pin
    /*!
        \remark set the object its pending flag and inform root about this
        \remark default false
        \param RenderConnected if true connected pin is rendered visible
    */
    inline void SetRenderConnected(bool RenderConnected) { SetPending(true); m_RenderConnected = RenderConnected; }

    //! \return true is connected pins are rendered
    inline bool GetRenderConnected() { return m_RenderConnected; }

    virtual void SetPending( bool pending );

    //! \remark the parent of the pin is taken over, but its connection pin not.
    virtual a2dObject* Clone( CloneOptions options ) const;

    //! set parent object of the pin
    virtual void SetParent( a2dCanvasObject* parent );

    //! set postion angle and name of the pin
    /*!
        \param xc x-position
        \param yc y-position
        \param angle the angle
        \param name empty means leave name as is
        \param dynamic when true pin is only a temporary pin.
    */
    void Set(double xc, double yc, double angle =0 , const wxString& name = wxT(""), bool dynamic = false );

    //! get absolute position of the pin ( after applying the parent's matrix and its own matrix )
    a2dPoint2D GetAbsXY() const;

    //! get absolute X position of the pin ( after applying the parent's matrix and its own matrix )
    double GetAbsX() const;

    //! get absolute Y position of the pin ( after applying the parent's matrix and its own matrix )
    double GetAbsY() const;

    //! set the absolute X,Y position of the pin ( after applying the parent's matrix and its own matrix )
    void SetAbsXY( double x, double y );

    //! set the absolute X,Y position of the pin ( after applying the parent's matrix and its own matrix )
    void SetAbsXY( const a2dPoint2D & point );

    //! get absolute angle of the pin ( after applying the parent its matrix and it own matrix )
    double GetAbsAngle() const;

    //! return the pin class of this pin
    a2dPinClass *GetPinClass() const { return m_pinclass; }

    //! Set the pin class
    void SetPinClass( a2dPinClass* pinClass ) { m_pinclass = pinClass; }

    //! Is given pin allowed to connect to this pin
    /*!
        Override this function to make restriction on connecting pins.
        E.g You might make restriction for pins on one layer, not to connect with pins on other layers.

        The default implementation checks if the two pins have a2dPinClass which a2dPinClass::CanConnectTo() to eachother.        
    */
    virtual bool MayConnectTo( a2dPin* connectto );

    //! connect this pin to the given pin
    void ConnectTo( a2dPin* connectto ); 

    //! Return the pin to which this pin is connected.
    a2dPin* ConnectedTo() const { return m_canvaspin; }

    //! Find a connectable pin.
    /*! This only searches for pins of child objects of the root given */
    a2dPin* FindConnectablePin( a2dCanvasObject *root, double margin, bool autocreate );

    //! Try to connect this pin to another pin at the same location
    void AutoConnect( a2dCanvasObject *root, double margin );

    //! Check if this pin is Dislocated ( pin pos different from connected pins pos )
    bool IsDislocated() const;

    //! return true if this pin is a dynamic pin
    /*!
        Pins like this are create automatically by some objects, when they are able to connect.
        The location is dynamic, and therefore they are called dynamic.
        When moving connected objects/wires, the pins may move in position.
    */
    bool IsDynamicPin() const { return m_dynamicPin; }

    //! set when pin is a dynamic pin
    void SetDynamicPin( bool dynamicPin ) { m_dynamicPin = dynamicPin; }

    //! return true if this pin is a temporary pin
    /*!
        Pins like this are create automatically by some objects, when they are able to connect.
        Since for Undo actions, commands are normally used to create extra pins inside tools.
        But a temporary pin is in general for editing feedback, and therefore it only will stay alive when 
        the tools attempt to connect a second pin to it. 
        At that moment it becomes clear that a command is needed to create and connect the temporary pin using commands.
        If not the temporary pin will be deleted in the end, as if it did never exist, in no commands on the command stack 
        were issued.
    */
    bool IsTemporaryPin() const { return m_temporaryPin; }

    //! set when pin is only a temporary pin, which will be deleted by the application if not connected
    //! to another pin later.
    void SetTemporaryPin( bool temporaryPin ) { m_temporaryPin = temporaryPin; }

    //! set when pin is within the border of its parent
    /*!
        Used when routing wires to a pin which is within the object and not on the border.
        Meaning wires must be able to route within the object that contains the pin. 
    */
    void SetInternal( bool internal ) { m_internal = internal; }

    //! see SetInternal()
    bool IsInternal() const { return m_internal; }

    //! set when pin is an object pin
    void SetObjectPin( bool objectPin ) { m_objectPin = objectPin; }

    //! return true if the pin is on object instead of wire/connects
    bool IsObjectPin() const { return m_objectPin; }

#if wxART2D_USE_CVGIO
    virtual void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );
#endif //wxART2D_USE_CVGIO
    virtual bool IsTemporary_DontSave() const;
    virtual bool AlwaysWriteSerializationId() const;
    virtual bool LinkReference( a2dObject *other );

    DECLARE_CLASS(a2dPin)

    //! This is used with EditFeedback to highlight matching pins when drawing a wire
    const static a2dFeedbackId sm_feedbackStart;
    //! This is used with EditFeedback to dynamically create pins, which can connect to
    //! the pin given as parameter. When a wire needs to be connected to another wire or object,
    //! this feedback id, result in generating the pin if non is there. The connection is not made yet, 
    //! it is only an indication that connection is possible.
    //! The generated pins 
    const static a2dFeedbackId sm_feedbackGeneratePin;
    //! This is used with EditFeedback to delete dynamically create pins and remove highlighting
    const static a2dFeedbackId sm_feedbackEnd;

    //! id generated in a2dCanvasObject::EditFeedback() when this pin can be connected.
    const static a2dFeedbackId sm_feedbackCanConnect;

    //! when the pin can connect to one of the maps in the table of a2dFeedbackIdPinMapping, rendering mode is changed.
    //! This feedback id is used when a pin on an object can connect to one of the a2dPinClassMap's
    //! which is given as input to the id. A typical use is when a new wire needs to be started and the type of wire 
    //! depends on the pin the wire starts at. The a2dPinClassMap found at a start pin, will give the type of wire
    //! which needs to be created.
    static a2dFeedbackIdPinMapping sm_feedbackOnPinmapConnect;

    const static long sm_PinUnConnected;
    const static long sm_PinConnected;
    const static long sm_PinCanConnect;
    const static long sm_PinCannotConnect;
    const static long sm_PinCanConnectToPinClass;

protected:

    void OnEnterObject(a2dCanvasObjectMouseEvent &event);

    void OnLeaveObject(a2dCanvasObjectMouseEvent &event);

    //! specific feedback fo a pin
    /*!
        Depending on the feedback id, sets the rendering mode of the pin.  
        
          \li sm_feedbackStart if connection is possible set mode to 2 else 3
          \li sm_feedbackEnd cleanup dynamic pins when not connected and set mode to 0
          \li sm_feedbackGeneratePin cleanup dynamic pins when not connected
    */
    virtual void EditFeedback( a2dIterC& ic, const a2dFeedbackId *id, a2dCanvasObject *currentEdit=0, int depth=INT_MAX, a2dCanvasObjectFlagsMask flags=0, double x=0, double y=0 );
    virtual void DrawHighLighted( a2dIterC& ic );

    virtual void RestoreConnectionsAfterCloning( class a2dCanvasCommandProcessor *cp = 0 );
    virtual void ClearAllPinConnections( class a2dCanvasCommandProcessor *cp );

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

#ifdef _DEBUG
    virtual void DoDump( int indent, wxString *line );
#endif

    //! The class defines to which other pins this pin can connect
    a2dPinClass* m_pinclass;

    //! set when this pin is a temporary pin for editing feedback
    bool m_dynamicPin: 1;

    //! set when this pin is a temporary pin for editing feedback,
    //! this pin will be replaced by a normal pin or its flag will be reset, to make it so.
    bool m_temporaryPin: 1;

    //! flag to render or not when connected
    bool m_RenderConnected: 1;

    //! true when pin is internal to object border.
    bool m_internal: 1;

    //! is true when pin is on an object instead of a wire/connect
    bool m_objectPin: 1;

    //!to which a2dPin is this pin connected onto another graph.
    /*!
        If not connected it is NULL.
    */
    a2dPin* m_canvaspin;

    //!here during cloning source and destination are connected
    a2dPin* m_clonebrother;

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dPin( const a2dPin &other );
};

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
//! smart pointer for a2dPin
template class A2DCANVASDLLEXP a2dSmrtPtr<a2dPin>;
#endif
typedef a2dSmrtPtr<a2dPin> a2dPinPtr;

//! This is a class/type description for a2dPin's
/*! a2dPin's have a pin class which can be used by a2dConnectionGenerator to define 
    to which other pin classes ( of other pins ) it can connect and how.
    E.g. One class might be input and one class might be output and it is
    only possible to connect an input to an output, but not two inputs or two
    outputs. 
    This class mainly has a name and an array of pin classes it is allowed to connect to.
    How and when a pinclass is connected to another pinclass ( one to one, or with a wire and what type of wire ), 
    is decided by the a2dConnectionGenerator. 

    As an example:
    You want pin object on certain layers to only connect to pins on some other layers. For that you give a pin
    on a layerA a a2dPinClass called PC_layerA. And for pins on layers B C D you do the same. 
    Now to be able to connect a  PC_layerA to PC_layerB PC_layerC and NOT PC_layerD. You add to PC_layerA
    its m_canConnectTo, the pin classes: PC_layerA, PC_layerB, PC_layerC. And to PC_layerB, PC_layerC you add at least PC_layerA.
    You could also define a pin class called PC_layersABC with in its m_canConnectTo he same PC_layersABC,
    next you use for pins one layers A,B,C this class. So all pins on those ayesr can connect with each other.
    As you see what layer a pin is on, is of no importance, it is the pin class which allows pins to connect or not.

    

    Both the class and the m_canConnectTo array are created statically. If not,
    it is your responsibility to remove the canConnectTo array. The
    m_canConnectTo array is terminated with a zero pointer. The default
    class is a2dPinClass::Standard, which can only connect to itself.
*/

class A2DCANVASDLLEXP a2dPinClass
{
public:

    enum a2dPinClassFlags
    {
        /*! input */
        PC_input = 0x0001,

        /*! output */
        PC_output = 0x0002,

        /*! output */
        PC_angle = 0x0004,
        
        /*! For Xor ing and all set */
        PC_ALLSET  = 0xFFFFFFFF
    };
  
    //! constructor
    /*!
        \param name name of the pinclass, can be used e.g. for XML saving
        \param flags type of pin (in/out etc.)
    */
    a2dPinClass( const wxString &name, wxUint32 flags = PC_input | PC_output );

    //! destructor
    ~a2dPinClass();

    //! add a connection pinclass, to which this pin can connect
    void AddConnect( a2dPinClass* pinClass ) { m_canConnectTo.push_back( pinClass ); }

    //! remove a connection pinclass
    void RemoveConnect( a2dPinClass* pinClass );

    //! called to initialize static stockobjects
    static void InitializeStockPinClasses();
    
    //! called to delete all pin class objects
    static void DeleteStockPinClasses();

    const wxString &GetName() const { return m_name; }

    //! return true if the pinClass is for pins that accepts input
    bool IsInputPin() const { return (m_flags & PC_input) == PC_input; }

    //! return true if the pinClass is for pins that accepts input
    bool IsOutputPin() const { return (m_flags & PC_output) == PC_output; }

    //! is there an angle line on the pin
    bool HasAngleLine() const { return (m_flags & PC_angle) == PC_angle; }

    //! is there an angle line on the pin
    void SetAngleLine( bool value ) {   value?(m_flags = m_flags | PC_angle) : 
              m_flags = m_flags & ( PC_ALLSET ^ PC_angle ); }

    //! get all flags
    wxUint32 GetFlags() { return m_flags; }

    //! searches in the connection list for a given pin class 
    /*!
        If the given pin class is found, this means that the pin having that pinclass can connect to
        the pin having this pinclass.

        \param other pin to test connection
        \param flags type of pin needed
    */
    a2dPinClass*  CanConnectTo( a2dPinClass *other = NULL, wxUint32 flags = PC_input | PC_output ) const;

    //! return list of connectable pin class objects.
    std::list< a2dPinClass* >& GetConnectList() { return m_canConnectTo; }

    //! search in m_canConnectTo list for a pin class which can be used for creating connect objects/wires.
    /*!
        If in the list a pin class has m_isObjectPin set false and m_tmplObject is set, that one is returned.
        \param specific if set, only look for this type of pin class.    
        \param flags type of pin
        
        \return pinclass found or NULL
    */
    a2dPinClass* CanConnectToAsWire( a2dPinClass *specific = NULL, wxUint32 flags = PC_input | PC_output ) const;

    //! search in m_canConnectTo list for a pin class which can connect to another object which is NOT connect
    /*!
        If in the list a pin class has m_isObjectPin set true is returned.
        \param specific if set, only look for this type of pin class. 
        \param flags type of pin

        \return pinclass found or NULL
    */
    a2dPinClass* CanConnectToAsObject( a2dPinClass *specific = NULL, wxUint32 flags = PC_input | PC_output ) const;

    //! the template object is used as a template for creating new wires between pins.
    /*! You can use it for other purposes as well if needed.
      
        When m_isObjectPin is false (meaning pin class for wire connections), this is a template for a new wire.
    */
    void SetConnectObject( a2dCanvasObject *tmplObject );

    //! return connect object.
    a2dCanvasObject* GetConnectObject() const;

    //! return the name of this pinclass.
    static a2dPinClass *GetClassByName( const wxString &name );

    //! 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 );

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

    //! 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; }

    a2dPinClass* GetPinClassForTask( a2dConnectTask task, a2dCanvasObject* obj ) const
        { return m_connectionGenerator->GetPinClassForTask( const_cast<a2dPinClass*>(this), task, obj ); }

protected:

    //! name of pin class
    wxString m_name;

    //! list of a2dPinClass objects, to which this a2dPinClass object can connect.
    //! Each Pin has a a2dPinClass which defines to which that pin can connect to other pins.
    //! This is approved based on those other Pins having a a2dPinClass in this array here.
    //! Of course another pin which wants to connect, should check the availibility of this pin its pinclass
    //! in its own connection list.
    std::list< a2dPinClass* > m_canConnectTo;

    //! pinclass specific flags
    wxUint32 m_flags;

    //! Template for created object which represents a connection. e.g a2dWirePolylineL.
    a2dCanvasObjectPtr m_tmplObject; 

    a2dPinPtr m_defPin;

    a2dPinPtr m_defCanConnectPin;

    a2dPinPtr m_defCannotConnectPin;

    //! Use this connection generator for wires and pins
    a2dConnectionGeneratorPtr m_connectionGenerator;

public:

    //! a linked lists of all a2dPinClass'es, so that one can get a class by name
    static std::list< a2dPinClass* > m_allPinClasses;

    //! used to ask for a new default pin on an object.
    /*!
        m_connectionGenerator decides what is returned when asking a connection task given this pin class.
    */
    static a2dPinClass* Any;

    //! Pins of this class can only connect to pins of the same class
    static a2dPinClass* Standard;

    //! Pins of this class can only connect to Wire pins
    static a2dPinClass* Object;
    //! Pins of this class can only connect to Object pins
    static a2dPinClass* Wire;
    
    //! Pins of this class can only connect to Output pins
    static a2dPinClass* Input;
    //! Pins of this class can only connect to Input pins
    static a2dPinClass* Output;
    
    //! Pins of this class can only connect to WireInput pins
    static a2dPinClass* ObjectInput;
    //! Pins of this class can only connect to WireOutput pins
    static a2dPinClass* ObjectOutput;
    //! Pins of this class can only connect to ObjectInput pins
    static a2dPinClass* WireInput;
    //! Pins of this class can only connect to ObjectOutput pins
    static a2dPinClass* WireOutput;
};

//! a2dRectC is a centered rectangle 
/*!
    Rectangle around a center point.

    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dRectC: public a2dCanvasObject
{
public:

    //! constructor
    a2dRectC();

    //! construct a centered rectangle
    /*!
        \param xc center x
        \param yc center y
        \param w  width of rectangle
        \param h  height of rectangle
        \param angle angle of rotation of rectangle
        \param radius for a rounded rectangle
    */
    a2dRectC( double xc, double yc, double w, double h, double angle =0 , double radius=0);

    //! constructor
    a2dRectC( const a2dRectC& ori, CloneOptions options );

    //! destructor
    ~a2dRectC();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! set all paramters for the centered rectangle
    /*!
        \param xc center x
        \param yc center y
        \param w  width of rectangle
        \param h  height of rectangle
        \param angle angle of rotation of rectangle
        \param radius for a rounded rectangle
    */
    void    Set(double xc, double yc, double w, double h, double angle =0 , double radius=0);

    //!set width of rectangle
    /*!
        \param w width of rectangle
    */
    void    SetWidth( double w)  { m_width=w; SetPending(true); }

    //!set height of rectangle
    /*!
        \param h height of rectangle
    */
    void    SetHeight( double h) { m_height=h; SetPending(true); }

    //!return width
    double  GetWidth() const { return m_width; }
    //!return height
    double  GetHeight() const { return m_height; }
    //!return radius
    double  GetRadius() const { return m_height; }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );
#endif //wxART2D_USE_CVGIO

    a2dVertexList* GetAsPolygon();

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    DECLARE_CLASS(a2dRectC)

protected:

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;

    //! width of rectangle
    double m_width;
    //! height of rectangle
    double m_height;
    //!radius in case of rounded rectangle
    double m_radius;

public:

    static a2dPropertyIdDouble* PROPID_Width;
    static a2dPropertyIdDouble* PROPID_Height; 
    static a2dPropertyIdDouble* PROPID_Radius; 

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dRectC( const a2dRectC& ori );
};

//!a2dArrow is used for having line begin and ends on specific objects.
/*! Those objects do position the arrow at the right place, and scale if needed.
    \sa a2dEndsLine
    \sa a2dPolylineL

    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dArrow: public a2dCanvasObject
{
public:

    //! constructor
    /*!
        \param xt x top of arrow (normal 0)
        \param yt y top of arrow (normal 0)
        \param l1 How long is the arrow.
        \param l2 Distance from top to the inside of the arrow.
        \param b  How broad is the basis of the arrow.
        \param spline Draw the arrow in a spline fashion
    */
    a2dArrow( double xt, double yt, double l1, double l2, double b, bool spline = false);

    //! constructor
    a2dArrow();

    //! copy constructor
    a2dArrow( const a2dArrow& ori, CloneOptions options );

    ~a2dArrow();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! Sets top, length, height and broad parameters
    /*!
        \param xt: x top of arrow (normal 0)
        \param yt: y top of arrow (normal 0)
        \param l1: How long is the arrow.
        \param l2: Distance from top to the inside of the arrow.
        \param b: How broad is the basis of the arrow.
    */
    void    Set(double xt, double yt, double l1, double l2, double b, bool spline = false );

    //! Sets length, height and broad parameters
    /*!
        \param l1: How long is the arrow.
        \param l2: Distance from top to the inside of the arrow.
        \param b: How broad is the basis of the arrow.
    */
    void    Set( double l1, double l2, double b, bool spline = false );

    //! Returns the arrow length.
    double GetL1() { return m_l1; }

    //! return Distance from top to the inside of the arrow.
    double GetL2() { return m_l2; }

    //! return how broad the basis of the arrow is.
    double GetBase() { return m_b; }

    //! is the arrwo drawn as a splined polygon?
    bool GetSpline() { return m_spline; }

    //! return the arrow converted to a polygon.
    a2dVertexList* GetAsPolygon();

    //! return the arrow converted to a vector path.
    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    DECLARE_CLASS(a2dArrow)

protected:

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    void DoRender( a2dIterC& ic, OVERLAP clipparent );

    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );

    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;

    //! length from top of arrow to outside points in X
    double m_l1;

    //! length from top of arrow to inside point in X
    double m_l2;

    //! base of arrow
    double m_b;

    //! draw splined?
    bool m_spline;


private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dArrow( const a2dArrow& ori );
};

//! a2dWH
/*!
   Virtual base class for canvas objects with width and height parameters.
   The object has an extension from (x,y) to (x+w,y+h).
     
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dWH: public a2dCanvasObject
{
    A2D_DECLARE_EVENT_TABLE()

public:
    //!default constructor
    a2dWH();

    //!standard constructor
    /*!
    \param x: x minimum
    \param y: y minimum
    \param w: Width of object
    \param h: Heigth of object
    */
    a2dWH( double x, double y, double w, double h);

    //!destructor
    ~a2dWH();

    //!copy constructor
    a2dWH( const a2dWH& other, CloneOptions options );

    //! This is here so that this class cannot be used directly
    virtual a2dObject* Clone( CloneOptions options ) const = 0;

    //!set width of rectangle
    /*!
        \param w width of rectangle
    */
    void    SetWidth( double w)  { m_width = w; SetPending(true); }

    //!set height of rectangle
    /*!
        \param h height of rectangle
    */
    void    SetHeight( double h) { m_height = h; SetPending(true); }

    //!return width
    double  GetWidth() const { return m_width; }
    //!return height
    double  GetHeight() const { return m_height; }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    bool RestrictToObject( a2dRestrictionEngine* engine, a2dSnapToWhatMask snapToWhat );
    
    DECLARE_CLASS(a2dWH)

protected:


    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );
    void OnHandleEvent(a2dHandleMouseEvent &event);

    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );
    void OnResizeObjectToChildBox(a2dCanvasObjectEvent &event);

    //! width of rectangle
    double m_width;
    //! height of rectangle
    double m_height;

public:

    //! property to get m_width
    static a2dPropertyIdDouble* PROPID_Width;
    //! property to get m_height
    static a2dPropertyIdDouble* PROPID_Height; 

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dWH( const a2dWH& other );
};

//! a2dWHCenter
/*!
   Virtual base class for canvas objects with width and height parameters.
   The object has an extension from (x-w/2,y-h/2) to (x+w/2,y+h/2).
     
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dWHCenter: public a2dWH
{
    A2D_DECLARE_EVENT_TABLE()

public:
    //!default constructor
    a2dWHCenter();

    //!standard constructor
    /*!
    \param xc: x center
    \param yc: y center
    \param w: Width (double radius) of object.
    \param h: Heigth (double radius) of object
    */
    a2dWHCenter( double xc, double yc, double w, double h);

    //!destructor
    ~a2dWHCenter();

    //!copy constructor
    a2dWHCenter( const a2dWHCenter& other, CloneOptions options );

    //! This is here so that this class cannot be used directly
    virtual a2dObject* Clone( CloneOptions options ) const = 0;

    DECLARE_CLASS(a2dWHCenter)

public:

    static a2dPropertyIdDouble* PROPID_Width;
    static a2dPropertyIdDouble* PROPID_Height; 

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dWHCenter( const a2dWHCenter& other );
};

//! a2dRect
/*!
   Rectangle with radius 
     
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dRect: public a2dWH
{

    A2D_DECLARE_EVENT_TABLE()

public:

    a2dRect();

    //!constructor
    /*!
    \param x: x minimum
    \param y: y minimum
    \param w: Width of rectangle.
    \param h: Heigth of rectangle
    \param radius Radius at corners (negatif inwards positif outwards).
    \param contourwidth contour around rectangle.
    */
    a2dRect( double x, double y, double w, double h , double radius=0, double contourwidth = 0 );

    //!constructor
    /*!
    \param p1 one point of rectangle
    \param p2 second point on diagonal
    \param radius Radius at corners (negatif inwards positif outwards).
    \param contourwidth contour around rectangle.
    */
    a2dRect( const a2dPoint2D& p1,  const a2dPoint2D& p2, double radius=0, double contourwidth = 0 );

    //!constructor
    /*!
    \param bbox used for size of rectangle
    \param radius Radius at corners (negatif inwards positif outwards).
    \param contourwidth contour around rectangle.
    */
    a2dRect( const a2dBoundingBox& bbox, double radius=0, double contourwidth = 0 );

    a2dRect( const a2dRect& rec, CloneOptions options );

    ~a2dRect();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //!set the Contour width of the shape
    void SetContourWidth(double width) { m_contourwidth = width; SetPending(true); }

    //!get the Contour width of the shape
    double GetContourWidth() const { return m_contourwidth; }

    //!set corner radius of rectangle
    /*!
        \param radius  rounded corner radius of rectangle
    */
    void    SetRadius( double radius ) { m_radius = radius; SetPending(true); }

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

    //! GDSII compatible to sub identify types of rectangles.
    /*! you can use it as a special tagged rectangle */
    void SetBoxType( int type ) { m_boxtype = type; }

    //! GDSII compatible to sub identify types of rectangles.
    /*! you can use it as a special tagged rectangle */
    int GetBoxType() const { return m_boxtype; }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    a2dVertexList* GetAsPolygon();

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    bool GeneratePins( a2dPinClass* toConnectTo, a2dConnectTask task, double x, double y  );

    void OnHandleEvent(a2dHandleMouseEvent &event);

    DECLARE_DYNAMIC_CLASS(a2dRect)

protected:

    virtual void EditFeedback( a2dIterC& ic, const a2dFeedbackId *id, a2dCanvasObject *currentEdit=0, int depth=INT_MAX, a2dCanvasObjectFlagsMask flags=0, double x=0, double y=0 );

    virtual bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;

    //! GDSII compatible to sub identify types of rectangles.
    int m_boxtype;

    //!radius in case of rounded rectangle  (negatif inwards positif outwards)
    double m_radius;

    //! if != 0 you get a contour around the rectangle ( donut like ).
    double m_contourwidth;

public:

    static a2dPropertyIdDouble* PROPID_Radius;

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dRect( const a2dRect &other );
};

//! a2dCircle at x,y, and with radius
/*!
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dCircle: public a2dCanvasObject
{
public:
    a2dCircle( const a2dCircle& ori, CloneOptions options );

    a2dCircle();

    //! constructor
    /*!
        \param x center X
        \param y center Y
        \param radius radius of circle
        \param width contour width
    */
    a2dCircle( double x, double y, double radius, double width = 0 );

    //! destructor
    ~a2dCircle();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //!set radius
    /*!
        \remark As side-effect this circle is set pending for redraw
        \param radius radius of circle
    */
    void SetRadius(double radius)        { m_radius = radius; SetPending(true);  }

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

    //!set the Contour width of the shape
    void SetContourWidth(double width) { m_contourwidth = width; SetPending(true); }

    //!get the Contour width of the shape
    double GetContourWidth() const { return m_contourwidth; }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    a2dVertexList* GetAsPolygon();

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    bool GeneratePins( a2dPinClass* toConnectTo, a2dConnectTask task, double x, double y );

    DECLARE_DYNAMIC_CLASS(a2dCircle)

protected:

    virtual bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    //!radius of circle
    double m_radius;

    //! if != 0 you get a donut
    double m_contourwidth;

public:

    static a2dPropertyIdDouble* PROPID_Radius;

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dCircle( const a2dCircle &other );
};

//! a2dEllipse  centered at x,y.
/*!
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dEllipse: public a2dWHCenter
{
public:

    a2dEllipse();

    //! constructor for ellipse
    /*!
        \param xc x center
        \param yc y center
        \param width Width of ellipse.
        \param height Heigth of ellipse.
        \param contourwidth contour around rectangle.
    */
    a2dEllipse( double xc, double yc, double width, double height, double contourwidth = 0 );
    a2dEllipse( const a2dEllipse& ori, CloneOptions options );
    ~a2dEllipse();

    virtual a2dObject* Clone( CloneOptions options ) const;

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    a2dVertexList* GetAsPolygon();

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    //!set the Contour width of the shape
    void SetContourWidth(double width) { m_contourwidth = width; SetPending(true); }

    //!get the Contour width of the shape
    double GetContourWidth() const { return m_contourwidth; }

    bool GeneratePins( a2dPinClass* toConnectTo, a2dConnectTask task, double x, double y );

    DECLARE_DYNAMIC_CLASS(a2dEllipse)

protected:

    virtual bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dEllipse( const a2dEllipse &other );

    //! if != 0 you get a contour around the rectangle ( donut like ).
    double m_contourwidth;

};

//! a2dEllipticArc centered at x,y
/*!
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dEllipticArc: public a2dWHCenter
{
    A2D_DECLARE_EVENT_TABLE()

public:

    //! constructor
    a2dEllipticArc();

    //! Constructor.
    /*!
        \param xc: x center
        \param yc: y center
        \param width: Width of Arc
        \param height: Heigth of Arc
        \param start: Start Angle degrees
        \param end: End Angle in degrees
        \param chord if true only show outline.
        \param contourwidth to give a width to the cord
    */
    a2dEllipticArc( double xc, double yc, double width, double height, double start, double end, bool chord = false, double contourwidth = 0 );

    //! constructor for cloning
    a2dEllipticArc( const a2dEllipticArc& ori, CloneOptions options );

    //! destructor
    ~a2dEllipticArc();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //!set start angle
    /*!
        \remark As side-effect the ellipse is set pending for redraw
        \param start start angle in degrees
    */
    void SetStart(double start) { m_start = start; SetPending(true); }

    //!return start angle
    double  GetStart() { return m_start; }

    //!set end angle
    /*!
        \remark As side-effect the ellipse is set pending for redraw
        \param end end angle in degrees
    */
    void SetEnd(double end) { m_end = end; SetPending(true); }

    //!return end angle
    double GetEnd() { return m_end; }

    //! if true draw as a chord ( no fill end no lines to center )
    void SetChord( bool chord );

    //! get chord setting
    bool GetChord() { return m_chord; }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    a2dVertexList* GetAsPolygon();

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    //!set the Contour width of the shape
    void SetContourWidth(double width) { m_contourwidth = width; SetPending(true); }

    //!get the Contour width of the shape
    double GetContourWidth() const { return m_contourwidth; }

    DECLARE_DYNAMIC_CLASS(a2dEllipticArc)

protected:

    virtual bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );

    void OnChar(wxKeyEvent& event);

    void OnHandleEvent(a2dHandleMouseEvent &event);

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    //! drawn as a chord ( no fill end no lines to center )
    bool   m_chord;

    //! start angle
    double m_start;

    //! end angle
    double m_end;

    //! if != 0 you get a contour around the rectangle ( donut like ).
    double m_contourwidth;

public:

    static a2dPropertyIdDouble* PROPID_StartAngle; 
    static a2dPropertyIdDouble* PROPID_EndAngle; 
    static a2dPropertyIdBool* PROPID_Chord; 

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dEllipticArc( const a2dEllipticArc &other );
};

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DCANVASDLLEXP a2dSmrtPtr<a2dEllipticArc>;
#endif 

//! a2dArc centered at x,y
/*!
     The Arc is defined by three vertexes, one for the center and two for the start and end point of
     the arc.
     The arc is drawn in an anticlockwise direction from the start point to the end point when Y axis is down
     else clockwise direction.


     \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dArc: public a2dCanvasObject
{
    A2D_DECLARE_EVENT_TABLE()

public:

    //! constructor
    a2dArc();

    //!constructor
    /*!
        \param xc x center
        \param yc y center
        \param radius radius of the Arc.
        \param start Start Angle .
        \param end End Angle .
        \param chord When only the arc contour is shown, not the lines to the center and no fill.
        \param contourwidth to give a width to the cord

        \remark The angles are transfered to x,y positions only once.
     */
    a2dArc( double xc, double yc, double radius, double start, double end, bool chord = false, double contourwidth = 0 );

    //!constructor
    /*!
        \param x1 x1 used for starting angle and radius
        \param y1 y1 used for starting angle and radius
        \param x2 x2 used for end angle
        \param y2 y2 used for end angle
        \param xc x center
        \param yc y center
        \param chord When only the arc contour is shown, not the lines to the center and no fill.
        \param contourwidth to give a width to the cord
     */
    a2dArc( double x1, double y1, double x2, double y2, double xc, double yc, bool chord = false, double contourwidth = 0 );

    //! copy constructor
    a2dArc( const a2dArc& ori, CloneOptions options );

    //! destructor
    ~a2dArc();

    //! Get X1 of arc being begin point of arc
    double GetX1() const { return m_x1; }
    //! Get Y1 of arc being begin point of arc
    double GetY1() const { return m_y1; }
    //! Get X2 of arc being end point of arc
    double GetX2() const { return m_x2; }
    //! Get Y2 of arc being end point of arc
    double GetY2() const{ return m_y2; }
    //! Get the start angle (calculated form x1/y1)
    double GetStartAngle() const;
    //! Get the end angle (calculated form x2/y2)
    double GetEndAngle() const;

    //! get point in between begin and end
    a2dPoint2D GetMidPoint() const;
    
    //! Set X1 of arc being begin point of arc
    void SetX1( double x1 ) { m_x1 = x1; SetPending(true); }
    //! Set Y1 of arc being begin point of arc
    void SetY1( double y1 ) { m_y1 = y1; SetPending(true); }
    //! Set X2 of arc being end point of arc
    void SetX2( double x2 ) { m_x2 = x2; SetPending(true); }
    //! Set Y2 of arc being end point of arc
    void SetY2( double y2 ) { m_y2 = y2; SetPending(true); }
    //! Set the start angle (actually sets x1/y1)
    void SetStartAngle( double a );
    //! Set the end angle (actually sets x2/y2)
    void SetEndAngle( double a );

    //! set arc using begin, end and middle point.
    void Set( double xs, double ys,  double xm, double ym, double xe, double ye );

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! set radius of the Arc
    void SetRadius( double radius );

    //! get radius of the Arc
    double GetRadius() const;

    //! if true draw as a chord ( no fill end no lines to center )
    void SetChord( bool chord );

    //! get chord setting
    bool GetChord() const { return m_chord; }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    //! convert to a polygon and return the vertexlist.
    a2dVertexList* GetAsPolygon();

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    void SetContourWidth(double width) { m_contourwidth = width; SetPending(true); }

    //!get the Contour width of the shape
    double GetContourWidth() const { return m_contourwidth; }

    DECLARE_DYNAMIC_CLASS(a2dArc)

protected:

    virtual bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );

    void OnChar(wxKeyEvent& event);

    void OnHandleEvent(a2dHandleMouseEvent &event);

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    //! drawn as a chord ( no fill end no lines to center )
    bool   m_chord;

    //! x of begin point
    double m_x1;
    //! y of begin point
    double m_y1;

    //! x of end point
    double m_x2;

    //! y of end point
    double m_y2;

    //! if != 0 the line is contoured at distance m_contourwidth/2
    double m_contourwidth;

public:

    //! property for class member
    static a2dPropertyIdDouble* PROPID_X1;
    //! property for class member
    static a2dPropertyIdDouble* PROPID_X2; 
    //! property for class member
    static a2dPropertyIdDouble* PROPID_Y1; 
    //! property for class member
    static a2dPropertyIdDouble* PROPID_Y2; 
    //! property for class member
    static a2dPropertyIdBool* PROPID_Chord; 
    //! property for class member
    static a2dPropertyIdDouble* PROPID_StartAngle; 
    //! property for class member
    static a2dPropertyIdDouble* PROPID_EndAngle; 

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dArc( const a2dArc &other );
};

//! a2dSLine
/*!
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dSLine: public a2dCanvasObject
{
    A2D_DECLARE_EVENT_TABLE()

public:

    a2dSLine();

    //!constructor
    /*!
        \param x1 x line start
        \param y1 y line start
        \param x2 x line end
        \param y2 y line end
        \param contourwidth to give the line a width
     */
    a2dSLine( double x1, double y1, double x2, double y2, double contourwidth = 0 );

    //! constructor
    a2dSLine( const a2dSLine& ori, CloneOptions options );


    //! destructor
    ~a2dSLine();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! Get (transformed) position of X1
    /*!
        \param transform if true return x transformed with local matrix
    */
    double  GetPosX1( bool transform = true ) const;

    //! Get (transformed) position of Y1
    /*!
        \param transform if true return y transformed with local matrix
    */
    double  GetPosY1( bool transform = true ) const;

    //! Get (transformed) position of X2
    /*!
        \param transform if true return x transformed with local matrix
    */
    double  GetPosX2( bool transform = true ) const;

    //! Get (transformed) position of Y2
    /*!
        \param transform if true return y transformed with local matrix
    */
    double  GetPosY2( bool transform = true ) const;

    //! Returns length of line
    /*!
        \return line length
    */
    double GetLength() const;

    //! reduce matrix to identity without replacing object
    bool EliminateMatrix();

    //! sets position of first point
    /*!
        \param x new x for the first point
        \param y new y for the first point
        \param afterinversion if true the input x,y or first inverted with the local matrix of the object.
        The inverted values are used to set the point.

        \remark afterinversion = true should be used if you have x,y relative to the line object,
        while afterinversion = false should be used when x,y are relative to the point in the line
    */
    void    SetPosXY1( double x, double y, bool afterinversion = true );

    //! sets position of second point
    /*!
        \param x new x for the second point
        \param y new y for the second point
        \param afterinversion if true the input x,y or first inverted with the local matrix of the object.
        The inverted values are used to set the point.

        \remark afterinversion = true should be used if you have x,y relative to the line object,
        while afterinversion = false should be used when x,y are relative to the point in the line
    */
    void    SetPosXY2( double x, double y, bool afterinversion = true );

    //! sets both positions of line
    /*!
        \param x1 new x for the first point
        \param y1 new y for the first point
        \param x2 new x for the second point
        \param y2 new y for the second point
        \param afterinversion if true the input x,y or first inverted with the local matrix of the object.
        The inverted values are used to set the point.

        \remark afterinversion = true should be used if you have x,y relative to the line object,
        while afterinversion = false should be used when x,y are relative to the point in the line
    */
    void    SetPosXY12( double x1, double y1, double x2, double y2, bool afterinversion = true );

    //! dummies to be compatible with a2dEndsLine
    virtual void SetBegin(a2dCanvasObject *WXUNUSED(begin)) {}
    //! dummies to be compatible with a2dEndsLine
    virtual void SetEnd(a2dCanvasObject *WXUNUSED(end)) {}

    //! dummies to be compatible with a2dEndsLine
    virtual a2dCanvasObject* GetBegin() { return NULL; }

    //! dummies to be compatible with a2dEndsLine
    virtual a2dCanvasObject* GetEnd() { return NULL; }

    //! dummies to be compatible with a2dEndsLine
    virtual void SetEndScaleX(double WXUNUSED(xs)) {}
    //! dummies to be compatible with a2dEndsLine
    virtual void SetEndScaleY(double WXUNUSED(ys)) {}

    //! dummies to be compatible with a2dEndsLine
    double GetEndScaleX(){ return 1; }
    //! dummies to be compatible with a2dEndsLine
    double GetEndScaleY(){ return 1; }

    //! set a contour width
    void SetContourWidth(double width) { m_contourwidth = width; SetPending(true); }

    //!get the Contour width of the shape
    double GetContourWidth() const { return m_contourwidth; }

    //! 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; }

    a2dCanvasObjectList* GetAsCanvasVpaths( bool transform = true );

    bool RestrictToObject( a2dRestrictionEngine* engine, a2dSnapToWhatMask snapToWhat );

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    DECLARE_DYNAMIC_CLASS(a2dSLine)

protected:

    virtual bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );

    void OnChar(wxKeyEvent& event);

    void OnHandleEvent(a2dHandleMouseEvent &event);

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;

    //! start x
    double m_x1;
    //! start y
    double m_y1;
    //! end x
    double m_x2;
    //! end y
    double m_y2;

    //! if != 0 the line is contoured at distance m_contourwidth/2
    double m_contourwidth;

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

public:
    static a2dPropertyIdDouble* PROPID_X1;
    static a2dPropertyIdDouble* PROPID_X2; 
    static a2dPropertyIdDouble* PROPID_Y1; 
    static a2dPropertyIdDouble* PROPID_Y2; 

    DECLARE_PROPERTIES()

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dSLine( const a2dSLine &other );
};

//! a2dEndsLine with begin and/or end object.
/*!
     \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dEndsLine: public a2dSLine
{
public:

    a2dEndsLine();

    //!constructor
    /*!
        \param x1: x line start
        \param y1: y line start
        \param x2: x line end
        \param y2: y line end
     */
    a2dEndsLine( double x1, double y1, double x2, double y2, double contourwidth = 0 );


    //! constructor using a a2dEndsLine as input
    a2dEndsLine( const a2dEndsLine& ori, CloneOptions options );

    //! constructor using a a2dSLine as input (end and begin are set to NULL )
    a2dEndsLine( const a2dSLine& ori, CloneOptions options );

    ~a2dEndsLine();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! set object to draw as begin point
    void SetBegin(a2dCanvasObject* begin);

    a2dCanvasObject* GetBegin() { return m_begin; }

    //! set object to draw as end point
    void SetEnd(a2dCanvasObject* end);

    a2dCanvasObject* GetEnd() { return m_end; }

    //! Scale begin and end object with this factor in X
    /*!
        \remark As side-effect this object is set pending for redraw
    */
    void SetEndScaleX(double xs){ m_xscale=xs; SetPending(true); }

    double GetEndScaleX(){ return m_xscale; }

    //! Scale begin and end object with this factor in Y
    /*!
        \remark As side-effect this object is set pending for redraw
    */
    void SetEndScaleY(double ys){ m_yscale=ys; SetPending(true); }

    double GetEndScaleY(){ return m_yscale; }

    //! if set take style changes on line to the arrow objects
    void SetStyleToArrow( bool takeStyleToArrow ) { m_takeStyleToArrow = takeStyleToArrow; }
    //! if true take style changes on line to the arrow objects
    bool GetStyleToArrow() { return m_takeStyleToArrow; }

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    virtual void DoWalker( wxObject* parent, a2dWalkerIOHandler& handler );

    DECLARE_DYNAMIC_CLASS(a2dEndsLine)

protected:

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    //! object drawn at begin point
    a2dCanvasObjectPtr m_begin;

    //! object drawn at end point
    a2dCanvasObjectPtr m_end;

    //!scale begin and end object with this factor in X
    double m_xscale;

    //!scale begin and end object with this factor in Y
    double m_yscale;

    //! if set take style changes on line to the arrow objects
    bool m_takeStyleToArrow;

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dEndsLine( const a2dEndsLine &other );
};


//! a2dScaledEndLine
/*!
    The begin and end object on the line are scaled to the contour width.
    In case of a a2dArrow derived object, rendering is optimized to look good.
    All types of end objects are scalled up m_contourwidth.
    If m_contourwidth is zero, there will be no endpoints drawn.

    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dScaledEndLine: public a2dEndsLine
{
    A2D_DECLARE_EVENT_TABLE()

public:

    a2dScaledEndLine();

    //!constructor
    /*!
        \param x1 x line start
        \param y1 y line start
        \param x2 x line end
        \param y2 y line end
        \param contourwidth to give the line a width
     */
    a2dScaledEndLine( double x1, double y1, double x2, double y2, double contourwidth = 0 );

    //! constructor using a a2dEndsLine as input
    a2dScaledEndLine( const a2dScaledEndLine& ori, CloneOptions options );

    //! constructor
    a2dScaledEndLine( const a2dSLine& ori, CloneOptions options );

    //! destructor
    ~a2dScaledEndLine();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! set begin shape factors if it is a2dArrow derived
    void SetBegin( double l1, double l2, double b, bool spline = false ); 
    //! set end shape factors if it is a2dArrow derived
    void SetEnd( double l1, double l2, double b, bool spline = false ); 

    DECLARE_DYNAMIC_CLASS(a2dScaledEndLine)

protected:

    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    void DoRender( a2dIterC& ic, OVERLAP clipparent );

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dScaledEndLine( const a2dScaledEndLine &other );
};

//! a2dEndsEllipticChord with begin and/or end object.
/*!
     \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dEndsEllipticChord: public a2dEllipticArc
{
public:

    //! constructor
    a2dEndsEllipticChord();

    //!constructor
    /*!
        \param xc x cord start
        \param yc y cord start
        \param width width of cord
        \param height height of cord
        \param start start angle
        \param end end angle
     */
    a2dEndsEllipticChord( double xc, double yc, double width, double height, double start, double end );


    //! constructor using a a2dEndsEllipticChord as input
    a2dEndsEllipticChord( const a2dEndsEllipticChord& ori, CloneOptions options );

    //! destructor
    ~a2dEndsEllipticChord();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! set object to draw as begin point
    void SetBeginObj(a2dCanvasObject* begin);

    //! return begin object
    a2dCanvasObject* GetBeginObj() { return m_beginobj; }

    //! set object to draw as end point
    void SetEndObj(a2dCanvasObject* endob);

    //! return end object
    a2dCanvasObject* GetEndObj() { return m_endobj; }

    //! Scale begin and end object with this factor in X
    /*!
        \remark As side-effect this object is set pending for redraw
    */
    void SetEndScaleX(double xs){ m_xscale=xs; SetPending(true); }

    //! see SetEndScaleX()
    double GetEndScaleX(){ return m_xscale; }

    //! Scale begin and end object with this factor in Y
    /*!
        \remark As side-effect this object is set pending for redraw
    */
    void SetEndScaleY(double ys){ m_yscale=ys; SetPending(true); }

    //! see SetEndScaleY()
    double GetEndScaleY(){ return m_yscale; }

    void DoWalker( wxObject *parent, a2dWalkerIOHandler& handler );

#if wxART2D_USE_CVGIO
    virtual void DoSave( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dXmlSer_flag xmlparts , a2dObjectList* towrite );

    void DoLoad( wxObject* parent, a2dIOHandlerXmlSerIn& parser, a2dXmlSer_flag xmlparts );
#endif //wxART2D_USE_CVGIO

    DECLARE_DYNAMIC_CLASS(a2dEndsEllipticChord)

protected:

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    a2dBoundingBox DoGetUnTransformedBbox( a2dBboxFlags flags = a2dCANOBJ_BBOX_NON ) const;
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    //! Get the coordinate transform for the begin object
    a2dAffineMatrix GetBeginTransform() const;
    //! Get the coordinate transform for the end object
    a2dAffineMatrix GetEndTransform() const;

    //! object drawn at begin point
    a2dCanvasObjectPtr m_beginobj;

    //! object drawn at end point
    a2dCanvasObjectPtr m_endobj;

    //!scale begin and end object with this factor in X
    double m_xscale;

    //!scale begin and end object with this factor in Y
    double m_yscale;
public:

private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dEndsEllipticChord( const a2dEndsEllipticChord &other );
};

//! a2dControl captures a wxWindow inside
/*!
    \ingroup canvasobject
*/
class A2DCANVASDLLEXP a2dControl: public a2dRect
{
public:

    //! constructor
    /*!
        \param x: x left top
        \param y: y left top
        \param width: width of the control drawing
        \param height: height of the control drawing
        \param control pointer to wxWindow derived control
    */ 
    a2dControl( double x, double y, double width, double height, wxWindow *control );
    //! constructor
    a2dControl( const a2dControl& ori, CloneOptions options );
    //! destructor
    ~a2dControl();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! Get control pointer
    wxWindow* GetControl(){return m_control;}

    DECLARE_CLASS(a2dControl)

protected:

    virtual bool DoStartEdit( wxUint16 editmode, wxEditStyle editstyle );

    virtual void DoEndEdit();

    void DoRender( a2dIterC& ic, OVERLAP clipparent );
    bool DoIsHitWorld( a2dIterC& ic, a2dHitEvent& hitEvent );
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );

    //! control with a a2dCanvas as parent. 
    wxWindow     *m_control;

private:

    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dControl( const a2dControl &other );
};


//! a2dWires is used to generate wires to Connect other a2dCanvasObject's
/*!
 a2dWires is not just one wire, but a set of wires. 
 This is done by taking the position of the pins of the conncted a2dCanvasObject's,
 and based on that generate the wires.
 When Connected Objects are moved and the wire set is not frozen,
 The wires will automatically be resized to keep the objects connected via the wire set.

 \ingroup canvasobject
 \sa a2dWirePolylineL
*/
class A2DCANVASDLLEXP a2dWires: public a2dCanvasObject
{
public:

    //! constructor
    a2dWires();

    //! constructor
    a2dWires( a2dCanvasObject* toconnect, const wxString& pinname );

    //! constructor
    a2dWires( a2dCanvasObject* toconnect, a2dPin* pinc );

    //! destructor
    ~a2dWires();

    virtual a2dObject* Clone( CloneOptions options ) const;

    //! type of wire
    virtual bool IsConnect() const;

    bool NeedsUpdateWhenConnected() const { return !m_frozen; }

    bool ConnectWith(  a2dCanvasObject* parent, a2dCanvasObject* graph, const wxString& pinname, double margin = 1, bool undo = false );

    bool ConnectWith(  a2dCanvasObject* parent, a2dPin* pin, double margin = 1, bool undo = false );

    bool GetFrozen() { return m_frozen; }
    void SetFrozen( bool freeze ) { m_frozen = freeze; }

    DECLARE_CLASS(a2dWires)

protected:

    virtual void CreateWires();
    bool DoUpdate( UpdateMode mode, const a2dBoundingBox& childbox, const a2dBoundingBox& clipbox, const a2dBoundingBox& propbox );
    void DoRender( a2dIterC& ic, OVERLAP clipparent );

    //!are the wires frozen (means will not resize)
    bool m_frozen;
};

#endif /* __WXCANPRIM_H__ */

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