drawer.h

Go to the documentation of this file.

/*! \file wx/canvas/drawer.h
    \brief the a2dCanvasView is a a2dView specially designed for displaying 
    parts of a a2dCanvasDocument. It uses a a2dDrawer2D to actually redraw things from the document,
    by giving that a2dDrawer2D as drawing context to the document, and telling the document to redraw 
    a certain rectangular area. At that last is what this class is for.
    It optimizes the areas to be redrawn after object in the document were changed.
    To do that it combines redraw areas to a minimal set of redrawing areas.
    All the administration for this and the way things will be redrawn is from this view.

    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: drawer.h,v 1.49 2008/10/21 21:48:30 titato Exp $
*/

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


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

#if wxUSE_PRINTING_ARCHITECTURE
    #include "wx/prntbase.h"
#endif

#include "wx/docview/docviewref.h"
#include "wx/artbase/drawer2d.h"
#include "wx/canvas/candefs.h"
#include "wx/canvas/tools.h"

#include <vector>

class a2dCursorStack : public std::vector<wxCursor>
{
public:

    a2dCursorStack();
};

//! mask flags for a2dCanvasView::OnUpdate
/*! a2dCanViewUpdateFlags
\sa  a2dCanvasView

    \ingroup docview 
*/
enum a2dCanViewUpdateFlags
{
    a2dCANVIEW_UPDATE_OLDNEW  = 0x0001, /*!< only add pending object areas from document to arealist of all drawer views,
                                           does reset pending objects */
    a2dCANVIEW_UPDATE_PENDING = 0x0002, /*!< only add pending object areas from document to arealist of this drawer view, 
                                           do NOT reset pending objects */
    a2dCANVIEW_UPDATE_ALL     = a2dVIEW_UPDATE_ALL, /*!< total area displayed by drawer is added as pending to arealist 
                                           (removes all other pending areas) */
    a2dCANVIEW_UPDATE_AREAS   = 0x0008, /*!< redraw arealist into buffer or directly to device when not double buffered */

    a2dCANVIEW_UPDATE_AREAS_NOBLIT = 0x0010, /*!< redraw arealist into buffer but do not blit them by directly deleting the redrawn area */

    a2dCANVIEW_UPDATE_BLIT         = 0x0020,  /*!< blit updated areas to device window*/

    a2dCANVIEW_UPDATE_VIEWDEPENDENT = 0x0040, /*!< update objects which are view dependent */

    a2dCANVIEW_UPDATE_VIEWDEPENDENT_RIGHTNOW = 0x0080, /*!< update objects which are view dependent right now*/

    a2dCANVIEW_UPDATE_SYNC_DRAWERS = a2dCANVIEW_UPDATE_OLDNEW |a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT

};

//! record in update list of a2dCanvasView.
/*!
    \ingroup drawer
*/
class A2DCANVASDLLEXP a2dUpdateArea: public wxRect
{
#ifdef CLASS_MEM_MANAGEMENT
    //! memory manager for speed up to replace system calls allocation and deallocation
    static a2dMemManager sm_memManager;
public:
    //! overloaded operator new for this class and it all derived classes
    void* operator new(size_t bytes) {
        return sm_memManager.Allocate(bytes);
    }

    //! overloaded operator delete for this class and it all derived classes
    /*!
        This function doesn't free to OS-system memory block by pointer 'space'.
        It adds memory block by pointer 'space' to internal lists.
        It is speed up.
    */
    void operator delete(void *space, size_t bytes) {
        sm_memManager.Deallocate(space, bytes);
    }
#endif //CLASS_MEM_MANAGEMENT

public:
    a2dUpdateArea(int x, int y, int width, int height, wxUint8 id = 0 );
    ~a2dUpdateArea();

public:

    // update done blit awaiting
    bool m_update_done;
    bool m_update_direct;
    
    //! buffer id
    wxUint8 m_id;
};

#include <wx/listimpl.cpp>

//! Holds all updateareas within a a2dCanvasView
WX_DECLARE_LIST_WITH_DECL(a2dUpdateArea, a2dUpdateListBase, class A2DCANVASDLLEXP);

//! maintains a list of areas on a view to be redrawn.
/*!
    update areas reported directly to a view or extracted from tiles or stored here.    
*/
class A2DCANVASDLLEXP a2dUpdateList : public a2dUpdateListBase
{

#ifdef CLASS_MEM_MANAGEMENT
    //! memory manager for speed up to replace system calls allocation and deallocation
    static a2dMemManager sm_memManager;
public:
    //! overloaded operator new for this class and it all derived classes
    void* operator new(size_t bytes) {
        return sm_memManager.Allocate(bytes);
    }

    //! overloaded operator delete for this class and it all derived classes
    /*!
    This function doesn't free to OS-system memory block by pointer 'space'.
    It adds memory block by pointer 'space' to internal lists.
    It is speed up.
    */
    void operator delete(void *space, size_t bytes) {
        sm_memManager.Deallocate(space, bytes);
    }
#endif //CLASS_MEM_MANAGEMENT

public: 
    a2dUpdateList(void) : a2dUpdateListBase() {
    }

};

#define a2d_TILESHIFT 8
#define a2d_TILESIZE 256 //(1 << a2d_TILESHIFT) 

//! a2dTileBox is a subarea of a tile.
/*!
    The drawing area is divided into tiles, where each tile is 256 * 256 pixels.
    The part of the tile which needs a redraw is stored in tile coordinates.
*/
class A2DCANVASDLLEXP a2dTileBox
{
public:

    //! constructor
    a2dTileBox(int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0 );

    //! destructor
    ~a2dTileBox();

    //! Initialize a tile
    void Init( int x1 = 0, int y1 = 0, int x2 = 0, int y2 = 0 );
    
    //! expand a tile with this box
    void Expand( int x1, int y1, int x2, int y2 );

    //! get x1 in pixel coordinates
    inline int x1p() { return m_x1 << a2d_TILESHIFT; }
    //! get y1 in pixel coordinates
    inline int y1p() { return m_y1 << a2d_TILESHIFT; }
    //! get x2 in pixel coordinates
    inline int x2p() { return m_x2 << a2d_TILESHIFT; }
    //! get y2 in pixel coordinates
    inline int y2p() { return m_y2 << a2d_TILESHIFT; }

    //! if set, true
    bool m_valid;

    //! x1 in pixel coordinates
    int m_x1;
    //! y1 in pixel coordinates
    int m_y1;
    //! x2 in pixel coordinates
    int m_x2;
    //! y2 in pixel coordinates
    int m_y2;

    //! prev row pointer to combine tiles into rectangles
    a2dUpdateArea* m_rectPrevRow;

};

#define a2d_INIT_TILES 100

#if (defined(__WXMSW__) && defined(WXUSINGDLL) )
template class A2DCANVASDLLEXP a2dArrayGrow < a2dTileBox >;
#endif

//! a storage for a a tiled area
/*!
    An array of tiles width * height is maintained here.
    The tiles can be filled using scaning functions which take basic primitives as input.
    Later on the covered tiles can be extracted as a list of rectangles which 
    cover the same area but with less rectangles in general.
*/
class A2DCANVASDLLEXP a2dTiles
{
public:

