candoc.h

Go to the documentation of this file.

/*! \file wx/canvas/candoc.h
    \brief Contains a2dCanvasDocument Class to hold a drawing.

    a2dCanvasDocument is the class where a hierarchy of a2dCanvasObject's is stored.
    Updating pending/changed objects and drawing a document is all from this class.

    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: candoc.h,v 1.31 2009/07/10 19:23:13 titato Exp $
*/

#ifndef __WXCANDOC_H__
#define __WXCANDOC_H__

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

#include "wx/image.h"
#include "wx/txtstrm.h"

#include "a2dprivate.h"

#include "wx/canvas/canobj.h"
#include "wx/canvas/vpath.h"
#include "wx/canvas/canprim.h"
#include "wx/canvas/polygon.h"
#include "wx/canvas/objlist.h"
#include "wx/canvas/recur.h"

#include "wx/canvas/canprop.h"

#if wxART2D_USE_SVGIO
#include "wx/svgio/parssvg.h"
#endif //wxART2D_USE_SVGIO

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

#include "wx/docview/docviewref.h"

class a2dCanvasCommandProcessor;
class a2dIOHandlerCVGIn;
class a2dIOHandlerCVGOut;

#include "wx/canvas/drawer.h"

//----------------------------------------------------------------------------
// decls
//----------------------------------------------------------------------------

//!Each a2dCanvasView needs to have a a2dCanvasDocument set in order to render data.
/*!
    Several a2dCanvasView objects can share the same a2dCanvasDocument.
    The a2dCanvasDocument has one top a2dCanvasObject, called m_rootobject.
    All other a2dCanvasObject's are added as children to this root object. 
    The docuemnt also contains the layer settings for the canvas objects to be rendered. 
    The a2dCanvasDocument is derived from a2dDocument, and it is used to store a hierarchy of a2dCanvasObject's.
    The updating of modified a2dCanvasObject's is also organized as part of this class. One can load a canvas document from
    a file, and save it to a file, in the CVG format. But other formats are possible, via the document its a2dDocumentTemplate and 
    associated a2dIOHandlers. 

    Rendering a a2dCanvasDocument is started at a given a2dCanvasObject,
    which needs to be part of the data structure below the a2dCanvasDocument.
    Since a2dCanvasDocument owns a a2dCanvasObject as root, rendering the complete document will start at the m_rootobject.
    But any nested child a2dCanvasObject can be used to start rendering, and only that object and it children will be displayed
    on the a2dCanvasView ( and a2dCanvas which is the display window ).
    The a2dCanvasObject to be displayed on a certain a2dCanvasView is maintained in the
    a2dCanvasView object. It can be different for all a2dCanvasView objects sharing the same a2dCanvasDocument.

    a2dCanvasDocument senets update events when a2dCanvasObject have changed internal. The a2dView's using the document
    are intercepting the update events, and react by updating the data that they display. For a a2dCanvasView this means
    redrawing those parts that have changed.

    Any nested child from a a2dCanvasDocument Object can be displayed on several a2dCanvasView Objects at the same time.
    The child displayed does not have to be the same on each a2dCanvasView.
    The active a2dCanvasView is used to render and convert coordinates from world to device.
    So it is important to set the active a2dCanvasView based on the a2dCanvasView that has the focus
    or is scrolled etc. This is normally done within a2dCanvasView when appropriate.


    \remark Use a2dDocumentTemplate's to get the type of the file, where this data was read from.
            based on this the document can be saved in the same type as read from.

\sa a2dCanvasView
\sa a2dCanvas
\sa wxWorldCanvas
\sa a2dCanvasObject

    \ingroup docview canvasobject
*/
class A2DCANVASDLLEXP a2dCanvasDocument : public a2dDocument
{
public:

    //!Construct a  a2dCanvasDocument to store a complete drawing in
    /*!
        This class contains nested a2dCanvasObject's and other drawing object derived from a2dCanvasObject's.
        The class itself is derived from a2dDocument.
        All objects are stored are as childs of the m_rootobject.
        A complete drawing is stored here, and displaying the drawing, is done by setting a pointer to this a2dCanvasDocument
        for a a2dCanvasView derived class.
        Every change inside the wxCavasObject's stored inside this class, will report themselfs as pending to an instance
        of this class.
        The a2dCanvasView classes, having this instance of a2dCanvasDocument set, will be updated from the document via update events.
        a2dCanvasObject that are changed or set pending. Those pending objects are reported to the document also. In Idle time the pending
        objects are redrawn on the a2dCanvasView's that display the document. 
        The same a2dCanvasDocument can be displayed on reveral a2dCanvasView's at the same time.
        And therefore a pending a2dCanvasObject maybe be (re)displayed on several a2dCanvasView's also.
        The a2dCanvasObjects stored in a a2dCanvasDocument, will have their m_root member set in order to get to the a2dCanvasDocument
        in which they are stored. Through the a2dCanvasDocument they will be able to reach the a2dCanvasView class that is currently active.
        The a2dCanvasView class is set to the document when needed on a higher level. e.g. when rendering a a2dCanvasDocument.
        This way each a2dCanvasObject stored inside the a2dCanvasDocument, can draw itself on the active a2dCanvasView.
        The a2dCanvasView in this case can be seen as a sort of drawing context.
        Indirectly a a2dCanvasView can use a2dCanvas as the window/device to draw up on.
        Another type of a2dCanvasView can draw to a bitmap, image or printer device.
        
        \remark The initially layer setup is defined my a2dCanvasGlobal::GetLayerSetup
        
        \see SetLayerSetup for an example for introduce your own layers
    */
    a2dCanvasDocument();

    //! destructor
    ~a2dCanvasDocument();

    //! like it to be protected, but this does not work with wxList macros
    //void operator delete(void* recordptr);
    
    //! constructor with other document
    a2dCanvasDocument( const a2dCanvasDocument &other );

    //! create exact copy
    virtual a2dObject* Clone( CloneOptions options ) const;

    //! get the root object, which holds the objects in the document.
    inline a2dCanvasObject* GetRootObject() const { return m_rootobject; }

    //! set new root object ( may not ne NULL )
    void SetRootObject( a2dCanvasObject* newRoot );

    //! get bounding box of document its minimum X
    double  GetBboxMinX()     { return m_rootobject->GetBboxMinX(); }

    //! get bounding box of document its minimum Y
    double  GetBboxMinY()     { return m_rootobject->GetBboxMinY(); }

    //! get bounding box of document its maximum X
    double  GetBboxMaxX()     { return m_rootobject->GetBboxMaxX(); }

    //! get bounding box of document its maximum Y
    double  GetBboxMaxY()     { return m_rootobject->GetBboxMaxY(); }

    //! get bounding box of document its width
    double  GetBboxWidth()    { return m_rootobject->GetBboxWidth(); }

    //! get bounding box of document its height
    double  GetBboxHeight()   { return m_rootobject->GetBboxHeight(); }

    //! get bounding box of document
    a2dBoundingBox&  GetBbox() { return m_rootobject->GetBbox(); }

    //!add at begin an object the root group
    void Prepend( a2dCanvasObject* obj ) { m_rootobject->Prepend( obj ); }

    //!add at end an object the root group
    void Append( a2dCanvasObject* obj )  { m_rootobject->Append( obj ); }

    //!insert object at a position in the root group
    void Insert( size_t before, a2dCanvasObject* obj ) { m_rootobject->Insert( before, obj ); }

    //! release a specific object from the rootobject
    /*!
        \param obj object to release
        \param backwards start at the end 
        \param all if true remove all references to object

        \return number of released objects
    */
    int ReleaseChild( a2dCanvasObject* obj, bool backwards = false, bool all = true )  { return m_rootobject->ReleaseChild( obj, backwards, all ); }

    //!removes and release only from the childobjects the objects with the given mask
    /*!
        \return true if some object were released
    */
    bool ReleaseChildObjects( a2dCanvasObjectFlagsMask mask = a2dCanvasOFlags::ALL ) { return m_rootobject->ReleaseChildObjects( mask ); }

    //!set all bit flags in object that or true in mask to true or false
    /*!
        set specific flags to true or false, also recursive for children objects

        \remark the object is not setpending when soemthing changed ( actually the pending flag can be set here also ) 

        \param setOrClear if true sets the flag to true else to false
        \param which set only those flags in object to true or false
        \param classname if not empty, object must have this classname
        \param whichobjects set flags only for object having this flags set already
    */
    void SetSpecificFlags( bool setOrClear, a2dCanvasObjectFlagsMask which, const wxString& classname = wxT(""), a2dCanvasObjectFlagsMask whichobjects = a2dCanvasOFlags::ALL );