    //! constructor
    /*!
        \param width number of horizontal tiles
        \param height number of vertical tiles
    */
    a2dTiles(int width, int height);

    //! destructor
    ~a2dTiles();

    //! change tile area
    void SetSize(int width, int height);

    //! All tiles become empty
    void Clear();

    //! draw tiles to given view in device coordinates. 
    void DrawTiles( a2dDrawer2D* drawer );

    //! draw optimized rectangles to given view in device coordinates. 
    void DrawRects( a2dDrawer2D* drawer );

    //! convert internal tile to pixel coordinate tiles area 
    inline int toP( int tilexy ) { return tilexy << a2d_TILESHIFT; }

    //! convert pixel to  internal tile coordinate tiles area 
    inline int toT( int xy ) { return xy >> a2d_TILESHIFT; }

    //!  xy modules 256 
    inline int ModT( int xy ) { return xy & (a2d_TILESIZE - 1); }

    //! fill tiles covering the rect given see FillTiles(  int x, int y, int w, int h, bool expand )
    void FillTiles( const wxRect& rect, bool expand = true );

    //! fill tiles covering the rect given
    /*!
        The rect formed by x,y,w,h, is divided over the tiles, filling the the part of the tiles that
        are covered by the rectangle.

        \param x x of rectangle 
        \param y y of rectangle 
        \param w width of rectangle 
        \param h height of rectangle 
        \param expand if true keep existing filled tiles, else clear all.
    */
    void FillTiles( int x, int y, int w, int h, bool expand );

    //! are there filled tiles available? 
    bool HasFilledTiles();

    //! generate from files tiles a list of semi optimal covering rectangles
    /*!
        The tiles are iterated in horizontal rows, combining filed tiles found 
        in the rows when at same height and connecting with the previous tile.
        The found rect is then combined a rectangle already found in a previous row.
    */
    a2dUpdateList* GenerateUpdateRectangles();

    //! see GenerateUpdateRectangles(), this one adds to the list given.
    void GenerateUpdateRectangles( a2dUpdateList* rects, wxUint8 id );

    //! number of horizontal tiles
    int m_width;
    //! number of vertical tiles
    int m_height;

    //! get tile at index i
    inline a2dTileBox tile( int i ) 
    { 
        assert( i < ( m_width*m_height -1 ) ); 
        return m_tiles[ i ]; 
    }

    //! array of tiles ( normally m_width * m_height )
    vector< a2dTileBox > m_tiles;
};

class A2DCANVASDLLEXP a2dCanvas;
class A2DCANVASDLLEXP a2dViewPrintout;

#if wxUSE_PRINTING_ARCHITECTURE
class A2DCANVASDLLEXP a2dViewPrintout;

//! to print what is displayed on a a2dCanvasView or the whole document as seen from the showobject of the drawer.
/*!
    Internal a second wxDarwer class is initiated with a mapping that nicely fits that mapping of the input
    a2dCanvasView to a piece of paper. This mapping depends on the type of print. If only what is on the view needs
    to be printed, the mapping of the input drawer is used, but if the whole document is wanted as seen
    from the ShowObject() of the input drawer, the boundingbox of the showobject will be used for the mapping.


    \ingroup docview
*/
class A2DCANVASDLLEXP a2dViewPrintout: public a2dDocumentPrintout
{
    public:

        //!initialize mapping based on an existing canvas
        /*!
           \param drawer the a2dCanvasView from which the print is wanted.
           
           \param title title at top of the print 

           \param filename the name of the file to be printed (may be empty )
            
           \param typeOfPrint When called from a2dDocumentCommandProcessor, the a2dCommand* which lead to this call.

            Depending on the command one can organize printing features.
            Like in the default implementation:
            \code
                a2dCommand_Print::a2dPrintWhat
                {
                    Print,     
                    Preview,    
                    PrintView,     
                    PreviewView,     
                    PrintDocument,     
                    PreviewDocument,  
                    PrintSetup
                };
            \endcode
                              
            Here View is to only print what is the visible view.
            Document print the document as seen from the 
            a2dView::ShowObject(), it fits this to the paper.

            \param drawframe print a frame rectangle in bounding box of drawing/view
            \param scalelimit limits the scaling (world/pixel) to the given value, so that small graphics are not zoomed to full page
            \param fitToPage scale to fit the page
        */
        a2dViewPrintout(a2dCanvasView* drawer,const wxString& title, const wxString& filename, a2dCommand* typeOfPrint, bool drawframe, double scalelimit, bool fitToPage );

        //!destructor
        ~a2dViewPrintout(void);

        //! called for every page to print, for a2dCanvasDocument in general just one.
        /*!
           It redraws/rerenders without double buffering the view or document on the pinter its wxDC.
           Internal a a2dDcDrawer is used to redraw the a2dCanvasDocument on the device.
        */
        bool OnPrintPage(int);

    protected:

        //! type of print requested
        a2dCommand* m_typeOfPrint;

        //! maping defined by this canvas
        a2dCanvasView*  m_drawingView;

        //!title put above printout
        wxString    m_title;

        //!filename put below printout
        wxString    m_filename;

        //! limit scaling to this value (world/pixel)
        double m_scalelimit;

        //! draw a frame around the page
        bool m_drawframe;

        //! draw a view without real scale, the scaling in X and Y may differ.
        //! The drawing is adjusted in X and Y seperately to draw until the sides/border of the printer area
        bool m_fitToPage;
};
#endif


//! Used by a2dCanvasView to decide what layers are to be rendered.
/*!
    The a2dCanvasDocument is checked via a2dCanvasObject::Addpending() etc. which 
    layers contain objects. The array containing this information is stored 
    seperate for each a2dCanvasView. This is because each view can show different parts
    of a document, and one part can contain more layers then the other.
    This information is used to skip rendering layers which do not contain objects, 
    or which are set invisible.

    \ingroup canvasobject

    \ingroup docview
*/
class A2DCANVASDLLEXP a2dLayerView 
{

public:

    //!constructor
    a2dLayerView()
    {
        m_layervisible = true;
        m_layeravailable = false;
        m_check = true;
    }

    ~a2dLayerView(){};

    //!is the layer visible
    bool GetVisible() { return m_layervisible; }

    //! set layer visible
    void SetVisible( bool status ) { m_layervisible = status; }

    //!are the objects on this layer
    bool GetAvailable() { return m_layeravailable; }

    //! set layer available (will be rendered)
    void SetAvailable( bool status ) { m_layeravailable = status; }

    //! check this layer?
    bool GetCheck() { return m_check; }

    //! set the layer to be checked in idle time.
    void SetCheck( bool status ) { m_check = status; }

    //! should this layer be rendered
    bool DoRenderLayer() 
    { 
        return ( m_layeravailable && m_layervisible ) || m_check; 
    }

protected:

    //!is the layer visible
    bool m_layervisible;

    //!is the layer filled with primitives
    bool m_layeravailable;