    //!return the object if it is part of the given object or
    /*! if the given object is part of a childobjects within this object.
        For child objects this means recursively search for it.
        \param obj object to search for
    */
    a2dCanvasObject* Find( a2dCanvasObject* obj );

    //!return the object with (name, classname, id) if it is part of the given object or
    /*! if the given object is part of a recursive childobject within this object.
        For child objects this means recursively search for it.

        \param objectname object with this name to search for. Empty string means ignore this.
        \param classname object must have this classname. Empty string means ignore this.
        \param id if a id is given, the object must have with this id ( address as wxInt64 )
    */
    a2dCanvasObject* Find( const wxString& objectname,  const wxString& classname = wxT(""), wxInt64 id = -1 );

    //! Sets a description of the document
    /*!
        A description may describe the content of this document or contain keywords etc.
        The default value is "a2dCanvasDocument generated by wxArt2D".
        
        \param desc description of the document
    */
    void SetDescription( const wxString& desc ) { m_description = desc; }

    //! Returns the description of the document
    /*!
        \see SetDescription
    
        \return the description
    */
    wxString& GetDescription() { return m_description; }

    //! to name the document as a library (independent of a path and filename )
    void SetLibraryName( const wxString& libraryname ) { m_libraryname = libraryname; }

    //! Get name the document as a library (independent of a path and filename )
    wxString& GetLibraryName() { return m_libraryname; }

    //! set version of library or document
    void SetVersion( int version ) { m_version = version; }

    //! get version of library or document
    int GetVersion() { return m_version; }

    //! delete all object in this document (also nested groups etc.)
    virtual void DeleteContents();

    //! get a pointer to the command processor
    a2dCanvasCommandProcessor* GetCanvasCommandProcessor();

    //! create the commandprocessor (special designed to work with a2dCanvas code)
    void CreateCommandProcessor();

    //!adds current and future boundingbox of the objects with pending flag set, to the pendinglist of all a2dCanvasView's
    /*!
        which are using this document.
        The areas will only be updated from the a2dCanvasView's, which are using this document in idle time.
        It first check's for pending object's stored in this a2dCanvasDocument.
        If true, it searches those object starting from the displayed showgroup in each drawer, and adds
        the boundingbox of the current state the object is in, to the update area list of the those a2dCanvasView's
        If the boundingbox of an object is not available, it will be calcualted at that moment.
        In Next step the new boundingboxes are calculated for the pending objects and those are also
        added to the pending arae list's of all a2dCanvasView's.
        This functions adds areas of all places where this object is rendered also when referenced.
        In the end, the pending flag in all objects is reset.

        AddPendingUpdatesOldNew() makes sure all objects
        that where pending are processed. 

        In idle time a2dCanvasView's will only redraw the areas that are damaged because of changes to canvas objects.

        

        \return if there were pendingobjects it return true
    */
    bool AddPendingUpdatesOldNew();

    //! sent Update events to all a2dView which display or use this document.
    /*!
        Changes in the document are reported by the objects contained in the document,
        after a change, they set the pending flag of the document and itself.
        Here the document lets the a2dView's know how the views should be updated.
        The normal case is Redrawing what is in the old and new boundingbox of each changed object.

        The default Updates all a2dCanvasObjects that are pending and adds a redraw area the size of the view to all views,
        after that the pending object flags are reset. The result is redrawing all a2dCanvasView views in idle time completely.

        \param sender which view did calls this fucntion ( Non = NULL ).
        \param hint will be casted to a2dCanViewUpdateFlags in a2dCanvasView the effect will differ on the hint given.
        \param objecthint more complex way to deliver hints 
    */
    virtual void UpdateAllViews(a2dView *sender = (a2dView *) NULL, unsigned int hint = a2dCANVIEW_UPDATE_ALL, wxObject *objecthint = (wxObject *) NULL);

    //!sets all associated view/drawers to Frozen to prevent all drawer activity
    virtual void Freeze();

    //!sets all associated view/drawers to non Frozen to allow all drawer activity
    virtual void Thaw(bool update);

    //!write as SVG to a file starting at given object
    /*!
        \param drawer    drawing view context  
        \param filename  filename of stream to write the SVG content to.
        \param top       start writting at this object.
        \param Width     width in unit will be the physical width of the drawing.
        \param Height    height in unit will be the physical height of the drawing.
        \param unit      Unit of width and height e.g. "cm" "um".
    */
    bool WriteSVG( a2dCanvasView* drawer, const wxString& filename, a2dCanvasObject* top, double Width, double Height, wxString unit);

    //!load form a file containing the a2dCanvas specific XML called CVG format
    virtual a2dDocumentInputStream& LoadObject( a2dDocumentInputStream& stream, a2dIOHandlerStrIn* handler );

#if wxART2D_USE_CVGIO
    //! used by CVG parser
    /*!
        \remark do not use directly
     */
    void Load( wxObject* parent, a2dIOHandlerXmlSerIn& parser );
#endif //wxART2D_USE_CVGIO

    //! load document from a file with the given filename and given parser type
    bool Load( const wxString& filename, a2dIOHandlerStrIn* handler );

    //! save layer settings to CVG file
    bool SaveLayers( const wxString& filename );

    //! load layers from another file
    /*!
        Only the layer settings are read from the file and put in place of the
        current layers settings in the document.
    */
    bool LoadLayers( const wxString& filename );

    //! Update a loaded layer setup
    /*! This is called after loading a layer setup. The base class function does
        nothing. It is usefull to override this to update a loaded layer setup to
        e.g. a new software version */
    virtual void UpdateLoadedLayerSetup();

    //!save as the a2dCanvas specific XML called CVG format
    a2dDocumentOutputStream& SaveObject( a2dDocumentOutputStream& stream, a2dIOHandlerStrOut* handler );

#if wxART2D_USE_CVGIO
    void Save( wxObject* parent, a2dIOHandlerXmlSerOut &out, a2dObjectList* towrite );

    //! called from a2dIOHandlerCVGOut after a SaveObject.
    /*!
        \param out CVG io handler 
        \param start start wrting from this object   
    */
    void Save( a2dIOHandlerCVGOut &out, a2dCanvasObject* start = 0 );
#endif //wxART2D_USE_CVGIO

    //! save document to a file with the given name and given output writer type
    bool Save( const wxString& filename,  a2dIOHandlerStrOut* handler ) const;

    //!set a2dCanvasDocument recursive for whole tree
    void SetCanvasDocumentRecursive();

    //! update all pending objects in the document
    /*
        At the minumum all boudingboxes are brought up to date, and if a layersetup is set,
        in the end all layers used in the document are known.

        This function is part of the update cycle e.g. in AddPendingUpdatesOldNew()
    */
    void Update( a2dCanvasObject::UpdateMode mode );

    //!set the layersettings for the canvas.
    /*!
        A default Layer Setting is created in the constructor a2dCanvasDocument::a2dCanvasDocument
        
        An example how to set another layer setup
        \code
        // Clone the current layer setup
        a2dLayers* docLayers = doc->GetLayerSetup()->Clone( bool deep = true );
        
        // Create a new layer with an index above the predefined layers
        a2dLayerInfo* lr = new a2dLayerInfo(wxLAYER_USER_FIRST, "MyLayer");
        
        // Set layer available
        lr->Set_Available(true);
        
        // Add layer to to the a2dLayers
        docLayers->Append(lr);
        
        doc->SetLayerSetup(docLayers);
        \endcode
        
        \remark
        You don't have to call Set_UpdateAvailableLayers it will be done automatically
        
        \param layersetup the new layersetup
    */
    void SetLayerSetup( a2dLayers* layersetup );

    //!Get the layersettings for the canvas.
    /*!
        A default Layer Setting is taken from a2dCanvasGlobal.
        \sa a2dCanvasGlobal for central layers settings, used for initializing a a2dCanvasDocument
    */
    a2dLayers* GetLayerSetup() { return m_layersetup; }

    //!Set true if the document read from a file did not have on erootobject but several
    /*!
        Some formats as GDS-II and KEY, can contain many structure, which are not placed in
        a single parent object. Still in a a2dCanvasDocument they will be placed in the m_rootobject.
        This flag can be used when writing the data back in the same way, skipping the rootobject if possible.
    */
    void SetMultiRoot( bool multiRoot = true ) { m_multiRoot = multiRoot; }