    //!if true layer need to be check again document for availability.
    bool m_check;
};

//! View on a a2dCanvasDocument, in which a2dCanvasObjects are shown.
/*!
    a2dCanvasView is a specialized view to display parts of a a2dCanvasDocument. 
    Such a part always starts at one a2dCanvasObject which is inside of a a2dCanvasDocument object. 
    The a2dCanvasObject itself contains as children a2dCanvasObject derived drawable objects. A hierarchy 
    of recursively nexted objects is what forms the actual drawing.
    The parent object to start the drawing is called the ShowObject.
    The member functions SetShowObject(...) are used to set the ShowObject to be displayed.
    All objects are defined in relative world coordinates, which are relative to the parent object(s).

    a2dCanvasDocument is given as a drawing and/or updating context a a2dCanvasView.  E.g. in
    a2dCanvasDocument::RenderTopObject() the a2dCanvasView is used by the a2dCanvasObject render functions to get to
    a2dCanvasView::m_drawer2D, which is the Drawing Context used to do the actual drawing within
    the a2dCanvasObjects. But a2dCanvasView::RenderTopObject() defines what drawing style is used to draw.

    The real purpose of a2dCanvasView, is to maintain a list of damaged/changed areas in the view/drawing, and 
    when time is ready, start redrawing those areas. When a a2dCanvasObject did change in position or size etc.,
    the a2dCanvasDocument reports this change as a rectangular redraw areas to the a2dCanvasView's of that document.
    The update areas are based on the boundingbox of the object in its old state and in its new state.
    This reporting is done in idle time, and for all changed objects at once. When reporting of all changed areas is done, 
    each a2dCanvasView knows what parts of its drawing need to be redrawn. It will then start redrawing those areas, 
    but only after optimizing to the minimum areas to redraw. So overlapping areas will only be redrawn once.
    The mechanism for that is called tilling. 

    The size of the drawing in world coordinates and the size of the view in pixels is all indirectly defined by 
    a2dCanvasView::m_drawer2D and a2dView::m_display. The area of the drawing in world coordinates that is visible, 
    can be set via a2dCanvasView::m_drawer2D. Also if World coordinates is with the Y axis going up are down.
    a2dDrawer2D has methods to convert from world to device coordinates and visa versa.
    a2dCanvasView::m_drawer2D draws into a buffer. After rendering an update of all damaged parts into this buffer,
    it will be blitted from the buffer to the a2dView::m_display of the a2dCanvasView. This is done in Idle time, 
    but can also be forced. In the end a2dCanvasView automatically always displays an up to date part of the drawing 
    which is stored inside the a2dCanvasDocument. The user just changes a a2dCanvasObject inside the a2dCanvasDocument, 
    and the redrawing on all the views will be done automatically.
    
    A a2dCanvasView its a2dCanvasView::m_drawer2D knows where to draw to, this can be a bitmap buffer or a window etc.
    The job to update a window in case of drawing to a bitmap buffer, is not part of the a2dDrawer2D.
    This is/needs to be done by the class using the drawer, like a2dCanvasView and indirectly a2dCanvas here.
    The a2dCanvas receives a paint event, e.g. when moving an overlapping window or dialog, and it then blits the right
    parts from a2dCanvasView::m_drawer2D its drawing buffer to the canvas window.
    a2dCanvasView also takes care of scrolling the view, it does this by re-using the contents of the a2dDrawer2D drawing
    buffer when possible. 
    The drawing buffer can be bigger then the size of the canvas window. a2dCanvasView always makes sure the whole buffer
    contains an up to date contents, as being the drawing to display form its document. Therefore if the canvas windows 
    which uses the a2dCanvasView for drawing, implements scrolling and resizing, the canvas window is responsible for 
    optimizing the scroll to take maximum advantage from the buffer of a2dCanvasView. Like if the buffer is bigger in
    size then the canvas windows size, a resize of the canvas window only needs to increase the buffer size of 
    a2dCanvasView, when the size of the window exeeds the buffer size.
    One can even decide to set the buffer to the size of the complete virtual area that can be scrolled.
    This way one can make a trade of between buffer size and scrolling/resizing speed.
    Knowing this, one needs to realize that mouse coordinates as received inside a canvas window, are different
    if the origin in the drawing context is not at the orginin of the canvas window.
    The a2dCanvasView::m_drawer2D takes (0,0) of the buffer as the origin of device coodinates.
*/
class A2DCANVASDLLEXP a2dCanvasView: public a2dView
{
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    a2dInitCurrentSmartPointerOwner m_initCurrentSmartPointerOwner;
#endif
    A2D_DECLARE_EVENT_TABLE()

public:


    //!constructor
    /*!
        \remark 
        Do not forget to call SetDocument() if used standalone
        (in a a2dDocumentCommandProcessor setting this is taken care of).
    */
    a2dCanvasView( int width = 1000, int height = 1000 );

    //!constructor
    /*!
        Width and hight is given, mapping is as in drawer given.

        \remark 
        Do not forget to call SetDocument() if used standalone
        (in a a2dDocumentCommandProcessor setting this is taken care of).
    */
    a2dCanvasView( int width, int height, a2dDrawer2D *drawer2D );

    //!constructor
    /*!
        Width and hight and mapping is as in drawer given.

        \remark 
        Do not forget to call SetDocument() if used standalone
        (in a a2dDocumentCommandProcessor setting this is taken care of).
    */
    a2dCanvasView( a2dDrawer2D * drawer );

    //!constructor
    /*!
        \remark
        Do not forget to call SetDocument() if used standalone
        (in a a2dDocumentCommandProcessor setting this is taken care of)
    */
    a2dCanvasView( const wxSize& size );

    //!copy constructor
    a2dCanvasView( const a2dCanvasView& other);

    //! next to the base its m_display, this also sets m_drawer2d to this display
    virtual void SetDisplayWindow( wxWindow* display ); 

    //! Get the Display window of the a2dView. But casted to a a2dCanvas 
    /*! when a a2dCanvas is used in this a2dCanvasView return it else 0.
        a2dCanvasView needs to know the window (a2dCanvas) to display itself.
        The a2dCanvasView updates to this window in idel time.
        Paint event to the a2dCanvas are using the a2dCanvasView its buffer for 
        quick updating the a2dCanvas window.

        \sa a2dView::SetDisplayWindow()
    */
    a2dCanvas* GetCanvas() const { return (a2dCanvas*) m_display; }

    //! sets buffersize ( if used ) for the a2dDrawer2D
    virtual void SetBufferSize( int w, int h );
    
    virtual bool GetTrippleBuf() { return false; }

    virtual bool GetTrippleBufHasAlpha() { return false; }

    virtual bool HasAlhpa() { return m_drawer2D->HasAlpha(); }

    //!destructor
    virtual ~a2dCanvasView();

    //! if set true, document can contain objects that depend on this view (size etc).
    /*! If set those objects will be automatically updated for this view.
        Else the document is assumed to not contain viewdependent objects for this view, and that update cycle is skipped.
    */
    void SetViewDependentObjects( bool viewDependentObjects ) { m_viewDependentObjects = viewDependentObjects; }