    //! \see SetMultiRoot()
    bool GetMultiRoot() { return m_multiRoot; }

    //! Tells the document that an object has changed.
    /*! 
        If an object has changed and and needs an update, this method
        informes the document about this.
        The update of pending objects will be proceed in Idle time.
    */
    void SetUpdatesPending(bool onoff);

    //! call DependencyPending on root object and recursive on childs.
    /*!
        This call is repeated until no more a2dCanvasObject were set pending.
        \sa a2dCanvasObject::DependencyPending
    */
    void DependencyPending();

    //!returns true if some objects have changed recently within this document
    bool GetUpdatesPending();

    //! Switches ignorance of pending objects on and off.
    /*! 
        If set to <code>true</code> pending objects won't be updated.
        This method is used by several tools (i.e. a2dDragTool) to avoid updates
        while the tool is working.

        \see GetUpdatesPending()
    
        \param onoff <code>true</code> to ignore pending objects, else <code>false</code>
    */
    void SetIgnorePendingObjects( bool onoff );

    //!get setting of ignore pending objects /sa GetUpdatesPending()
    bool GetIgnorePendingObjects() { return m_ignorePendingObjects; }

    //!this is the number that defines the number of decimal places in the fraction
    /*!when writing numbers to a file.
       When reading a file, this number is set to the accuracy information available in the file.
       1/GetUnitsAccuracy() == 100 means 2 decimal places will be written, or the data just
       read is accurate to this number of decimal places.

       \remark GetUnitsAccuracy() can also be > 1
    */
    double GetUnitsAccuracy() { return m_units_accuracy; }

    //!this is the number that defines the number of decimal places in the fraction
    /*!when writing numbers to a file.
       When reading a file, this number is set to the accuracy information available in the file.
       1/GetAccuracyUserUnits() == 100 means 2 decimal places will be written, or the data just
       read is accurate to this number of decimal places.
       \remark SetUnitsAccuracy() can also be > 1
    */
    void   SetUnitsAccuracy(double accuracy) { m_units_accuracy = accuracy; }

    //!this is the number that defines the physical dimension in meters / inch/ etc.
    /*! numbers used for storing length or position or always stored as doubles.
        The real dimension is: (anynumber) * GetUnitsScale() * GetUnits()
    */
    double GetUnitsScale() { return m_units_scale; }


    //!this is the number that defines the physical dimension in meters / inch/ etc.
    /*! numbers used for storing length or position or always stored as doubles.
        The real dimension is: (anynumber) * GetUnitsScale() * GetUnits()
    */
    void   SetUnitsScale(double scale) { m_units_scale = scale; }

    //! Normalize objects ( defined in coordinates -1 to 1 ranges ) will be multiplied by this factor.
    /*! 
        Libraries containing object which are defined in normalized coordinates, 
        need to be multiplied by a certain factor before they can be added to a document.
        This factor defines by how much that should be done.
        As an example a libary containing arrow objects for placing at the end of a2dEndsLine 
        objects, will use this factor.
    */
    double GetNormalizeScale() { return m_normalize_scale; }

    //! see GetNormalizeScale()
    void SetNormalizeScale(double scale) { m_normalize_scale = scale; }

    //!this string defines the unit e.g. meters / inch/ etc.
    /*! numbers used for storing length or position or always stored as doubles.
        The real dimension is: (anynumber) * GetUnitsScale() * GetUnits()

        \remark the value may also be "trees" "pixels" or "people"  etc.

        \remark conversion to other units is not just simply changing this string.
        You must Change the SetUnitsScale(double) or really scale the data itself.
    */
    wxString GetUnits() { return m_units; }

    //!this string defines the unit e.g. meters / inch/ etc.
    /*! numbers used for storing length or position or always stored as doubles.
        The real dimension is: (anynumber) * GetUnitsScale() * GetUnits()

        \remark the value may also be "trees" "pixels" or "people" etc.

        \remark conversion to other units is not just simply changing this string.
        You must Change the SetUnitsScale(double) or really scale the data itself.
    */
    void SetUnits( const wxString& unitString ) { m_units = unitString; }