    //! see SetViewDependentObjects()
    bool GetViewDependentObjects() const { return m_viewDependentObjects; }

    //! get the layer render array
    a2dLayerView* GetLayerRenderArray() { return m_layerRenderArray; }

    //!update layers available needed?
    /*!
        \sa Set_UpdateAvailableLayers
    */
    bool Get_UpdateAvailableLayers() const { return m_update_available_layers; }

    //! check which layers do contain objects as seen from the ShowObject() 
    void SetAvailable();

    //! signals the need to check the given layer for visibility/availibility as seen from this view.
    void SetLayerCheck( wxUint16 layer );

    //! Sets a flag for updating available layers checking, which makes sure layers will be checked first when needed.
    /*! 
        Eventually results in updating the layers table settings on layers available in document
        before rendering starts or simular functions.
    */
    void Set_UpdateAvailableLayers( bool value ) { m_update_available_layers = value; }

    //!Set to draw layers in reverse order
    void SetReverseOrder(bool revorder);

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

    //! used to extend a hittest with the number of pixels.
    /*! to be able to hit a line of width zero, a margin is needed to hit it,
        which is set here.

        \remark default value is 2 pixels
    */
    inline void SetHitMargin( wxUint16 pixels ) { m_hitmargin = pixels; }

    //! Get HitMargin used to extend a hittest with the number of pixels.
    inline wxUint16 GetHitMarginDevice() const { return m_hitmargin; }

    //! Get HitMargin used to extend a hittest in world units.
    double GetHitMarginWorld() const;

    //! Special event handling for a2dCanvasView class
    /*! 
        If eventprocessing is enabled and the view is enabled. OR in case this event ( wxEVT_ENABLE_VIEW | wxEVT_ENABLE_VIEWS )
        is to enable this a2dView, the event is processed.
    
        wxEVT_IDLE is first processed by the view, and next by the m_toolcontroller is set.
        wxEVT_PAINT is first processed by the m_display if set, next by the view, and next by the m_toolcontroller is set.
        This garantees proper redrawing of tools on top of the window.

      Next to this check the command processor for its current parent object, and sent 
        a command to set it right if change is needed.
    */
    virtual bool ProcessEvent(wxEvent& event);

#if wxUSE_PRINTING_ARCHITECTURE
    //! to create a a2dViewPrintout, used to print a view or its document
    /*!
        The a2dViewPrintout created will take as much possible from the this view.
        a2dViewPrintout will create itself a view which fits the size of the paper, but important setting are taken from this view.
    */
    virtual wxPrintout* OnCreatePrintout( a2dCommand* typeOfPrint );
#endif

    //! If not set do not process mouse events.
    /*! 
        Mouse events are handled by the canvas.
        They are redirected to the a2dCanvasObject hit.
        You can switch this off here, and skip the event from being processed.
        This is often used in tools, to prevent a2dCanvasObjects from receiving events.

        \remark most events go to the m_toolcontroller first if set. \see ProcessEvent()
    */
    void SetMouseEvents(bool onoff);

    //! return true if this a2dCanvasView allows mouse events to be processed.
    bool GetMouseEvents() const { return m_mouseevents; }

    //! set the object that is captured for events in the a2dCanvasDocument.
    /*!
        Used in combination with the a2dIterC class to set a corridor path for events.
        Do not use this function directly from outside a2dCorridor or a2diterC
    */
    void SetCaptured( a2dCanvasObject* captured ) { m_capture = captured; }

    //!are events redirected to a captured corridor? if so return the captured object in it, else NULL
    inline a2dCanvasObject* GetCaptured() const { return m_capture; }

    //! use in combination with the a2dIterC class to set a corridor path for events.
    /*!
        A corridor path leads event to a specific a2dCanvasObject in a a2dCanvasDocument.
        This feature is used to do editing of nested a2dCanvasObject 's, and to captures events 
        to such objects.
        The a2dCanvasObject's on a corridor path get the m_flags.m_isOnCorridorPath set, which result
        in redirecting events to the m_endCorridorObject.
    */
    void SetEndCorridorObject( a2dCanvasObject* endCorridorObject );

    //! return the corridor object if set else NULL \see SetEndCorridorObject()
    a2dCanvasObject* GetEndCorridorObject() const { return m_endCorridorObject; }

    //!get a2dCanvasDocument that is displayed on the canvas
    /*!
        As a side effect also sets this drawer for the document as active.
    */
    a2dCanvasDocument* GetCanvasDocument() const;

    //!set object available in the a2dCanvasDocument to be shown on the drawer
    /*!
        \param name name of top object
        \return pointer to the object found else NULL
    */
    a2dCanvasObject* SetShowObject(const wxString& name);

    //!set top object available in the a2dCanvasDocument to be shown on the drawer
    /*!
    \param obj: pointer to object to show
    */
    bool SetShowObject(a2dCanvasObject* obj);

    //!return pointer of then currently shown object on the drawer.
    /*!
        \return: pointer to the current object that is shown.
    */
    a2dCanvasObject* GetShowObject() const {
            return m_top; }
    
    //!add pending update for the area that is the boundingbox of the given object
    /*!
        Updates the boundingbox area of the given object at idle time.
        If obj is NULL nothing will be done
        If refalso is true then all references to this object will be updated also.
        
        \param obj the object where to take the bounding box from
        \param refsalso <code>true</code> to update all references, else <code>false</code>
    */
    void AddPendingUpdateArea( a2dCanvasObject* obj, wxUint8 id = 0, bool refsalso=true );

    //!recursive find pending objects and adds their areas to the updatelist
    /*! it does first test if the a2dCanvasDocument has the flag set to tell it has pending objects inside.
    If that is the case, it traverses the a2dCanvasDocument, and adds
    the absolute boundingbox of the pending object to the a2dCanvasView updatelist.
    This is for all paths leading to the object from the current ShowObject, so also a2dCanvasObjectReference's.
    \return true if did add pendingobject's else false
    */
    bool AddObjectPendingUpdates();

    //!add boundingbox to update list for updating in idle time
    void AddPendingUpdateArea(const a2dBoundingBox& box, wxUint8 id = 0 );

    //!add rectangle to update list for updating in idle time
    void AddPendingUpdateArea( const wxRect& recnew, wxUint8 id = 0 );

    //!add area to update list for updating in idle time
    /*!
    the given area will be added to the
    list of rectangles to be blitted to the screen later in idle time,
    at repaint or after an UpdateNow action.
    The given area will be combined (merged/ignored) with the already available update areas.
    This to prevent un necessary redraws.
    */
    void AddPendingUpdateArea( int x, int y, int w, int h, wxUint8 id = 0 );

    void AddOverlayAreas( bool update );

    //! add to list of overlay objects (must be children of m_top) 
    void AddOverlayObject( a2dCanvasObject* obj );

    //! remove from the list of overlay objects (must be children of m_top) 
    void RemoveOverlayObject( a2dCanvasObject* obj );

    //! Not implemented, use a2dViewPrintout to print
    /*!
       OnDraw is called when printing a view via wxView::OnPrint with wxDocPrintout::OnPrintPage.
       But for a2dCanvasView, i implemented it in a2dViewPrintout::OnPrintPage.

       This funcion is and should NOT be used to Redraw the a2dCanvasView views, this is taken care of automatically,
       and if needed can be forced with OnUpdate or Update.
       Paint events are intercepted to blit damaged parts caused by overlaping windows,
       and in Idle time changes or updated in a2dCanvasView. 
    */
    virtual void OnDraw( wxDC* );

    //! depending on the hint value performs specific updating on the view.
    /*!
    Hint is unsigned int containing flags of type \sa a2dCanViewUpdateFlags which actions will be executed in the right order.
    In principle the view its internal data ( this is mostly the buffer ) should be updated, and be made ready 
    for redisplay on the view its DisplayWindow().
    A reason for updating a view, is a change in the a2dCanvasDocument. The document is checked for changes in idle 
    time, and updates all views on the document at once when a change exists.
    First all changed areas on the view because of changes to the document, are reported by the document to the a2dCanvasView.
    The a2dCanvasView keeps an internal list of areas needing a redraw. 
    The areas reported are found on the basis of the old and new boundingboxes of the changed objects.
    Next the areas in the updatelist are redrawn in the buffer of the a2dCanvasView, and at last those areas will be blitted.

    The above is done automatic, but one is free for whatever reason to add pending areas directly to the
    a2dCanvasView its update arealist. Those will be updated also in idle time, along with all others areas as a result
    of changing objects.
    
    \remark OnUpdate is the key routine to speedy redraws, proper use asures only redraw of changed or
    damaged areas in idle time.

    \remark Called in a2dCanvasDocument from UpdateAllViews() and AddPendingUpdatesOldNew() to update this view.

    \remark a2dCANVIEW_UPDATE_BLIT means, blit all updated areas for this a2dCanvas now to the screen,
    else it will happen in idle time.
    Use a2dCANVIEW_UPDATE_OLDNEW |a2dCANVIEW_UPDATE_BLIT | a2dCANVIEW_UPDATE_BLIT
    to support dragging for instance, because in such cases idle time
    will take to long. Other a2dCanvas using the same a2dCanvasDocument will not be redrawn and blitted
    when double buffered.
    */
    void OnUpdate( a2dDocumentEvent& event );

    //! see OnUpdate
    /*!by default adds a full pending update for the drawer and all in it, and redraws this to the device.
    Use how = a2dCANVIEW_UPDATE_ALL when the contents/data of the canvas has changed
    without specific updates applied to areas. This will do the redraw in idle time.
    For example: after adding many new objects to the root object
    or other objects referenced or after changing the root object

    \remark the default value is brute force redraw all, but in general not wise to use since it means a total redraw.
    instead most often a2dCANVIEW_UPDATE_OLDNEW is used, or if result needs to be displayed directly, use
    ( a2dCANVIEW_UPDATE_OLDNEW |a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT )

    */
    void Update( unsigned int how = (a2dCANVIEW_UPDATE_ALL | a2dCANVIEW_UPDATE_BLIT)
                 , wxObject* hintObject = NULL );

    //!update/redraw part of the buffer, using the given a2dCanvasDocument and ShowObject within that root.
    /*!
        This method also takes care of redrawing the background and the grid
    */
    virtual void UpdateArea( int x, int y, int width, int height, wxUint8 id = 0 );

    virtual void ClearArea( int x, int y, int width, int height );

    virtual void RenderChildObject( a2dCanvasObject* obj );

    //! blit part of the drawing buffer to the canvas
    virtual void BlitBuffer( int x, int y, int width, int height, int xbuf, int ybuf );

    //!Function to draw the origin
    /*!override this function in a derived class to redefine painting of the origin*/
    virtual void DrawOrigin();

    //!Function to draw the grid
    /*!override this function in a derived class to redefine painting of the grid*/
    virtual void PaintGrid( int x, int y, int width, int height );

    //!(re)painting of background
    /*!override this function in a derived class to redefine painting of the background*/
    virtual void PaintBackground( int x, int y, int width, int height );

    //! set enable crosshair cursor
    void SetCrossHair( bool onoff );

    //! get enable crosshair cursor
    bool GetCrossHair() { return m_crosshair; }

    //! set crosshair cursor Length in X in pixels
    void SetCrossHairLengthX( int LengthX ) { m_crosshairLengthX = LengthX; }

    //! set crosshair cursor Length in Y in pixels
    void SetCrossHairLengthY( int LengthY ) { m_crosshairLengthY = LengthY; }

    //! get crosshair cursor Length in X in pixels
    int GetCrossHairLengthX() { return m_crosshairLengthX; }

    //! get crosshair cursor Length in Y in pixels
    int GetCrossHairLengthY() { return m_crosshairLengthY; }

    //!set stroke for crosshair
    void SetCrossHairStroke( const a2dStroke& stroke );

    //!get stroke for crosshair
    a2dStroke& GetCrossHairStroke() { return m_crosshairStroke; }

    //! blit old areas to remove last drawn crosshair and draw the cross hair at this new position.
    virtual void UpdateCrossHair( int x, int y );

    //! set a2dFill to use when RenderFIX_STYLE is set.
    void SetFixedStyleFill( const a2dFill& fixFill ) { m_fixFill = fixFill; }

    //! set a2dStroke to use when RenderFIX_STYLE is set.
    void SetFixedStyleStroke( const a2dStroke& fixStroke ) { m_fixStroke = fixStroke; }

    //! set a2dFill to use when RenderWIREFRAME_SELECT or RenderWIREFRAME_SELECT_INVERT is set.
    void SetSelectFill( const a2dFill& selectFill ) { m_selectFill = selectFill; }

    //! set a2dStroke to use when RenderWIREFRAME_SELECT or RenderWIREFRAME_SELECT_INVERT is set.
    void SetSelectStroke( const a2dStroke& selectStroke ) { m_selectStroke = selectStroke; }

    //! set a2dFill to use when RenderWIREFRAME_HighLight.
    void SetHighLight( const a2dFill& hightLightFill ) { m_highLightFill = hightLightFill; }

    //! set a2dStroke to use when RenderWIREFRAME_HighLight.
    void SetHighLight( const a2dStroke& hightLightStroke ) { m_highLightStroke = hightLightStroke; }

    //! set a2dFill to use when RenderFIX_STYLE is set.
    void SetOverlayFill( const a2dFill& overlayFill ) { m_overlayFill = overlayFill; }

    //! set a2dStroke to use when RenderFIX_STYLE is set.
    void SetOverlayStroke( const a2dStroke& overlayStroke ) { m_overlayStroke = overlayStroke; }

    //!background fill for the canvas
    void SetBackgroundFill( const a2dFill& backgroundfill );

    //!get current background fill for the canvas
    a2dFill& GetBackgroundFill() { return m_backgroundfill; }

    //!Set grid setting for drawing grid in front or back
    void SetGridAtFront(bool gridatfront){ m_gridatfront = gridatfront; Update( a2dCANVIEW_UPDATE_ALL ); }