    //! set size for view in userunits, when still empty
    void SetInitialSize( double sizeX, double sizeY )
        { m_initialSizeX = sizeX; m_initialSizeY = sizeY; }

    //! get size for view in userunits, when still empty
    double GetInitialSizeX() { return m_initialSizeX; }

    //! get size for view in userunits, when still empty
    double GetInitialSizeY() { return m_initialSizeY; }

    //! Sets a time of last modification
    /*!
        \param datatime new modification time
    */
    void SetModificationTime( const wxDateTime& datatime ) { m_modificationtime = datatime; }

    //! Returns the time of last modification when the document was saved
    /*!
        \return time of last modification
    */
    wxDateTime& GetModificationTime() { return m_modificationtime; }

    //! Sets the time of last access to this doc.
    /*!
        \param datatime new last access time
    */
    void SetAccessTime( const wxDateTime& datatime ) { m_accesstime = datatime; }

    //! Returns the time of last access.
    wxDateTime& GetAccessTime() { return m_accesstime; }

    //! gives time when a change was made to the document which may effect rendering  
    /*!
        Comparing this time in a dialogs its own update time, one can easily keep them up to date.

        e.g. set in SetUpdatesPending()
    */
    wxDateTime& GetInternalChangedTime() { return m_changedInternalAccesstime; }


    DECLARE_DYNAMIC_CLASS(a2dCanvasDocument);

protected:

    //! Called by ProcessEvent(wxEvent& event) of document
    /*!
        Event processing is called by wxView and therefore a2dCanvasView.
        In a a2dDocumentCommandProcessor controller application wxDocChildFrame and wxDocParentFrame
        redirect events to wxView and a2dDocumentCommandProcessor.
        In a non a2dDocumentCommandProcessor the a2dCanvas is calling ProcessEvent(wxEvent& event) of document.
        Onidle updates all drawers if pending updates are available
    */
    void OnIdle( wxIdleEvent &event );

    //! uses wxBufferedInputStream instead of a2dDocumentInputStream
    void OnOpenDocument( a2dDocumentEvent& event );

protected:

#if wxART2D_USE_CVGIO
    //! do not use directly, part of CVG format writing
    void DoSave( a2dIOHandlerCVGOut &out, a2dCanvasObjectList* towrite );
#endif //wxART2D_USE_CVGIO

    //! start a2dCanvasObject containing all primitives
    a2dCanvasObjectPtr m_rootobject;

    //!setup for layers in this document
    /*!
        \remark will contain if a layer is available/visible for rendering
        \remark object without style will take the layer style to draw itself.
    */
    a2dSmrtPtr<a2dLayers>  m_layersetup;

    //! multi root document
    bool m_multiRoot;

    //!set by object in this a2dCanvasDocument, to tell they have changed and therefore it needs to be rerendered
    bool m_updatespending;

    //!if set ignore all setting for pendingobjects
    bool m_ignorePendingObjects;

    //! how many decimal places in fraction are valid
    double m_units_accuracy;

    //! scaling factor (how many "m_units_measure" is one unit)
    double m_units_scale;

    //! normalization factor to scale normalized objects.
    double m_normalize_scale;

    //! unit (e.g. Meters Inch Microns etc.)
    wxString m_units;

    //! measuring unit (e.g. Meters Inch Microns etc.)
    wxString m_units_measure;

    //! for new document views what will be the size in userunits in X
    double m_initialSizeX;

    //! for new document views what will be the size in userunits in Y
    double m_initialSizeY;

    //! last modification time when this document was stored.
    wxDateTime m_modificationtime;

    //! when was the document last accessed.
    wxDateTime m_accesstime;

    //! gives time when a change was made to the document which may effect rendering  
    /*!
        e.g. set in SetUpdatesPending()
    */
    wxDateTime m_changedInternalAccesstime;


public:
   
    //! name of library or document
    wxString m_libraryname;

    //! description for document
    wxString m_description;

    //! version of library or document
    int m_version;

    //! layer info changed id sent around when m_layersetup is changed.
    static const wxEventType sm_layersetupChanged;

    A2D_DECLARE_EVENT_TABLE()

};

#if defined(WXART2D_USINGDLL)
template class A2DCANVASDLLEXP a2dSmrtPtr<a2dCanvasDocument>;
#endif

#endif /* __WXCANDOC_H__ */

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