    //!Get grid setting for drawing grid in front or back
    bool GetGridAtFront(){ return m_gridatfront;}

    //!set stroke used for grid drawing
    void SetGridStroke( const a2dStroke& gridstroke);

    //!set size of grid circle
    void SetGridSize(wxUint16 gridsize){ m_gridsize = gridsize; Update( a2dCANVIEW_UPDATE_ALL );}

    //!set fill used for grid drawing
    void SetGridFill( const a2dFill& gridfill);

    //!Get grid distance in X
    double GetGridX(){return m_gridx;}

    //!Set grid distance in X
    void SetGridX(double gridx){ m_gridx = gridx; Update( a2dCANVIEW_UPDATE_ALL );}

    //!Get grid distance in Y
    double GetGridY(){return m_gridy;}

    //!Set grid distance in Y
    void SetGridY(double gridy){ m_gridy = gridy; Update( a2dCANVIEW_UPDATE_ALL );}

    //!Set grid on/off
    void SetGrid(bool grid){ m_grid = grid; Update( a2dCANVIEW_UPDATE_ALL ); }

    //!Get grid setting on/off
    bool GetGrid(){return m_grid;}

    //!Get grid setting for line drawing
    /*!Note: SetGridSize must be 0, if gridlines=false */
    void SetGridLines(bool gridlines) { m_gridlines = gridlines; Update( a2dCANVIEW_UPDATE_ALL ); }

    //!Get setting for grid to draw lines instead of points
    bool GetGridLines() { return m_gridlines; }

    //!Set grid threshold, if grid distance is below this in pixels, it will be increased
    //! by factors of 2 until it fits.
    void SetGridThreshold( wxUint16 gridthres ) { m_gridthres = gridthres; Update( a2dCANVIEW_UPDATE_ALL ); }

    //!Get grid threshold.
    wxUint16 GetGridThreshold() { return m_gridthres; }

    //!Set showorigin on/off
    void SetShowOrigin(bool show) { m_showorigin = show; Update( a2dCANVIEW_UPDATE_ALL ); }

    //!Returns if canvas is frozen.
    bool IsFrozen()              { return m_frozen; }

    //!prevent changing the a2dCanvasView buffer and blitting it to the window
    /*! 
        This makes sure the contents displayed into the a2dCanvasView buffer does not change.
        Pending objects inside a root will be added to the update list of the a2dCanvasView,
        but not redrawn into the buffer until Thaw.
    
        \see Thaw
    */
    void Freeze();

    //! to release Freeze()
    /*!
        The Frozen view ( Freeze() ), is released. Pending update araes in the update list 
        will be redrawn in OnIdle at the next idle event.

        \see Freeze

        \param update if true all shown on this view will be redrawn.
    */
    void Thaw( bool update );

    //! blit pending update areas, that are already updated to the buffer, now to the screen.
    /*! does the second stage in the two stage process of updating
    */
    virtual bool BlitPendingUpdateAreas();

    //! set toolcontroller ( reset with NULL )
    /*! Toolcontrollers are meant to implement tools that manipulate the objects
    displayed on the a2dCanvas.
    All events to the canvas window or first redirected to the controller.
    When skipped in the controller the events will eventually reach the a2dCanvas itself.

    \return true is there was a controller set already.

    \remark The controller is owned by the canvas and will be deleted by the canvas on destruction or when changed.
    */
    bool SetCanvasToolContr( a2dToolContr* controller );

    a2dToolContr* GetCanvasToolContr() { return m_toolcontroller; }

    void SetCursor(const wxCursor&cursor);    

    //! push a cursor on the cursor stack, and set display cursor to new back being cursor.
    void PushCursor(const wxCursor& cursor);    

    //! pop a cursor from the cursor stack, and set display cursor to back
    void PopCursor(); 

    //! clear the stack of cursor, and set display cursor ARROW.
    void ClearCursorStack(); 

    //!do a hittest on the view at coordinates x,y
    /*!
    \param x x of point to do hittest
    \param y y of point to do hittest
    \param layer test only if objects are on this layer or if set to wxLAYER_ALL test obejcts on all layers
    \param option ways to hit
    \param mask only object with this mask set will be hit

    \return the top object that was hit (e.g.in case of groups)

    \remark hit margin is defined in a2dCanvasDocument containing the root group
    */
    a2dCanvasObject* IsHitWorld(
        double x, double y, 
        int layer = wxLAYER_ALL,
        a2dHitOption option = a2dCANOBJHITOPTION_NONE,
        bool filterSelectableLayers = false
    );

    //!do an advanged hittest on the view
    /*!
    \param hitEvent stores hit information
    \param layer test only if objects are on this layer or if set to wxLAYER_ALL test obejcts on all layers

    \return the top object that was hit (e.g.in case of groups)

    \remark hit margin is defined in a2dCanvasDocument containing the root group
    */
    a2dCanvasObject* IsHitWorld(
        a2dHitEvent& hitEvent,
        int layer = wxLAYER_ALL
    );

    //! Corridor and captured object event processing.
    /*! 
        Follow corridor set, and redirect the event to last object in the corridor.
        The event is first sent to the child objects, and if not processed there,
        testing for a hit on the object itself is done, and if true a2dEvtHandler::ProcessEvent is called. 

        \param event the event to process
        \param isHit return if there was a hit on an object
        \param x x of point to do hittest
        \param y y of point to do hittest
        \param margin margin that still gives a valid hittest.
        \param layer only if object is on this layer or if set to wxLAYER_ALL ignore layer id.

        \return true if Object (or a child ) did process the event and did not call event.Skip()
    */
    virtual bool ProcessCanvasObjectEvent( wxEvent& event, bool& isHit, 
                       double x, double y, int margin, 
                       int layer = wxLAYER_ALL );

    //! Corridor and captured object event processing.
    /*! This is the same as the function
        ProcessCanvasObjectEvent( wxEvent& event, bool& isHit, double x, double y, int margin, int layer = wxLAYER_ALL ),
        but it sets the iteration context pointer of the event.
        This is used when sending a2dCanvasObjectEvents from a simple (handle less) tool.

        \param event the event to process
        \param isHit return if there was a hit on an object
        \param x x of point to do hittest
        \param y y of point to do hittest
        \param margin margin that still gives a valid hittest.
        \param layer only if object is on this layer or if set to wxLAYER_ALL ignore layer id.

        \return true if Object (or a child ) did process the event and did not call event.Skip()
    */
    virtual bool ProcessCanvasObjectEvent( a2dCanvasObjectEvent& event, bool& isHit, 
                       double x, double y, int margin, 
                       int layer = wxLAYER_ALL );

    //! This function is called after a property changed
    /*! This is overloaded to update the view if needed.
    */
    void OnPropertyChanged( const a2dPropertyId* id );

    //! Find the show-object child object, set the path to the given child object and capture it
    /*! \see a2dIterC::SetCorridorPath
        This is used to redirect events to a specific child object, e.g. one found by
        extended hit testing.

        \param findObject (child) object to be searched for.
        \param capture if true the findObject is captured
        \return true if findObject was found
    */
    bool FindAndSetCorridorPath( a2dCanvasObject* findObject, bool capture );

    //! find object on the current corridor path.
    /*!
        The a2dCanvasObject in the document with the m_flags.m_isOnCorridorPath set, are 
        pushed into a list, which is returned. If non found the return is false, else true and the list 
        of objects leading to the end of the corridor.
    */
    // bool FindCorridorPath( a2dCorridor& result );

    //! set a corridor from a list of objects
    void SetCorridorPath( const a2dCorridor& corridor );

    //! Reset all corridor paths and uncapture object
    /*! \see a2dIterC::SetCorridorPath
        Reset a corridor path set with FindAndSetCorridorPath

        \param uncapture if true uncaptured the captured object
    */
    void ClearCorridorPath( bool uncapture );


    //! use the boundingbox of the ShowObject to set the mapping such that it will be displayed completely on the device.
    /*!
        \see SetMappingDeviceRect to map to a different device/buffer rectangle.
    */
    void SetMappingShowAll();

    //! set the internal m_drawer2D to be used for rendering the document
    /*! The drawing context is owned by a2dCanvasView, it will delete it.
        Still you set it to NULL or othere context without deletion using the noDelete parameter.

        \param drawer2d the drawing context object to set
        \param noDelete default the old drawing context object is deleted, but not is this is set true.
                  This can be used to simulate ownership of the drawing context by another class. 
    */
    void SetDrawer2D( a2dDrawer2D* drawer2d, bool noDelete = false );

    //! get the internal m_drawer2D that is used for rendering the document
    a2dDrawer2D* GetDrawer2D() { return m_drawer2D; }

    //!set drawstyles to use for drawing the document
    /*!
        The internal m_drawer2D is set to this style before rendering of the document starts.

        \remark m_drawstyleRestore is set to the current drawstyle. So a temporary change can easily be restored.
        
        \param  drawstyle one of the draw styles
    */
    void SetDocumentDrawStyle( wxUint32 drawstyle );

    //! restore drawstyle to the one before the last change
    void RestoreDrawStyle() {  m_documentDrawStyle = m_documentDrawStyleRestore; }

    //!get drawstyles used for drawing the document
    wxUint32 GetDocumentDrawStyle() { return m_documentDrawStyle; }

    void SetOverlayDrawStyle( a2dDocumentRenderStyle drawstyle );

    //! scroll up down or left right
    /*! \param dxy scroll distance in X or Y
        \param yscroll if true scrolling is in Y else X
        \param total update whole device after scroll
    */
    virtual void Scroll( int dxy, bool yscroll, bool  total);

    //! does render the top object in the given style.
    /*!
        This function can be used from tools to render the tool its objects which do become
        part of the document in a certain style.
    */
    virtual void RenderTopObject( wxUint32 documentDrawStyle, wxUint8 id );

    //! single drawstyle render cycle called on document
    /*!
        Render the given topobject and all that is below it
        Will recursive call the render routines of all the objects seen from the topobject.
        This rendering iterates over layers.
        \param mask object must have this mask
        \param drawstyle which drawstyle should be used for this render action .

        \remark If a layer is Invisible it will not be rendered.
    */
    virtual void RenderTopObject( a2dCanvasObjectFlagsMask mask,  a2dDocumentRenderStyle drawstyle );

    //! render of overlay objects stored in m_overlayObjects specific to the view 
    virtual void RenderOverlay( a2dDocumentRenderStyle drawstyle );

    //! update the transform matrix for objects with property 'PROPID_viewDependent' 
    /*!
        will recursive call the UpdateViewDependentObjects routines of all the objects seen from the topobject.

        \remark TODO: Check all child objects (TODO for optimize: with flag 'm_childpixelsize=true').
    */
    void UpdateViewDependentObjects();

    //! If true render the printout with a title string, otherwise not
    void SetPrintTitle( bool val ) { m_printtitle = val; }

    //! If true render the printout with a filename string, otherwise not
    void SetPrintFilename( bool val ) { m_printfilename = val; }

    //! Set the scaling limit for printing, so that small stuff is not zoomed to full page
    void SetPrintScaleLimit( double val ) { m_printscalelimit = val; }

    //! If true, draw a frame around printouts
    void SetPrintFrame( bool val ) { m_printframe = val; }

    //! If true, draw a view on all page without real scale
    void SetPrintFitToPage( bool val ) { m_printfittopage = val; }

    //! get mouse position X
    int GetMouseX() { return m_mouse_x; }
    //! get mouse position Y
    int GetMouseY() { return m_mouse_y; }

    //! get mouse position X in world coordinates
    int GetWorldMouseX() { return (int)m_drawer2D->DeviceToWorldX(m_mouse_x); }
    //! get mouse position Y in world coordinates
    int GetWorldMouseY() { return (int)m_drawer2D->DeviceToWorldY(m_mouse_y); }

    //! convert mouse position as seen from the display window, into world coordinates.
    //! If no display window is defined, 
    void MouseToToolWorld( int x, int y, double& xWorldLocal, double& yWorldLocal );

protected:

    //! Default handler for wxEVT_ACTIVATE_VIEW called when the view gets the focus or something else needs
    /*!
        to have this view the active view ( the one which recieves events from the containing window ).   
        This drawer is set (non)active for the a2dCanvasDocument which is displayed on this drawer.

        \remark at least called when a2dCanvasView gets the focus

        \sa wxView::Activate
    */
    void OnActivate( a2dViewEvent& activateEvent );

    void OnEnter( wxMouseEvent & WXUNUSED(event) );

    //! redraw and/or blit pending areas to the device
    void OnIdle(wxIdleEvent &event);

    //! normally sent from wxWindow containing the view, via its ProcessEvent(wxEvent& event)
    void OnMouseEvent( wxMouseEvent &event );

    //! normally sent from wxWindow containing the view, via its ProcessEvent(wxEvent& event)
    /*!
        
    */
    void OnCharEvent( wxKeyEvent &event );

    //! next to base class functionality, 
    /*!
        this here removes or resets the toolcontroller.
        The wxEVT_CLOSE_VIEW is first sent to the m_toolcontroller, so in there it is
        intercepted too.
    */
    void OnCloseView( a2dCloseViewEvent& event );

    //! called for a2dComEvent events.
    void OnComEvent( a2dComEvent& event );

    //! called when document of the a2dView has changed.
    /*!
        Sets the a2dCanvasDocument where the objects for this canvas are stored
        It will trigger boundingbox calculation and other administrative tasks
        to properly render the document onto this view
    */
    void OnSetDocument( a2dViewEvent& event );

    //!redraw the pending update areas to the buffer given in device coordinates.
    void RedrawPendingUpdateAreas( bool noblit = false );

    //!pending update areas in the update list are deleted.
    /*! use when ready with updates, or when they become useless because of scroll etc.
    */
    void DeleteAllPendingAreas();

    //! based on angle and radius and m_aberration calculate a proper delta phi and number of segments
    /*!
        The calculation is used for circular arc segments
    */
    void Aberration( double angle, double radius, double& dphi, unsigned int& segments );

    //!buffer updating activity possible or not
    bool m_frozen;

    //!object that is receiving events
    a2dCanvasObjectPtr m_capture;

    //! when a corridor is active, this is set.
    a2dCanvasObjectPtr m_endCorridorObject;

    //!enable/ disable mouse events handling by canvas
    bool m_mouseevents;

    //!top object for drawer object, from here the rendering starts
    a2dCanvasObjectPtr m_top;

    //!background fill of canvas and background color of background fill in case of mono colour fill
    a2dFill m_backgroundfill;

    //!showorigin?
    bool m_showorigin;

    //!grid drawn at front or back
    bool m_gridatfront;

    //! is croshair visible
    bool m_crosshair;

    //!crosshair x
    int m_crosshairx;

    //!crosshair y
    int m_crosshairy;

    //! crosshair cursor Length in X in pixels
    int  m_crosshairLengthX;

    //! crosshair cursor Length in Y in pixels
    int  m_crosshairLengthY;

    //! stroke to use for crosshair
    a2dStroke m_crosshairStroke;

    //! last mouse position
    int m_mouse_x, m_mouse_y;

    //!grid stroke
    a2dStroke m_gridstroke;

    //!grid fill
    a2dFill m_gridfill;

    //!fixed style stroke
    a2dStroke m_fixStroke;

    //!fixed style fill
    a2dFill m_fixFill;

    //!overlay style stroke
    a2dStroke m_overlayStroke;

    //!overlay style fill
    a2dFill m_overlayFill;

    //!select style stroke
    a2dStroke m_selectStroke;

    //!select style fill
    a2dFill m_selectFill;

    //!highLight style stroke
    a2dStroke m_highLightStroke;

    //!highLight style fill
    a2dFill m_highLightFill;

    //!grid distance in x
    double m_gridx;

    //!grid distance in y
    double m_gridy;

    //!grid point size
    wxUint16 m_gridsize;

    //!show grid as lines
    bool m_gridlines;

    //! threshold for grid.
    wxUint16 m_gridthres;

    //!grid on/off
    bool m_grid;

    //!is the virtual area set already (used during startup)
    bool m_virtualarea_set;

    //!device size width
    int m_width;

    //!device size height
    int m_height;

    //! accuracy of spline
    double m_splineaberration;

    //! pushed clipping regions
    a2dClipRegionList   m_clipregionlist;

    //!accuracy of arc segment calculation etc. in device coordinates
    double m_displayaberration;

    //!list of rectangles that need to be blited to the screen.
    /*!
        This list holds several rectangles, which should be updated.
        The are blitted from the buffer, since they were damaged they first need to be updated.
    */
    a2dUpdateList m_updateareas;

    //!to prevent recursive updates
    bool m_recur;

    //! toolscontroller plugged in as first event handler
    a2dSmrtPtr<a2dToolContr> m_toolcontroller;

    a2dDrawer2D *m_drawer2D;

    //! how close does a hit need to be to the object you are trying to hit.
    /*! This is given in device units (pixels) and tranformed to world units
        using the drawers transform
    */
    wxUint16 m_hitmargin;

    //! underneath the threshold draw rectangles.
    bool m_asrectangle;

    //! drawstyles to use when rendering document
    wxUint32 m_documentDrawStyle;

    //! drawstyles to use when rendering overlay
    a2dDocumentRenderStyle m_overlayDrawStyle;

    //! to restore style after a temporary change.
    wxUint32 m_documentDrawStyleRestore;

    //! if true, a printout is done with title (document name (description?)), otherwise not
    bool m_printtitle;

    //! if true, a printout is done with filename (document file path), otherwise not
    bool m_printfilename;

    //! Set the scaling limit for printing, so that small stuff is not zoomed to full page
    double m_printscalelimit;

    //! If true, draw a frame around printouts
    bool m_printframe;

    //! If true, draw a view on all page without real scale
    bool m_printfittopage;

    //! which layer should be rendered ( visible and/or available )
    a2dLayerView m_layerRenderArray[wxMAXLAYER];

    //!flag to updatelayers that are available.
    /*! 
        It is set when m_layerRenderArray does not contain all layers used by a2dCanvasObject's
    */
    bool m_update_available_layers;

    //! tiles on drawing surface, used to optimize update areas.
    a2dTiles m_tiles;

    a2dTiles m_tiles2;

    //!draw in reverse order if set
    bool m_reverse_order;

    bool m_viewDependentObjects;

    a2dCursorStack m_cursorStack;

    a2dCanvasObjectList m_overlayObjects;

public:

    bool m_skipBuffer;

    DECLARE_DYNAMIC_CLASS(a2dCanvasView)

private:

    //initialize a drawer
    void Init();

public:

    static a2dPropertyIdUint16* PROPID_drawstyle;
    static a2dPropertyIdBool* PROPID_gridlines;
    static a2dPropertyIdBool* PROPID_grid;
    static a2dPropertyIdBool* PROPID_showorigin;
    static a2dPropertyIdUint16* PROPID_hitmargin;
    static a2dPropertyIdBool* PROPID_gridatfront;
    static a2dPropertyIdUint16* PROPID_gridsize;
    static a2dPropertyIdUint16* PROPID_gridthres;
    static a2dPropertyIdDouble* PROPID_gridx;
    static a2dPropertyIdDouble* PROPID_gridy;

    //! when more layers changed ( rerendering view is needed).
    static const wxEventType sm_changedLayers;
    //! when an object is added to a layer, and therefore makes this layer available.
    static const wxEventType sm_changedLayerAvailable;
    //! when one layer is set visible in a2dCanvasView
    static const wxEventType sm_changedLayerVisibleInView;
    //! sent when activating a frame ( maybe containing several a2dView's ), used to update dialogs for the current
    //! active frame which shows some views.
    static const wxEventType sm_changedActiveView;

    //! id for changed a2dObject
    //! a new show object was chosen in a2dCanvasView
    static const wxEventType sm_changedShowObject;

    DECLARE_PROPERTIES()

};  

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


//! view to display the size of a2dCanvasView compared to the whole of the a2dCanvasDocument that is viewed. 
/*!
    \ingroup docview
*/
class A2DCANVASDLLEXP a2dZoomedView: public wxWindow
{
    DECLARE_EVENT_TABLE()

public:

    //! constructor
    a2dZoomedView( wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, a2dCanvasView* canvasview );

    //!destructor
    virtual ~a2dZoomedView();

protected:

    //! called for a2dComEvent events.
    void OnComEvent( a2dComEvent& event );

    //! \cond

    void OnUpdate( a2dDocumentEvent& event );

    //! repaint damaged araes.
    void OnPaint( wxPaintEvent &event );

    void OnRemoveView( a2dDocumentEvent& event );

    //! resize 
    void OnSize( wxSizeEvent &event );

    //! \endcond

    //! the view to view zoomed  
    a2dCanvasView* m_canvasDocview;

    DECLARE_CLASS(a2dZoomedView)

private:


};  







#endif /* __WXDRAWER_H__ */

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