drawer.cpp

Go to the documentation of this file.

/*! \file canvas/src/drawer.cpp
    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: drawer.cpp,v 1.241 2009/09/30 18:38:59 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/canvas/layerinf.h"
#include "wx/canvas/drawer.h"

#include "wx/canvas/candoc.h"
#include "wx/canvas/cancom.h"
#include "wx/canvas/canvas.h"
#include "wx/canvas/cansim.h"
#include "wx/canvas/tools.h"
#include "wx/artbase/drawer2d.h"
#include "wx/artbase/dcdrawer.h"
#include "wx/canvas/canglob.h"
#include "wx/canvas/algos.h"

#include <wx/wfstream.h>

#define CROSS_HAIR_X  300
#define CROSS_HAIR_Y  300

//----------------------------------------------------------------------------
// a2dCursorStack
//----------------------------------------------------------------------------

a2dCursorStack::a2dCursorStack()
{
}

//----------------------------------------------------------------------------
// globals
//----------------------------------------------------------------------------
WX_DEFINE_LIST(a2dUpdateListBase);


#ifdef CLASS_MEM_MANAGEMENT
a2dMemManager a2dUpdateList::sm_memManager(wxT("a2dUpdateList memory manager"));
#endif //CLASS_MEM_MANAGEMENT

//----------------------------------------------------------------------------
// a2dTileBox
//----------------------------------------------------------------------------
a2dTileBox::a2dTileBox(int x1, int y1, int x2, int y2 )
{
    Init(x1,y1,x2,y2);
}

a2dTileBox::~a2dTileBox()
{
}

void a2dTileBox::Init(int x1, int y1, int x2, int y2 )
{
    m_x1 = x1;
    m_y1 = y1;
    m_x2 = x2;
    m_y2 = y2;
    m_rectPrevRow = NULL;
    m_valid = false;
    if ( m_x1 != m_x2 && m_y1 != m_y2 ) 
        m_valid = true;
}

void a2dTileBox::Expand( int x1, int y1, int x2, int y2 )
{
    if (!m_valid)
    {
        m_x1 = x1; m_y1 = y1;
        m_x2 = x2; m_y2 = y2;
    }
    else
    {
        m_x1 = wxMin(m_x1, x1);
        m_x2 = wxMax(m_x2, x2);
        m_y1 = wxMin(m_y1, y1);
        m_y2 = wxMax(m_y2, y2);
    }
    if ( m_x1 != m_x2 && m_y1 != m_y2 ) 
        m_valid = true;
}

//----------------------------------------------------------------------------
// a2dTiles
//----------------------------------------------------------------------------
a2dTiles::a2dTiles(int width, int height): m_tiles( width * height ) 
{
    m_width = width;
    m_height = height;
}

a2dTiles::~a2dTiles()
{
}

void a2dTiles::SetSize(int width, int height)
{
    m_tiles.resize( width * height );
    m_width = width;
    m_height = height;
}

void a2dTiles::Clear()
{
    int t;
    for (t = 0; t < m_tiles.size(); t++)
    {
        m_tiles[t].m_valid = false; 
        m_tiles[t].m_rectPrevRow = NULL;
    }
}

bool a2dTiles::HasFilledTiles()
{
    int t;
    for (t = 0; t < m_tiles.size(); t++)
        if ( m_tiles[t].m_valid == true )
            return true;
    return false;
}

void a2dTiles::DrawTiles( a2dDrawer2D* drawer )
{
    int x,y;
    drawer->PushIdentityTransform();

    drawer->SetDrawerStroke( a2dStroke( wxColour(0,0,0),1  ) );

    for (y = 0; y < m_height; y++)
    {
        drawer->DrawLine( 0, toP(y), toP(m_width), toP(y) );
        for (x = 0; x < m_width; x++)
        {
            drawer->DrawLine( toP(x), 0, toP(x), toP(m_height) );
        }
    }

    drawer->SetDrawerStroke( a2dStroke( wxColour(210,22,25),2 ) );
    drawer->SetDrawerFill( a2dFill( wxColour(10,187,15), a2dFILL_HORIZONTAL_HATCH ) );

    for (y = 0; y < m_height; y++)
    {
        for (x = 0; x < m_width; x++)
        {
            a2dTileBox box = m_tiles[ x + y*m_width ];
            if ( box.m_valid )
            {
                int x1 = toP(x) + box.m_x1;
                int y1 = toP(y) + box.m_y1;
                int x2 = toP(x) + box.m_x2;
                int y2 = toP(y ) + box.m_y2;
                drawer->DrawRoundedRectangle( x1, y1, x2 - x1, y2 - y1, 0 );
            }
        }
    }
    drawer->PopTransform();
}

void a2dTiles::DrawRects( a2dDrawer2D* drawer )
{
    drawer->PushIdentityTransform();

    a2dUpdateList* a2dTiles = GenerateUpdateRectangles();

    a2dUpdateList::compatibility_iterator nodeb = a2dTiles->GetFirst();
    while (nodeb)
    {
        a2dUpdateArea* uobj = nodeb->GetData();

        int x,y,width,height;
        x = uobj->x;
        y = uobj->y;
        width = uobj->width;
        height = uobj->height;

        drawer->DrawRoundedRectangle( x, y, width, height, 0 );

        nodeb = nodeb->GetNext();
    }

    drawer->PopTransform();
    a2dTiles->DeleteContents( true );
    delete a2dTiles;
}

void a2dTiles::FillTiles( const wxRect& rect, bool expand )
{
    FillTiles( rect.x, rect.y, rect.width, rect.height, expand );
}

void a2dTiles::FillTiles(  int xr, int yr, int w, int h, bool expand )
{
    int x, y, x1, y1, x2, y2; //maximum and minimum tile corners which rect fits in
    
    if ( !w|| !h )          
        return;

    int widthPix = m_width * a2d_TILESIZE;
    int heightPix = m_height * a2d_TILESIZE;
    // clip to buffer
    if (xr < 0)
    {
        w += xr;
        xr = 0;
    }
    if (w <= 0) return;

    if (yr < 0)
    {
        h += yr;
        yr = 0;
    }
    if (h <= 0) return;

    if (xr+w > widthPix )
    {
        w = widthPix - xr;
    }
    if (w <= 0) return;

    if (yr+h > heightPix )
    {
        h = heightPix - yr;
    }
    if (h <= 0) return;

    if ( !expand )
        Clear();

    x1 = toT( xr );
    y1 = toT( yr );
    x2 = toT( xr + w + a2d_TILESIZE );
    y2 = toT( yr + h + a2d_TILESIZE );

    int width = x2 - x1; //tiles to check in x
    int height = y2 - y1; //tiles to check in y
 
    int tx1, ty1, tx2, ty2; //rest at corner tiles.

    // get the rest at the corners of the rectangle, which partly covers 4 tiles.
    tx1 = ModT(xr);
    ty1 = ModT(yr);
    // E.G Tiles(0 -> 255) ( 0 ->255 ) == pixels (0 -> 611) 
    tx2 = ModT( xr + w );
    ty2 = ModT( yr + h );
    if (height == 1)
    {
        if (width == 1)
            m_tiles[ x1 + y1*m_width ].Expand( tx1, ty1, tx2, ty2 );
        else
        {
            int ti = x1 + y1*m_width;
            m_tiles[ ti++ ].Expand( tx1, ty1, a2d_TILESIZE-1, ty2 );
            for (x = 1; x < width-1; x++)
                m_tiles[ ti++ ].Expand(0, ty1, a2d_TILESIZE-1, ty2);
            m_tiles[ ti++ ].Expand( 0, ty1, tx2, ty2 );
        }
    }
    else
    {
        if (width == 1)
        {
            m_tiles[ x1 + y1*m_width ].Expand( tx1, ty1, tx2, a2d_TILESIZE-1 );
            for ( y = 1; y < height-1; y++)
                m_tiles[ x1 + (y1+y)*m_width ].Expand( tx1, 0, tx2, a2d_TILESIZE-1);
            m_tiles[ x1 + (y1+y)*m_width ].Expand( tx1, 0, tx2, ty2 );
        }
        else
        {
            //bottom row
            int ti = x1 + y1*m_width;
            m_tiles[ ti++ ].Expand( tx1, ty1, a2d_TILESIZE-1, a2d_TILESIZE-1 );
            for (x = 1; x < width-1; x++)
                m_tiles[ ti++ ].Expand(  0, ty1, a2d_TILESIZE-1, a2d_TILESIZE-1 );
            m_tiles[ ti++ ].Expand( 0, ty1, tx2, a2d_TILESIZE-1 );

            //all in the middle rows
            for (y = 1; y < height-1; y++)
            {
                ti = x1 + (y1+y)*m_width;
                m_tiles[ ti++ ].Expand( tx1, 0, a2d_TILESIZE-1, a2d_TILESIZE-1 );
                for (x = 1; x < width-1; x++)
                    m_tiles[ ti++ ].Expand(  0, 0, a2d_TILESIZE-1, a2d_TILESIZE-1 );
                m_tiles[ ti++ ].Expand(0, 0, tx2, a2d_TILESIZE-1 );
            }

            ti = x1 + (y1+y)*m_width;
            //top row
            m_tiles[ ti++ ].Expand( tx1, 0, a2d_TILESIZE-1, ty2 );
            for (x = 1; x < width-1; x++)
                m_tiles[ ti++ ].Expand( 0, 0, a2d_TILESIZE-1, ty2 );
            m_tiles[ ti++ ].Expand( 0, 0, tx2, ty2 );
        }
    }
}

a2dUpdateList* a2dTiles::GenerateUpdateRectangles()
{
    a2dUpdateList* rects = new a2dUpdateList();

    GenerateUpdateRectangles( rects, 0 );

    return rects;
}

void a2dTiles::GenerateUpdateRectangles( a2dUpdateList* rects, wxUint8 id )
{
    int x1, y1, x2, y2; 

    a2dTileBox tile;
    //tile indexes
    int tilei,lefttilei;
    int x, y;
    tilei = 0;
    for (y = 0; y < m_height; y++)
    {
        for (x = 0; x < m_width; x++)
        {
            tile = m_tiles[ tilei ];
            if ( tile.m_valid )
            {
                x1 = toP(x) + tile.m_x1;
                y1 = toP(y) + tile.m_y1;
                y2 = toP(y) + tile.m_y2;

                lefttilei = tilei;

                //extend rectangle to the right when this one is full in x and other is 
                //continue-ing at same y1 and y2
                tile = m_tiles[tilei];
                while (x != m_width - 1 &&
                   tile.m_x2 == (a2d_TILESIZE-1) && //this tile connect to next tile in x
                   m_tiles[tilei + 1].m_x1 == 0 &&
                   tile.m_y1 == m_tiles[tilei + 1].m_y1 &&
                   tile.m_y2 == m_tiles[tilei + 1].m_y2 
                )
                {
                    tilei++;
                    tile = m_tiles[tilei];
                    x++;
                }
                x2 = toP(x) + tile.m_x2; 

                //if we found some tiles filled ( and combined ) in this row?
                if ((x1 ^ x2) | (y1 ^ y2)) 
                {
                    a2dUpdateArea* prevRows = m_tiles[lefttilei].m_rectPrevRow;
                    if ( prevRows && 
                         x1 == prevRows->x &&
                         x2 == prevRows->x + prevRows->width  &&
                         y1 == prevRows->y + prevRows->height +1 //only when y1 is at border to previous row
                    )
                    {
                        //extend lower rectangle with this one
                        prevRows->height = y2 - prevRows->y;
                    }
                    else
                    {
                        //add a new rectangle for output, and use it as prevRow pointer in coming row
                        prevRows = new a2dUpdateArea( x1, y1, x2 - x1, y2 - y1, id );
                        rects->Append( prevRows );
                    }

                    //store the found rect or NULL inside the coming row, in order to later merge with that row
                    // its found rectangles when possible.
                    if (y != m_height - 1 )
                        m_tiles[lefttilei + m_width].m_rectPrevRow = prevRows; 
                }               
            }
            tilei++;
        }    
    }
}

//----------------------------------------------------------------------------
// a2dUpdateArea
//----------------------------------------------------------------------------
#ifdef CLASS_MEM_MANAGEMENT
a2dMemManager a2dUpdateArea::sm_memManager(wxT("a2dUpdateArea memory manager"));
#endif //CLASS_MEM_MANAGEMENT

a2dUpdateArea::a2dUpdateArea(int x, int y, int width, int height, wxUint8 id ):wxRect(x,y,width,height)
{
    m_update_done = false;
    m_update_direct = false;
    m_id = id;
}

a2dUpdateArea::~a2dUpdateArea()
{
}


//----------------------------------------------------------------------------
// a2dViewPrintout
//----------------------------------------------------------------------------

#if wxUSE_PRINTING_ARCHITECTURE
/* print out for drawer */
a2dViewPrintout::a2dViewPrintout( a2dCanvasView* drawingView,const wxString& title, const wxString& filename, a2dCommand* typeOfPrint, bool drawframe, double scalelimit, bool fitToPage ) : a2dDocumentPrintout( drawingView, title )
{
    m_typeOfPrint = typeOfPrint;
    m_drawingView = drawingView;
    m_title = title;
    m_filename = filename;
    m_scalelimit = scalelimit;
    m_drawframe = drawframe;
    m_fitToPage = fitToPage;
}

a2dViewPrintout::~a2dViewPrintout(void)
{
}

bool a2dViewPrintout::OnPrintPage(int)
{
    wxDC* dc;
    dc = GetDC();

    int w,h;
    dc->GetSize(&w, &h);

/*TODO do i need this??

    // Add the margin to the graphic size

    double marginX = 25;
    double marginY = 25;

    double maxX = w + (2*marginX);
    double maxY = h + (2*marginY);

    double scaleX=(w/maxX);
    double scaleY=(h/maxY);

    double actualScale = wxMin(scaleX,scaleY);

    // Calculate the position on the DC for centering the graphic
    double posX = ((w - (maxX*actualScale))/2.0);
    double posY = ((h - (maxY*actualScale))/2.0);
*/
    int marginX = (int)(h * 0.015);
    int marginY = marginX;
    int fontMarginYTop = 0;
    int fontMarginYBottom = 0;
    wxFont fontTitle = wxFont(marginY,wxDEFAULT,wxNORMAL,wxNORMAL);
    wxFont fontFilename = wxFont(int(marginY/2.+0.5),wxDEFAULT,wxNORMAL,wxNORMAL);

    //! needed ?
    dc->SetBrush(*wxWHITE_BRUSH);
    dc->SetBackground(*wxWHITE_BRUSH);
    dc->Clear();

    dc->SetBackgroundMode(wxTRANSPARENT);

    dc->SetTextForeground(*wxBLACK);
    dc->SetBrush(*wxTRANSPARENT_BRUSH);

    if ( !m_title.IsEmpty() )
    {
        dc->SetFont(fontTitle);
        fontMarginYTop += 2*fontTitle.GetPointSize();
        wxCoord xExtent, yExtent;
        dc->GetTextExtent(m_title, &xExtent, &yExtent);
        dc->DrawText(m_title, w/2-xExtent/2, marginY );
    }

    if ( !m_filename.IsEmpty() )
    {
        dc->SetFont(fontFilename);
        fontMarginYBottom += 2*fontFilename.GetPointSize();
        dc->DrawText(m_filename, marginX, h - marginY - fontMarginYBottom);
    }
    // Add the margin to the graphic size
    int widthX = w - (2*marginX);
    int widthY = h - (2*marginY+fontMarginYTop+fontMarginYBottom);

    if( m_drawframe )
    {
        dc->DrawRectangle(marginX,marginY+fontMarginYTop,widthX,widthY);
        const wxPen& aPenForFrame = dc->GetPen();
        int penWidth = aPenForFrame.GetWidth();
        marginX += penWidth;
        marginY += penWidth;
        widthX -= 2*penWidth;
        widthY -= 2*penWidth;
    }
    dc->SetBackgroundMode(wxSOLID);
    dc->SetFont(wxNullFont);

    double scaleX = (widthX/ (double) w);
    double scaleY = (widthY/ (double) h);
//  double scaleX = (w/widthX);
//  double scaleY = (h/widthY);

    if(!m_fitToPage)
    {
        double actualScale = wxMax(scaleX,scaleY);

        if( actualScale < m_scalelimit )
            actualScale = m_scalelimit;
        scaleX = scaleY = actualScale;
    }

    //if scale in X and Y did change, adjust incoming Dc to draw draw on that exact area.
    // Calculate the position on the DC for centering the graphic
    int posX = marginX + Round((w - (widthX/scaleX))/2.0);
    int posY = marginY + fontMarginYTop + Round((h - (widthY/scaleY))/2.0);

    // Set the scale and origin
//  dc->SetUserScale(scaleX, scaleY);
    dc->SetDeviceOrigin(posX, posY);

    //! now draw to the area within the margins
    a2dDcDrawer* dcdrawer = new a2dDcDrawer(widthX,widthY);
    dcdrawer->SetPrintMode( true );
    dcdrawer->SetRealScale(!m_fitToPage);

    // initialize with the view to print, but scaling  will be changed later.
    a2dSmrtPtr<a2dCanvasView> drawView = new a2dCanvasView( *m_drawingView );

    //drawView is a a2dView and therefore gets events, but this is not wanted here.
    drawView->SetEvtHandlerEnabled( false );
    drawView->SetDrawer2D( dcdrawer );

    // take some important settings from the view where this a2dViewPrintout was created:
    // see a2dCanvasView::OnCreatePrintout() 
    a2dCanvasDocument* doc = m_drawingView->GetCanvasDocument();
    drawView->SetDocument( doc );
    drawView->SetShowObject( m_drawingView->GetShowObject());
    drawView->SetDocumentDrawStyle( m_drawingView->GetDocumentDrawStyle() );
    dcdrawer->SetYaxis( m_drawingView->GetDrawer2D()->GetYaxis() );

    if (   m_typeOfPrint->GetCommandId() == &a2dCommand_Print::Id )
    {
        a2dCommand_Print* printcmd = wxStaticCast( m_typeOfPrint, a2dCommand_Print );
        if ( a2dCommand_Print::PrintView == printcmd->What() ||
             a2dCommand_Print::PreviewView == printcmd->What() )
        {
                dcdrawer->SetMappingWidthHeight( m_drawingView->GetDrawer2D()->GetVisibleMinX(),
                                                 m_drawingView->GetDrawer2D()->GetVisibleMinY(),
                                                 m_drawingView->GetDrawer2D()->GetVisibleWidth(),
                                                 m_drawingView->GetDrawer2D()->GetVisibleHeight());
        }
        else //default do all of document
        {
            drawView->SetMappingShowAll();
        }
    }
    else //default do all of document
    {
        drawView->SetMappingShowAll();
    }

    //now start drawing the document on our created view 
    dcdrawer->SetRenderDC(dc); //a trick to set the drawers internal dc.

//klion: for debug origin    drawView->UpdateArea( posX/2.,posY/2.,widthX,widthY );
    drawView->UpdateArea( 0, 0,widthX,widthY );
    
    dcdrawer->SetRenderDC(NULL);

    drawView->SetClosed();
    return true;
}
#endif //wxUSE_PRINTING_ARCHITECTURE

//----------------------------------------------------------------------------
// a2dCanvasView
//----------------------------------------------------------------------------

a2dPropertyIdUint16* a2dCanvasView::PROPID_drawstyle = NULL;
a2dPropertyIdBool* a2dCanvasView::PROPID_gridlines = NULL;
a2dPropertyIdBool* a2dCanvasView::PROPID_grid = NULL;
a2dPropertyIdBool* a2dCanvasView::PROPID_showorigin = NULL;
a2dPropertyIdUint16* a2dCanvasView::PROPID_hitmargin = NULL;
a2dPropertyIdBool* a2dCanvasView::PROPID_gridatfront = NULL;
a2dPropertyIdUint16* a2dCanvasView::PROPID_gridsize = NULL;
a2dPropertyIdUint16* a2dCanvasView::PROPID_gridthres = NULL;
a2dPropertyIdDouble* a2dCanvasView::PROPID_gridx = NULL;
a2dPropertyIdDouble* a2dCanvasView::PROPID_gridy = NULL;

INITIALIZE_PROPERTIES( a2dCanvasView, a2dView )
{
    A2D_PROPID_D( a2dPropertyIdUint16, drawstyle, a2dFILLED );
    A2D_PROPID_M( a2dPropertyIdBool, a2dCanvasView, gridlines, false, m_gridlines );
    A2D_PROPID_M( a2dPropertyIdBool, a2dCanvasView, grid, false, m_grid );
    A2D_PROPID_M( a2dPropertyIdBool, a2dCanvasView, showorigin, false, m_showorigin );
    A2D_PROPID_M( a2dPropertyIdBool, a2dCanvasView, gridatfront, false, m_gridatfront );
    A2D_PROPID_M( a2dPropertyIdUint16, a2dCanvasView, hitmargin, 0, m_hitmargin );
    A2D_PROPID_M( a2dPropertyIdUint16, a2dCanvasView, gridsize, 0, m_gridsize );
    A2D_PROPID_M( a2dPropertyIdUint16, a2dCanvasView, gridthres, 0, m_gridthres );
    A2D_PROPID_M( a2dPropertyIdDouble, a2dCanvasView, gridx, 0, m_gridx );
    A2D_PROPID_M( a2dPropertyIdDouble, a2dCanvasView, gridy, 0, m_gridy );
    return true;
}

DEFINE_EVENT_TYPE( a2dCanvasView::sm_changedLayers )
DEFINE_EVENT_TYPE( a2dCanvasView::sm_changedLayerAvailable )
DEFINE_EVENT_TYPE( a2dCanvasView::sm_changedLayerVisibleInView )
DEFINE_EVENT_TYPE( a2dCanvasView::sm_changedActiveView )
DEFINE_EVENT_TYPE( a2dCanvasView::sm_changedShowObject )

void a2dCanvasView::OnPropertyChanged( const a2dPropertyId* WXUNUSED(id) )
{
    Update();
}

IMPLEMENT_DYNAMIC_CLASS( a2dCanvasView, a2dView )

A2D_BEGIN_EVENT_TABLE(a2dCanvasView,a2dView)
    A2D_EVT_ENTER_WINDOW( a2dCanvasView::OnEnter )
    A2D_EVT_IDLE( a2dCanvasView::OnIdle )
    A2D_EVT_MOUSE_EVENTS( a2dCanvasView::OnMouseEvent )
    A2D_EVT_CHAR( a2dCanvasView::OnCharEvent )
    A2D_EVT_SET_DOCUMENT( a2dCanvasView::OnSetDocument )
    A2D_EVT_ACTIVATE_VIEW( a2dCanvasView::OnActivate )
    A2D_EVT_UPDATE_VIEWS( a2dCanvasView::OnUpdate )
    A2D_EVT_COM_EVENT( a2dCanvasView::OnComEvent )
    A2D_EVT_CLOSE_VIEW( a2dCanvasView::OnCloseView )
    A2D_EVT_DISCONNECT_ALLVIEWS( a2dCanvasView::OnDisConnectView )
A2D_END_EVENT_TABLE()

a2dCanvasView::a2dCanvasView( const wxSize& size ):
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    m_initCurrentSmartPointerOwner(this), 
#endif
    m_tiles( (size.GetWidth() >> a2d_TILESHIFT) + 1 , (size.GetHeight() >> a2d_TILESHIFT) + 1 ),  
    m_tiles2( (size.GetWidth() >> a2d_TILESHIFT) + 1 , (size.GetHeight() >> a2d_TILESHIFT) + 1 )  
{
    m_width = size.GetWidth();
    m_height = size.GetHeight();

    m_drawer2D  = new a2dMemDcDrawer( m_width, m_height );

    Init();
}

a2dCanvasView::a2dCanvasView( int width, int height ):
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    m_initCurrentSmartPointerOwner(this), 
#endif
    m_tiles( (width >> a2d_TILESHIFT) + 1 , (height >> a2d_TILESHIFT) + 1 ),  
    m_tiles2( (width >> a2d_TILESHIFT) + 1 , (height >> a2d_TILESHIFT) + 1 )  
{
    m_width = width;
    m_height = height;

    m_drawer2D  = new a2dMemDcDrawer( m_width, m_height );

    Init();
}

a2dCanvasView::a2dCanvasView( int width, int height, a2dDrawer2D * drawer ):
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    m_initCurrentSmartPointerOwner(this), 
#endif
    m_tiles( (width >> a2d_TILESHIFT) + 1 , (height >> a2d_TILESHIFT) + 1 ),  
    m_tiles2( (width >> a2d_TILESHIFT) + 1 , (height >> a2d_TILESHIFT) + 1 )  
{
    m_width = width;
    m_height = height;

    m_drawer2D  = drawer;
    m_drawer2D->DestroyClippingRegion();

    Init();
}

a2dCanvasView::a2dCanvasView( a2dDrawer2D * drawer ):
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    m_initCurrentSmartPointerOwner(this), 
#endif
    m_tiles( (drawer->GetWidth() >> a2d_TILESHIFT) + 1 , (drawer->GetHeight() >> a2d_TILESHIFT) + 1 ),  
    m_tiles2( (drawer->GetWidth() >> a2d_TILESHIFT) + 1 , (drawer->GetHeight() >> a2d_TILESHIFT) + 1 )  
{
    m_drawer2D  = drawer;
    m_width = drawer->GetWidth();
    m_height = drawer->GetHeight();    

    Init();
}

void a2dCanvasView::Init()
{
    // wxLogDebug( "(a2dCanvasView*)0x%p", this );

    m_reverse_order = a2dCanvasGlobals->GetReverseOrder();
    m_update_available_layers = true;

    m_recur = false;
    //we want all layers to be rendered and selected objects.
    m_documentDrawStyle = RenderLAYERED | a2dCanvasGlobals->GetSelectDrawStyle();
    m_overlayDrawStyle = RenderLAYERED;
    m_documentDrawStyleRestore = m_documentDrawStyle;
    m_fixFill = *a2dBLACK_FILL;
    m_fixStroke = *a2dBLACK_STROKE;
    m_overlayFill = *a2dBLACK_FILL;
    m_overlayStroke = *a2dBLACK_STROKE;

    m_selectFill = a2dCanvasGlobals->GetSelectFill();
    m_selectStroke = a2dCanvasGlobals->GetSelectStroke();
    if ( m_drawer2D && m_drawer2D->HasAlpha() )
    {
        m_highLightStroke = a2dStroke( wxColor( 0,255,255, 255 ), 2);
        m_highLightFill = a2dFill( wxColor( 255,122,0,165 ) );
    }
    else
    {
        m_highLightStroke = a2dStroke( wxColor( 0,255,255 ), 2);
        m_highLightFill = *a2dTRANSPARENT_FILL;
    }

    if (m_drawer2D)
    {
        m_drawer2D->SetDisplay( m_display );
    }

    m_toolcontroller = 0; //needed 

    //mouse events handled by canvas itself
    m_mouseevents=true;
    
    m_top  = 0;

    m_frozen = false;

    m_virtualarea_set = false;

    m_gridatfront = false;
    m_gridx = 100;
    m_gridy = 100;
    m_gridlines = false;
    m_gridthres = 5;
    m_gridsize = 0;
    m_grid = false;

    m_showorigin = true;

    m_backgroundfill = *a2dWHITE_FILL;
    m_gridstroke = *a2dBLACK_STROKE;
    m_gridfill = *a2dTRANSPARENT_FILL;

    m_capture = (a2dCanvasObject*)NULL;
    m_endCorridorObject = (a2dCanvasObject*)NULL;

    m_crosshairStroke = a2dStroke( wxColour(200,30,30), 0, a2dSTROKE_DOT );
    m_crosshair = false;
    m_crosshairx = 0;
    m_crosshairy = 0;
    m_crosshairLengthX = CROSS_HAIR_X;
    m_crosshairLengthY = CROSS_HAIR_Y;
    m_mouse_x = m_mouse_y = 0;

    m_hitmargin = a2dCanvasGlobals->GetHitMarginDevice();

    m_printtitle = true;
    m_printfilename = true;
    m_printscalelimit = 0;
    m_printframe = true;
    m_printfittopage = false;

    m_viewDependentObjects = false;
}

a2dCanvasView::~a2dCanvasView()
{
    //prevent event handling from now one ( else problem from event distributer can happen ).
    //Unregister is done in a2dView.
    SetEvtHandlerEnabled( false );    
    DeleteAllPendingAreas();

    m_display = NULL; //is used to test inside controllers.

    m_toolcontroller = 0;

    if ( m_drawer2D )
        delete m_drawer2D;
}

a2dCanvasView::a2dCanvasView( const a2dCanvasView& other)
    :a2dView( other ), 
    m_tiles( (other.m_width >> a2d_TILESHIFT) + 1 , (other.m_height >> a2d_TILESHIFT) + 1 ),
    m_tiles2( (other.m_width >> a2d_TILESHIFT) + 1 , (other.m_height >> a2d_TILESHIFT) + 1 )
#if defined(_DEBUG) && defined (SMART_POINTER_DEBUG)
    , m_initCurrentSmartPointerOwner(this) 
#endif
{
    m_drawer2D  = NULL;

    Init();

    m_backgroundfill = other.m_backgroundfill;

    m_gridatfront = other.m_gridatfront;

    m_gridstroke = other.m_gridstroke;

    m_gridfill = other.m_gridfill;

    m_fixFill = other.m_fixFill;
    m_fixStroke = other.m_fixStroke;

    m_overlayFill = other.m_overlayFill;
    m_overlayStroke = other.m_overlayStroke;

    m_selectFill = other.m_selectFill;
    m_selectStroke = other.m_selectStroke;

    m_gridx = other.m_gridx;
    m_gridy = other.m_gridy;
    m_gridlines = other.m_gridlines;
    m_gridsize = other.m_gridsize;
    m_gridthres = other.m_gridthres;

    m_showorigin = other.m_showorigin;

    m_grid = other.m_grid;

    m_top  = other.m_top;

    m_crosshairStroke = other.m_crosshairStroke;
    m_crosshair = other.m_crosshair;
    m_crosshairx = other.m_crosshairx;
    m_crosshairy = other.m_crosshairy;
    m_crosshairLengthX = other.m_crosshairLengthX;
    m_crosshairLengthY = other.m_crosshairLengthY;

    m_printtitle = other.m_printtitle;
    m_printfilename = other.m_printfilename;
    m_printscalelimit = other.m_printscalelimit;
    m_printframe = other.m_printframe;
    m_printfittopage = other.m_printfittopage;

    m_documentDrawStyle = other.m_documentDrawStyle;
    m_reverse_order = other.m_reverse_order;

}

void a2dCanvasView::SetReverseOrder(bool revorder) 
{ 
    m_reverse_order = revorder; 
    Update( a2dCANVIEW_UPDATE_ALL );
}

double a2dCanvasView::GetHitMarginWorld() const 
{
    assert( m_drawer2D );
    return m_drawer2D->DeviceToWorldXRel( m_hitmargin );
}

void a2dCanvasView::SetDisplayWindow( wxWindow* display )
{
    a2dView::SetDisplayWindow( display );
    if (m_drawer2D)
        m_drawer2D->SetDisplay( display );
}

void a2dCanvasView::SetBufferSize( int w, int h )
{
    m_width = w;
    m_height = h;
    m_tiles.SetSize( (w >> a2d_TILESHIFT) + 1, (h >> a2d_TILESHIFT) + 1 );
    m_tiles2.SetSize( (w >> a2d_TILESHIFT) + 1, (h >> a2d_TILESHIFT) + 1 );
    if (m_drawer2D)
        m_drawer2D->SetBufferSize( w, h );
}

void a2dCanvasView::SetDrawer2D( a2dDrawer2D* drawer2d, bool noDelete ) 
{ 
    if ( noDelete != true )
    {
        if (m_drawer2D)
            delete m_drawer2D;
    }
    m_drawer2D = drawer2d; 
    if (m_drawer2D)
    {
        m_drawer2D->SetDisplay( m_display );
        m_width = m_drawer2D->GetWidth();
        m_height = m_drawer2D->GetHeight();
        // klion: we change m_width and m_height, so we must change m_tiles
        m_tiles.SetSize( (m_width >> a2d_TILESHIFT) + 1, (m_height >> a2d_TILESHIFT) + 1 ); 
        m_tiles2.SetSize( (m_width >> a2d_TILESHIFT) + 1, (m_height >> a2d_TILESHIFT) + 1 ); 
    }
}


bool a2dCanvasView::SetCanvasToolContr( a2dToolContr* controller )
{
    a2dToolContr* returnc = m_toolcontroller;

    if ( m_toolcontroller ) //remove the old one
    {
        wxASSERT_MSG( m_toolcontroller->GetCanvasView() == this, wxT("a2dToolContr has different a2dCanvasView set for it") );
        m_toolcontroller->Disable();
    }

    if ( controller ) //set the new one
    {
        wxASSERT_MSG( controller->GetCanvasView() == this, wxT("a2dToolContr has different a2dCanvasView set for it") );
    }
    m_toolcontroller = controller;
    return returnc != 0;
}

bool a2dCanvasView::ProcessEvent(wxEvent& event)
{
    bool processed = false;

    // An event handler can be enabled or disabled
    if ( (GetEvtHandlerEnabled() && m_viewEnabled) ||
         (event.GetEventType() == wxEVT_ENABLE_VIEW) ||
         (event.GetEventType() == wxEVT_ENABLE_VIEWS) 
       )
    {
        //prevent the object from being deleted until this process event is at an end
        a2dREFOBJECTPTR_KEEPALIVE;

        if ( event.GetEventType() == wxEVT_IDLE )
        {
            processed = a2dView::ProcessEvent( event);
            if ( m_toolcontroller )
            {
                event.Skip(); //skipped because not processed so prepare for controller
                processed = m_toolcontroller->ProcessEvent( event );
            }
        }
        else if ( m_toolcontroller && event.GetEventType() == wxEVT_PAINT )
        {
            if (m_display)
            {
                SetEvtHandlerEnabled(false); //this event coming back from the display will not be handled
                event.ResumePropagation( wxEVENT_PROPAGATE_MAX );
                m_display->GetEventHandler()->ProcessEvent( event );
                event.StopPropagation();
                SetEvtHandlerEnabled(true);
            }
            processed = a2dView::ProcessEvent( event);
            if ( !processed )
            {
                event.Skip(); //skipped because not processed so prepare for controller
                processed = m_toolcontroller->ProcessEvent( event );
            }
        }
        else if ( m_toolcontroller && event.GetEventType() == a2dEVT_COM_EVENT )
        {
            // communication event of changes in state, should always continue
            processed = m_toolcontroller->ProcessEvent( event );
            event.Skip(); //skipped because not processed so prepare for view
            processed = a2dView::ProcessEvent( event);
        }    
        else if ( m_toolcontroller && event.GetEventType() == wxEVT_CHAR )
        {
            processed = m_toolcontroller->ProcessEvent( event );
            if ( !processed )
            {
                event.Skip(); //skipped because not processed so prepare for view
                processed = a2dView::ProcessEvent( event);
            }
        }
        else if ( m_toolcontroller && event.GetEventType() == wxEVT_KEY_DOWN )
        {
            processed = m_toolcontroller->ProcessEvent( event );
            if ( !processed )
            {
                event.Skip(); //skipped because not processed so prepare for view
                processed = a2dView::ProcessEvent( event);
            }
        }
        else if ( m_toolcontroller && event.GetEventType() == wxEVT_KEY_UP )
        {
            processed = m_toolcontroller->ProcessEvent( event );
            if ( !processed )
            {
                event.Skip(); //skipped because not processed so prepare for view
                processed = a2dView::ProcessEvent( event);
            }
        }
        else if ( m_toolcontroller )
        {
            processed = m_toolcontroller->ProcessEvent( event );
            if ( !processed )
            {
                event.Skip(); //skipped because not processed so prepare for view
                processed = a2dView::ProcessEvent( event);
            }
        }
        else 
        {
            processed = a2dView::ProcessEvent( event);
        }

        return processed;
    }

    return false;
}

void a2dCanvasView::OnEnter( wxMouseEvent& event )
{

    //if ( GetDisplayWindow() )
        //GetDisplayWindow()->SetFocus();

    event.Skip(); 
}

void a2dCanvasView::OnIdle(wxIdleEvent &event)
{
    //wxLogDebug( "void a2dCanvasView::OnIdle(wxIdleEvent &event)" );

    if ( m_frozen )
    {
        event.Skip(); //to the display of the drawer.
        return;
    }
    
    if (Get_UpdateAvailableLayers())
    {
        Update( a2dCANVIEW_UPDATE_ALL );
    }

    AddOverlayAreas( false );

    // only redraw the areas which are currently in the updatelist,
    // waiting to be redrawn. After they are redrawn, directly blit those areas
    // to the window ( if available ).
    if ( m_tiles.HasFilledTiles() || m_tiles2.HasFilledTiles() || m_updateareas.GetCount() )
    {
        // Although pending areas most often result from pending object in the first place,
        // in some cases pending area are added directly and not via pending objects.
        // In those cases it is possible that there are pendingobjects in the document which do not have their
        // boundingbox yet calculated. e.g. SetMappingShowAll() followed by adding new objects in the code.
        // This idle event is  first always sent to the document, so this should not be solved by arriving there first. 
        //Therefore if the GetCanvasDocument() has still pending objects wait until those have bin added too.
        
        //But better save then sorry!
        if ( GetCanvasDocument() && !GetCanvasDocument()->GetUpdatesPending() )
            Update( a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT ); 
    }

    event.Skip(); //to the display of this view.
}

void a2dCanvasView::AddOverlayAreas( bool update )
{
    if ( m_overlayObjects.size() )
    {    
        a2dCanvasObjectList::iterator iter = m_overlayObjects.begin();
        for( iter = m_overlayObjects.begin(); iter != m_overlayObjects.end(); ++iter )
        {
            a2dCanvasObjectList::value_type obj = *iter;
            if ( obj->GetPending() )
            {    
                AddPendingUpdateArea( obj, 1 );
                obj->Update( a2dCanvasObject::updatemask_normal );
                AddPendingUpdateArea( obj, 1 );
                obj->SetPending( false );
            }     
        }
    }

    if ( update && m_tiles2.HasFilledTiles() )
    {
        Update( a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT ); 
    }

}

void a2dCanvasView::AddOverlayObject( a2dCanvasObject* obj )
{
    obj->SetCanvasDocument( GetCanvasDocument() );
    m_overlayObjects.push_back( obj );
}

void a2dCanvasView::RemoveOverlayObject( a2dCanvasObject* obj )
{
    a2dCanvasObjectList::iterator iter = m_overlayObjects.begin();
    for( iter = m_overlayObjects.begin(); iter != m_overlayObjects.end(); ++iter )
    {
        a2dCanvasObjectList::value_type iobj = *iter;
        if ( iobj == obj )
        {    
            AddPendingUpdateArea( obj, 1 );
            m_overlayObjects.erase( iter );
            break;
        }     
    }
}

void a2dCanvasView::OnActivate(  a2dViewEvent& viewevent )
{
    //a2dCanvasView* view = (a2dCanvasView*) viewevent.GetEventObject();
    bool activate = viewevent.GetActive();

    if ( activate && GetCanvasDocument() && viewevent.GetEventObject() == this )
    {
        if ( GetDisplayWindow() && wxWindow::FindFocus() != GetDisplayWindow() )
        {
            GetDisplayWindow()->SetFocus();
            //wxLogDebug( "activate focus " );
        }
    }
}

void a2dCanvasView::SetDocumentDrawStyle( wxUint32 documentDrawStyle ) 
{  
    m_documentDrawStyleRestore = m_documentDrawStyle; m_documentDrawStyle = documentDrawStyle; 
}

void a2dCanvasView::SetOverlayDrawStyle( a2dDocumentRenderStyle drawstyle ) 
{  
    m_overlayDrawStyle = drawstyle;
}

void a2dCanvasView::Freeze()
{
    m_frozen = true;
}

void a2dCanvasView::Thaw(bool update)
{
    m_frozen = false;

    if (update)
    {
        Update( a2dCANVIEW_UPDATE_ALL );
    }
}

void a2dCanvasView::SetEndCorridorObject( a2dCanvasObject* endCorridorObject )
{
    m_endCorridorObject = endCorridorObject;
}

void a2dCanvasView::SetCursor(const wxCursor& cursor)
{
    if ( m_display )
        m_display->SetCursor( cursor );
}

void a2dCanvasView::PushCursor(const wxCursor& cursor)    
{
    m_cursorStack.push_back( cursor );
    if ( m_display )
        m_display->SetCursor( cursor );
}

void a2dCanvasView::PopCursor()
{
    m_cursorStack.pop_back();
    if ( m_display )
    {
        if ( m_cursorStack.size() )
            m_display->SetCursor( m_cursorStack.back() );
        else
            m_display->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  )  );
    }
}

void a2dCanvasView::ClearCursorStack()
{
    m_cursorStack.clear();
    if ( m_display )
        m_display->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  )  );
}

void a2dCanvasView::SetMouseEvents(bool onoff)
{
    m_mouseevents=onoff;
}

void a2dCanvasView::SetCrossHairStroke( const a2dStroke& crosshairStroke )
{
    m_crosshairStroke = crosshairStroke;
};


void a2dCanvasView::SetCrossHair( bool onoff )
{
    m_crosshair = onoff;
    Update( a2dCANVIEW_UPDATE_ALL );
}

void a2dCanvasView::MouseToToolWorld( int x, int y, double& xWorldLocal, double& yWorldLocal )
{
    if ( wxDynamicCast( GetDisplayWindow(), a2dCanvas ) )
    {
        //a2dCanvas is aligned with view its buffer origin
    }
    else if ( wxDynamicCast( GetDisplayWindow(), a2dCanvasSim ) )
    {
        //a2dCanvasSim its virtual origin is aligned with view its buffer origin
        a2dCanvasSim* can = wxStaticCast( GetDisplayWindow(), a2dCanvasSim );
        can->CalcUnscrolledPosition( x, y, &x , &y );
    }

    xWorldLocal = GetDrawer2D()->DeviceToWorldX(x);
    yWorldLocal = GetDrawer2D()->DeviceToWorldY(y);
}

void a2dCanvasView::OnMouseEvent(wxMouseEvent &event)
{
    m_mouse_x = event.GetX();
    m_mouse_y = event.GetY();

    UpdateCrossHair( m_mouse_x, m_mouse_y );

    if (!GetCanvasDocument() || !m_mouseevents)
    {
        event.Skip();
        return;
    }

    //to world coordinates to do hit test in world coordinates
    double xw = m_drawer2D->DeviceToWorldX( m_mouse_x );
    double yw = m_drawer2D->DeviceToWorldY( m_mouse_y );

    if (m_capture && !GetCanvasDocument()->Find( m_capture ) )
        m_capture = (a2dCanvasObject*) NULL;

    a2dIterC ic( this );
    a2dAffineMatrix cworld = GetShowObject()->GetTransformMatrix();
    cworld.Invert();
    a2dIterCU cu( ic, cworld );
    ic.SetPerLayerMode( false );
    ic.SetLayer( wxLAYER_ALL );
    a2dHitEvent hitinfo( xw, yw );
    hitinfo.m_event = &event;
    if ( GetShowObject()->ProcessCanvasObjectEvent( ic, hitinfo ) )
        return;
    event.Skip(); //windows containing view may handle it

    return;
}

void a2dCanvasView::OnCharEvent(wxKeyEvent &event)
{
    if (m_capture )
        m_capture->ProcessEvent(event);
    else
        event.Skip(); // to base class, but also a2dCanvas and tools.
}

bool a2dCanvasView::ProcessCanvasObjectEvent( wxEvent& event, bool& isHit,
                                         double x, double y, int margin,
                                         int layer )
{
    a2dIterC ic( this );
    ic.SetHitMarginDevice( margin );
    ic.SetPerLayerMode( false );
    ic.SetLayer( wxLAYER_ALL );
    a2dAffineMatrix cworld = GetShowObject()->GetTransformMatrix();
    cworld.Invert();
    a2dIterCU cu( ic, cworld );

    GetShowObject()->SetSpecificFlags( true, a2dCanvasOFlags::IsOnCorridorPath );
    a2dHitEvent hitinfo( x, y );
    hitinfo.m_event = &event;
    bool res = GetShowObject()->ProcessCanvasObjectEvent( ic, hitinfo );
    isHit = hitinfo.m_isHit;
    GetShowObject()->SetSpecificFlags( false, a2dCanvasOFlags::IsOnCorridorPath );
    return res;
}

bool a2dCanvasView::ProcessCanvasObjectEvent( a2dCanvasObjectEvent& event, bool& isHit, 
                   double x, double y, int margin, 
                   int layer )
{
    a2dIterC ic( this );
    ic.SetHitMarginDevice( margin );
    ic.SetPerLayerMode( false );
    ic.SetLayer( layer );
    a2dAffineMatrix cworld = GetShowObject()->GetTransformMatrix();
    cworld.Invert();
    a2dIterCU cu( ic, cworld );

    event.SetIterC( &ic );

    GetShowObject()->SetSpecificFlags( true, a2dCanvasOFlags::IsOnCorridorPath );
    a2dHitEvent hitinfo( x, y );
    hitinfo.m_event = &event;
    bool res = GetShowObject()->ProcessCanvasObjectEvent( ic, hitinfo );
    isHit = hitinfo.m_isHit;
    GetShowObject()->SetSpecificFlags( false, a2dCanvasOFlags::IsOnCorridorPath );
    return res;
}

bool a2dCanvasView::FindAndSetCorridorPath( a2dCanvasObject* findObject, bool capture )
{
    a2dWalker_FindAndSetCorridorPath findcorridor( findObject ); 
    findcorridor.Start( GetShowObject() );

    if( findcorridor.GetResult() )
    {
        SetEndCorridorObject( findObject );
        if( capture )
        {
            SetCaptured( findObject );
        }
        return true;
    }
    return false;
}

void a2dCanvasView::SetCorridorPath( const a2dCorridor& corridor )
{
    ClearCorridorPath( true );
    a2dCanvasObjectList::const_iterator iter = corridor.begin();
    while( iter != corridor.end() )
    {    
        a2dCanvasObjectList::value_type obj = *iter;
        obj->SetIsOnCorridorPath( true ); 
        iter++;
    }
    if ( !corridor.empty() )
        SetEndCorridorObject( corridor.back() );
    SetCaptured( corridor.GetCaptured() );
}  

void a2dCanvasView::ClearCorridorPath( bool uncapture )
{
    if( uncapture )
    {
        SetCaptured( NULL );
    }
    SetEndCorridorObject( NULL );

    if ( GetShowObject() )
    {
        a2dWalker_SetSpecificFlagsCanvasObjects setflags( a2dCanvasOFlags::IsOnCorridorPath );
        setflags.Start( GetShowObject(), false );
    }
}

a2dCanvasObject* a2dCanvasView::IsHitWorld( 
    double x, double y,
    int layer,
    a2dHitOption option,
    bool filterSelectableLayers
) 
{
    Update( a2dCANVIEW_UPDATE_PENDING );
    a2dIterC ic( this );
    ic.SetPerLayerMode( false );
    ic.SetLayer( layer );
    ic.SetObjectFilter( new a2dCanvasObjectFilterLayerMask( layer, a2dCanvasOFlags::VISIBLE | a2dCanvasOFlags::SELECTABLE ) );  

    a2dHitEvent hitinfo( x, y );
    hitinfo.m_option = option;
    //at the top level the group its matrix is to be ignored.
    //Since it is normally NOT ignored within a2dCanvasObject, force an inverse.
    hitinfo.m_xyRelToChildren = false;

    a2dCanvasObject* res = GetShowObject()->ChildIsHitWorld( ic, hitinfo, filterSelectableLayers );
    return res;
}

a2dCanvasObject* a2dCanvasView::IsHitWorld(
    a2dHitEvent& hitEvent,
    int layer
)
{
    Update( a2dCANVIEW_UPDATE_PENDING );
    a2dIterC ic( this );
    ic.SetLayer( layer );
    a2dCanvasObject* res = GetShowObject()->ChildIsHitWorld( ic, hitEvent );
    return res;
}

void a2dCanvasView::OnDraw(wxDC* WXUNUSED(dc) )
{
    wxFAIL_MSG( wxT("a2dCanvasView::OnDraw is not implemented, see a2dViewPrintout::OnPrintPage(int)") );
}


void a2dCanvasView::SetLayerCheck( wxUint16 layer )
{
    GetLayerRenderArray()[ layer ].SetCheck( true );   
    Set_UpdateAvailableLayers(true); //see OnIdle
}

void a2dCanvasView::SetAvailable()
{
    unsigned int j;
    for ( j=0; j < wxMAXLAYER; j++ )
    {
        m_layerRenderArray[j].SetCheck( false );
        m_layerRenderArray[j].SetAvailable( false );
    }
    //this one always available because editing handles are on it.
    m_layerRenderArray[wxLAYER_DEFAULT].SetAvailable( true );

    if ( m_top )
    {
        a2dWalker_SetAvailable set( this );
        set.Start( m_top );
    }
    Set_UpdateAvailableLayers(false);
}

void a2dCanvasView::OnCloseView( a2dCloseViewEvent& event )
{
    //when a view is closed, and a controller, and its tools or still active,
    //they need to be terminated and removed.

    if ( m_toolcontroller.Get() )
        m_toolcontroller->Disable();
    m_toolcontroller = 0;
    event.Skip();
}

void a2dCanvasView::OnComEvent( a2dComEvent& event )
{
    if ( GetEvtHandlerEnabled() )
    {
        if ( event.GetEventComId() == &sm_changedLayers )
        {
            Set_UpdateAvailableLayers(true);
        }
        else if ( event.GetEventComId() == &a2dCanvasObject::sm_changedLayer ) 
        {
            a2dCanvasObject* obj = wxDynamicCast( event.GetEventObject(), a2dCanvasObject );

            if ( obj->GetCanvasDocument() == m_viewDocument )
            {
                a2dNamedProperty *property = event.GetProperty();
                if ( property->GetUint16() != wxLAYER_ALL )
                    m_layerRenderArray[property->GetUint16()].SetAvailable( true );
                else 
                    Set_UpdateAvailableLayers(true);
            }
        }
        else if ( event.GetEventComId() == &a2dCanvasDocument::sm_layersetupChanged ) 
        {
            a2dCanvasDocument* doc = wxDynamicCast( event.GetEventObject(), a2dCanvasDocument );
            if ( doc == m_viewDocument )
                Update( a2dCANVIEW_UPDATE_ALL );
                //Set_UpdateAvailableLayers(true);
        }
        else if ( event.GetEventComId() == &a2dLayerInfo::sm_changedLayer ) 
        {
            a2dCanvasObject* obj = wxDynamicCast( event.GetEventObject(), a2dCanvasObject );
            if ( m_viewDocument == obj->GetCanvasDocument() )
                Update( a2dCANVIEW_UPDATE_ALL );
        }
        else
            event.Skip();
    }
    else
        event.Skip();
}

void a2dCanvasView::Update( unsigned int how, wxObject* hintObject )
{
    a2dView::Update( how, hintObject );
}

void a2dCanvasView::OnUpdate( a2dDocumentEvent& event )
{
    if ( !m_top )
        return;
        
    if ( m_viewDocument != event.GetEventObject() )
        return;

    if ( !GetEvtHandlerEnabled() )
        return;

    if (!GetCanvasDocument())
        return;

    // Same event may be received several times via different paths.
    // Only do it once, will same redraws               
    static long lastProcessedEventTimeStamp = -1; // for a2d...Events   
    if( lastProcessedEventTimeStamp == event.GetTimestamp() )
        return;
    lastProcessedEventTimeStamp = event.GetTimestamp();

    int how = a2dCANVIEW_UPDATE_ALL | a2dCANVIEW_UPDATE_BLIT ;

    if ( event.GetUpdateHint() != 0 )
        how = event.GetUpdateHint();

    //order of actions is important!

    if ( how & a2dCANVIEW_UPDATE_PENDING )
    {
        AddObjectPendingUpdates();
    }

    if ( how & a2dCANVIEW_UPDATE_VIEWDEPENDENT )
    {
        UpdateViewDependentObjects();
    }

    if ( how & a2dCANVIEW_UPDATE_OLDNEW )
    {
        GetCanvasDocument()->AddPendingUpdatesOldNew();
    }

    if ( how & a2dCANVIEW_UPDATE_ALL )
    {
        SetAvailable();
        DeleteAllPendingAreas();
        AddPendingUpdateArea( 0, 0, m_width, m_height );
    }

    if ( how & a2dCANVIEW_UPDATE_AREAS )
    {
        //redraw pending update areas into buffer
        RedrawPendingUpdateAreas();
    }

    if ( how & a2dCANVIEW_UPDATE_AREAS_NOBLIT )
    {
        //redraw pending update areas into buffer
        RedrawPendingUpdateAreas( true );
    }

    if ( how & a2dCANVIEW_UPDATE_BLIT )
    {
        if (GetCanvas() && GetCanvas()->IsShown() )
            BlitPendingUpdateAreas();
    }
}

void a2dCanvasView::DeleteAllPendingAreas()
{
    wxASSERT_MSG( m_recur == false, wxT("recursive calls in updating not allowed") );
    m_recur = true;

    m_tiles.Clear();
    m_tiles2.Clear();

    //all pending updates become redundant, make the list empty
    a2dUpdateList::compatibility_iterator nodeb = m_updateareas.GetFirst();
    while (nodeb)
    {
        a2dUpdateArea* uobj = nodeb->GetData();
        delete uobj;
        delete nodeb;
        nodeb = m_updateareas.GetFirst();
    }

    m_recur = false;
}

void a2dCanvasView::RedrawPendingUpdateAreas( bool noblit )
{
    if (m_frozen) return;

    if ( m_recur ) return; 
    wxASSERT_MSG( m_recur == false, wxT("recursive calls in updating not allowed") );

    m_recur = true;

    m_tiles.GenerateUpdateRectangles( &m_updateareas, 0 );
    m_tiles.Clear();
    m_tiles2.GenerateUpdateRectangles( &m_updateareas, 1 );
    m_tiles2.Clear();

    a2dUpdateList::compatibility_iterator nodeb = m_updateareas.GetFirst();
    while (nodeb)
    {
        a2dUpdateArea* uobj = nodeb->GetData();

        if (!uobj->m_update_done)
        {
            //update a little more then is strictly needed,
            //to get rid of the 1 bit bugs
            //SEE wxRect a2dCanvasObject::GetAbsoluteArea( const a2dAffineMatrix& cworld )

            int x,y,width,height;
            uobj->Inflate( 2 );
            x = uobj->x;
            y = uobj->y;
            width = uobj->width;
            height = uobj->height;


            UpdateArea( x, y, width, height, uobj->m_id );

            //update is done Blitting needs to be done
            uobj->m_update_done = true;

            if ( noblit )
            {
                //we can delete this rect
                delete uobj;
                a2dUpdateList::compatibility_iterator nodeh = nodeb;
                nodeb = nodeb->GetNext();
                m_updateareas.DeleteNode(nodeh);
            }
            else
                nodeb = nodeb->GetNext();
        }
        else
            nodeb = nodeb->GetNext();
    }

    m_recur = false;
}

bool a2dCanvasView::BlitPendingUpdateAreas()
{
    //if there are blits we need a refresh for tools and/or controls
    bool refresh = false;

    if ( !GetCanvasDocument() || m_frozen ||  !m_updateareas.GetFirst() ) 
        return refresh;

    wxASSERT_MSG( m_recur == false, wxT("recursive calls in updating not allowed") );
    m_recur = true;

    //first find out if there will be blit, to prevent expensive call if there are not
    //areas to blit
    a2dUpdateList::compatibility_iterator node = m_updateareas.GetFirst();
    while (node)
    {
        a2dUpdateArea *rect = node->GetData();

        if (rect->m_update_done)
            refresh = true;
        node = node->GetNext();
    }

    if ( refresh )
    {
        m_drawer2D->BeginDraw();

        a2dUpdateList::compatibility_iterator node = m_updateareas.GetFirst();
        while (node)
        {
            a2dUpdateArea *rect = node->GetData();

            if (rect->m_update_done)
            {
                m_drawer2D->BlitBuffer( *rect, wxPoint( m_drawer2D->GetMapX(), m_drawer2D->GetMapY() ) );

                if ( m_display && m_display->GetChildren().GetCount() )
                {
                    m_display->Refresh( false, rect );
                }

                //we can delete this rect
                delete rect;
                a2dUpdateList::compatibility_iterator nodeh = node;
                node = node->GetNext();
                m_updateareas.DeleteNode(nodeh);
            }
            else
                node = node->GetNext();
        }

        if ( refresh )
        {
            //place for code which needs to refresh objects which are drawn on top of the buffer bitmap
            // for example wxWindows derived controls.
        }

        UpdateCrossHair( m_crosshairx, m_crosshairy );

        m_drawer2D->EndDraw();
    }

    m_recur = false;

    return refresh;
}

void a2dCanvasView::UpdateArea( int x, int y, int width, int height, wxUint8 id )
{
    if (!GetCanvasDocument())
    {
        wxASSERT_MSG( GetCanvasDocument() != 0, wxT("invalid a2dCanvasDocument in a2dCanvasView") );
        return;
    }

    // clip to buffer
    if (x < 0)
    {
        width += x;
        x = 0;
    }
    if (width <= 0) return;

    if (y < 0)
    {
        height += y;
        y = 0;
    }
    if (height <= 0) return;

    if (x+width > m_width )
    {
        width = m_width - x;
    }
    if (width <= 0) return;

    if (y+height > m_height )
    {
        height = m_height - y;
    }
    if (height <= 0) return;

    m_drawer2D->SetDrawStyle( a2dFILLED );
    m_drawer2D->BeginDraw();

    //wxLogDebug("update x=%d, y=%d w=%d h=%d", x, y, width, height );

    //This to make all rendering only work on this area
    //when using Dc's
    //We do not do it inside the rendering routines since
    //setting the clippingregion for every object is expensive
    //and not usefull in case of DC's where clipping is already
    //part of API drawing routines.
    //Still the canvasobject is checked for intersection with the update region
    //This to prevent drawing objects that are not within
    //the update region. Which would be useless.
    //Calculalation of boundingboxes etc. for all object is seperate from the rendering stage. 
    m_drawer2D->SetClippingRegionDev(x, y, width, height);

    bool ignore = GetCanvasDocument()->GetIgnorePendingObjects();

    if (!ignore)
        GetCanvasDocument()->SetIgnorePendingObjects( true );

    PaintBackground(x, y, width, height);

    if (m_grid && !m_gridatfront)
        PaintGrid( x, y, width, height );

    m_drawer2D->SetDrawerFill( *a2dTRANSPARENT_FILL );
    m_drawer2D->SetDrawerStroke( *a2dTRANSPARENT_STROKE );

    RenderTopObject( m_documentDrawStyle, id );
    RenderOverlay(  m_overlayDrawStyle );

    //tools always render on top of everything else, excepts the grid.
    if ( m_toolcontroller )
        m_toolcontroller->Render();

    if (m_grid && m_gridatfront)
        PaintGrid( x, y, width, height );

    m_drawer2D->DestroyClippingRegion();
    DrawOrigin();

    if (!ignore)
        GetCanvasDocument()->SetIgnorePendingObjects( false );

/* debuggy
    if ( m_display )
    {
    m_drawer2D->SetDrawerFill( *a2dTRANSPARENT_FILL );
    m_drawer2D->SetDrawerStroke( *a2dBLACK_STROKE );
    m_drawer2D->DevDrawRectangle(x, y, width, height);
    }
*/

    m_drawer2D->EndDraw();

/*
    if ( m_display && m_display->GetChildren().GetCount() )
    {
        wxRect rect = wxRect(x, y, width, height);
        m_display->Refresh( false, &rect );
    }
*/

}

void a2dCanvasView::ClearArea( int x, int y, int width, int height )
{
    if (!GetCanvasDocument())
    {
        wxASSERT_MSG( GetCanvasDocument() != 0, wxT("invalid a2dCanvasDocument in a2dCanvasView") );
        return;
    }

    // clip to buffer
    if (x < 0)
    {
        width += x;
        x = 0;
    }
    if (width <= 0) return;

    if (y < 0)
    {
        height += y;
        y = 0;
    }
    if (height <= 0) return;

    if (x+width > m_width )
    {
        width = m_width - x;
    }
    if (width <= 0) return;

    if (y+height > m_height )
    {
        height = m_height - y;
    }
    if (height <= 0) return;

    m_drawer2D->SetDrawStyle( a2dFILLED );
    m_drawer2D->BeginDraw();

    m_drawer2D->SetClippingRegionDev(x, y, width, height);

    PaintBackground(x, y, width, height);
    if (m_grid )
        PaintGrid( x, y, width, height );

    m_drawer2D->DestroyClippingRegion();
    DrawOrigin();

    m_drawer2D->EndDraw();
}

void a2dCanvasView::BlitBuffer( int x, int y, int width, int height, int xbuf, int ybuf )
{
    if (!GetCanvasDocument())
    {
        wxASSERT_MSG( GetCanvasDocument() != 0, wxT("invalid a2dCanvasDocument in a2dCanvasView") );
        return;
    }

    // clip to buffer
    if (x < 0)
    {
        width += x;
        x = 0;
    }
    if (width <= 0) return;

    if (y < 0)
    {
        height += y;
        y = 0;
    }
    if (height <= 0) return;

    if (x+width > m_width )
    {
        width = m_width - x;
    }
    if (width <= 0) return;

    if (y+height > m_height )
    {
        height = m_height - y;
    }
    if (height <= 0) return;

    m_drawer2D->SetDrawStyle( a2dFILLED );
    m_drawer2D->BeginDraw();

    m_drawer2D->BlitBuffer( x, y, width, height , xbuf, ybuf );

    m_drawer2D->EndDraw();
}


void a2dCanvasView::RenderChildObject( a2dCanvasObject* obj )
{
    if (!GetCanvasDocument())
    {
        wxASSERT_MSG( GetCanvasDocument() != 0, wxT("invalid a2dCanvasDocument in a2dCanvasView") );
        return;
    }

    int x,y,width,height;

    if (obj && obj->GetCanvasDocument() == GetCanvasDocument())
    {
        a2dIterC ic( this );
        a2dIterCU cu( ic, a2dIDENTITY_MATRIX );
        wxRect absarea = obj->GetAbsoluteArea( ic );
        x = absarea.GetX();
        y = absarea.GetY();
        width = absarea.GetWidth();
        height = absarea.GetHeight();
    }

    // clip to buffer
    if (x < 0)
    {
        width += x;
        x = 0;
    }
    if (width <= 0) return;

    if (y < 0)
    {
        height += y;
        y = 0;
    }
    if (height <= 0) return;

    if (x+width > m_width )
    {
        width = m_width - x;
    }
    if (width <= 0) return;

    if (y+height > m_height )
    {
        height = m_height - y;
    }
    if (height <= 0) return;

    m_drawer2D->SetDrawStyle( a2dFILLED );
    m_drawer2D->BeginDraw();

    m_drawer2D->SetClippingRegionDev(x, y, width, height);

    PaintBackground(x, y, width, height);
    if (m_grid )
        PaintGrid( x, y, width, height );

    a2dIterC ic( this );
    ic.SetDisableInvert( true );
    ic.SetDrawStyle( RenderWIREFRAME_HighLight );

    //at the top level the group its matrix is to be ignored.
    //Since it is normally NOT ignored within a2dCanvasObject, do an inverse first here.
    a2dAffineMatrix cworld= m_top->GetTransformMatrix();
    cworld.Invert();

    a2dBoundingBox absarea = m_top->GetMappedBbox( cworld );
    OVERLAP clipparent = m_drawer2D->GetClippingBox().Intersect( absarea );
    if ( clipparent != _OUT )
    {
        ic.SetPerLayerMode( false );
        m_drawer2D->SetDisableDrawing( true );
        ic.SetLayer( wxLAYER_ALL );
        a2dIterCU cu( ic, cworld );
        obj->Render( ic, clipparent );
        m_drawer2D->SetDisableDrawing( false );

        ic.Reset();
    }

    m_drawer2D->DestroyClippingRegion();
    DrawOrigin();

    m_drawer2D->BlitBuffer( x, y, width, height , m_drawer2D->GetMapX(), m_drawer2D->GetMapY() );

    m_drawer2D->EndDraw();
}



void a2dCanvasView::UpdateViewDependentObjects()
{
    if ( ! m_viewDependentObjects )
        return;

    a2dCanvasDocument* doc = GetCanvasDocument();
    if(doc)
    {
        if(!m_top)
            return;
        a2dIterC ic( this );
        a2dAffineMatrix cworld = m_top->GetTransformMatrix();
        cworld.Invert();
        a2dIterCU cu( ic, cworld );
        m_top->UpdateViewDependentObjects( ic );
    }
}

void a2dCanvasView::RenderTopObject( wxUint32 documentDrawStyle, wxUint8 id )
{
    if ( documentDrawStyle & RenderLAYERED )
    {
        m_drawer2D->SetDrawStyle( a2dFILLED );
        RenderTopObject( a2dCanvasOFlags::VISIBLE, RenderLAYERED );
    }
    if ( documentDrawStyle & RenderWIREFRAME )
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME );
        RenderTopObject( a2dCanvasOFlags::VISIBLE, RenderWIREFRAME );
    }
    if ( documentDrawStyle & RenderWIREFRAME_ZERO_WIDTH )
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME_ZERO_WIDTH );
        RenderTopObject( a2dCanvasOFlags::VISIBLE, RenderWIREFRAME_ZERO_WIDTH );
    }
    if ( documentDrawStyle & RenderWIREFRAME_INVERT ) 
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME_INVERT );
        RenderTopObject( a2dCanvasOFlags::VISIBLE, RenderWIREFRAME_INVERT );
    }
    if ( documentDrawStyle & RenderWIREFRAME_INVERT_ZERO_WIDTH )
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME_INVERT_ZERO_WIDTH );
        RenderTopObject( a2dCanvasOFlags::VISIBLE, RenderWIREFRAME_INVERT_ZERO_WIDTH );
    }
    if ( documentDrawStyle & RenderFIX_STYLE )
    {
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
        RenderTopObject( a2dCanvasOFlags::VISIBLE, RenderFIX_STYLE );
        m_drawer2D->ResetFixedStyle();
    }
    if ( documentDrawStyle & RenderRectangles ) 
    {
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
        RenderTopObject( a2dCanvasOFlags::VISIBLE, RenderRectangles );
        m_drawer2D->ResetFixedStyle();
    }

    if ( documentDrawStyle & RenderWIREFRAME_HighLight ) 
    {
        m_drawer2D->SetDrawerFill( m_highLightFill );
        m_drawer2D->SetDrawerStroke( m_highLightStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
        RenderTopObject(  a2dCanvasOFlags::VISIBLE, RenderWIREFRAME_HighLight );
        m_drawer2D->ResetFixedStyle();
    }

    if ( documentDrawStyle & RenderTOOL_OBJECTS )
    {
        //we want the object that is being edited, on top of all others, but before selection
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
        RenderTopObject(  a2dCanvasOFlags::VISIBLE, RenderTOOL_OBJECTS );
        m_drawer2D->ResetFixedStyle();
    }

    if ( documentDrawStyle & RenderTOOL_OBJECTS_STYLED )
    {
        m_drawer2D->SetDrawStyle( a2dFILLED );
        RenderTopObject(  a2dCanvasOFlags::VISIBLE, RenderTOOL_OBJECTS_STYLED );
    }

    if ( documentDrawStyle & RenderRectangleTOOL_OBJECTS )
    {
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
        RenderTopObject(  a2dCanvasOFlags::VISIBLE, RenderRectangleTOOL_OBJECTS );
        m_drawer2D->ResetFixedStyle();
    }

    if ( documentDrawStyle & RenderTOOL_DECORATIONS )
    {
        m_drawer2D->SetDrawStyle( a2dFILLED );
        RenderTopObject(  a2dCanvasOFlags::VISIBLE, RenderTOOL_DECORATIONS );
    }

    //we want the objects that are selected, in a select color, on top of all others, that is done next. 
    if ( documentDrawStyle & RenderWIREFRAME_SELECT ) 
    {
        m_drawer2D->SetDrawerFill( m_selectFill );
        m_drawer2D->SetDrawerStroke( m_selectStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
        RenderTopObject(  a2dCanvasOFlags::VISIBLE, RenderWIREFRAME_SELECT );
        m_drawer2D->ResetFixedStyle();
    }
    if ( documentDrawStyle & RenderWIREFRAME_SELECT_INVERT ) 
    {
        m_drawer2D->SetDrawerFill( m_selectFill );
        m_drawer2D->SetDrawerStroke( m_selectStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE_INVERT );
        RenderTopObject(  a2dCanvasOFlags::VISIBLE, RenderWIREFRAME_SELECT_INVERT );
        m_drawer2D->ResetFixedStyle();
    }

    m_drawer2D->SetDrawStyle( a2dFILLED );
}

void a2dCanvasView::RenderOverlay( a2dDocumentRenderStyle documentDrawStyle )
{
    if ( m_overlayObjects.empty() )
        return;

    if ( documentDrawStyle & RenderLAYERED )
    {
        m_drawer2D->SetDrawStyle( a2dFILLED );
    }
    if ( documentDrawStyle & RenderWIREFRAME )
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME );
    }
    if ( documentDrawStyle & RenderWIREFRAME_ZERO_WIDTH )
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME_ZERO_WIDTH );
    }
    if ( documentDrawStyle & RenderWIREFRAME_INVERT ) 
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME_INVERT );
    }
    if ( documentDrawStyle & RenderWIREFRAME_INVERT_ZERO_WIDTH )
    {
        m_drawer2D->SetDrawStyle( a2dWIREFRAME_INVERT_ZERO_WIDTH );
    }
    if ( documentDrawStyle & RenderFIX_STYLE )
    {
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
    }
    if ( documentDrawStyle & RenderRectangles ) 
    {
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
    }

    if ( documentDrawStyle & RenderWIREFRAME_HighLight ) 
    {
        m_drawer2D->SetDrawerFill( m_highLightFill );
        m_drawer2D->SetDrawerStroke( m_highLightStroke );
        //m_drawer2D->SetDrawerFill( a2dFill( wxColour( 66, 159, 25, 50 ) ) );
        //m_drawer2D->SetDrawerStroke( a2dStroke( wxColour( 66, 59, 235, 165 ), 2, a2dSTROKE_LONG_DASH) );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
    }

    if ( documentDrawStyle & RenderTOOL_OBJECTS )
    {
        //we want the object that is being edited, on top of all others, but before selection
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
    }

    if ( documentDrawStyle & RenderTOOL_OBJECTS_STYLED )
    {
        m_drawer2D->SetDrawStyle( a2dFILLED );
    }

    if ( documentDrawStyle & RenderRectangleTOOL_OBJECTS )
    {
        m_drawer2D->SetDrawerFill( m_fixFill );
        m_drawer2D->SetDrawerStroke( m_fixStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
    }

    if ( documentDrawStyle & RenderTOOL_DECORATIONS )
    {
        m_drawer2D->SetDrawStyle( a2dFILLED );
    }

    //we want the objects that are selected, in a select color, on top of all others, that is done next. 
    if ( documentDrawStyle & RenderWIREFRAME_SELECT ) 
    {
        m_drawer2D->SetDrawerFill( m_selectFill );
        m_drawer2D->SetDrawerStroke( m_selectStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE );
    }
    if ( documentDrawStyle & RenderWIREFRAME_SELECT_INVERT ) 
    {
        m_drawer2D->SetDrawerFill( m_selectFill );
        m_drawer2D->SetDrawerStroke( m_selectStroke );
        m_drawer2D->SetDrawStyle( a2dFIX_STYLE_INVERT );
    }

    a2dAffineMatrix cworld= m_top->GetTransformMatrix();
    cworld.Invert();

    // DO NOT clip to bbox m_top, since new objects not part of document can be outside it
    //a2dBoundingBox absarea = m_top->GetMappedBbox( cworld );
    //OVERLAP clipparent = m_drawer2D->GetClippingBox().Intersect( absarea );
    //if ( clipparent != _OUT  || !m_top->GetChildObjectsCount() )
    OVERLAP clipparent = _IN;
    {
        a2dCanvasObjectList::iterator iter = m_overlayObjects.begin();
        for( iter = m_overlayObjects.begin(); iter != m_overlayObjects.end(); ++iter )
        {
            a2dCanvasObjectList::value_type obj = *iter;
            a2dIterC ic( this );
            ic.SetDisableInvert( true );
            ic.SetPerLayerMode( false );
            ic.SetLayer( wxLAYER_ALL );
            a2dIterCU cu( ic, cworld );
            obj->Render( ic, clipparent );
            m_drawer2D->ResetFixedStyle();

            ic.Reset();
        }
    }

    m_drawer2D->ResetFixedStyle();

    m_drawer2D->SetDrawStyle( a2dFILLED );
}

void a2dCanvasView::RenderTopObject( a2dCanvasObjectFlagsMask mask, a2dDocumentRenderStyle drawstyle )
{
    if ( GetCanvasDocument()->GetUpdatesPending() )
        GetCanvasDocument()->AddPendingUpdatesOldNew(); //in general there are non, since the pending object are already updates before calling render 

    a2dIterC ic( this );
    ic.SetDisableInvert( true );
    ic.SetDrawStyle( drawstyle );

    //at the top level the group its matrix is to be ignored.
    //Since it is normally NOT ignored within a2dCanvasObject, do an inverse first here.
    a2dAffineMatrix cworld= m_top->GetTransformMatrix();
    cworld.Invert();

    a2dBoundingBox absarea = m_top->GetMappedBbox( cworld );
    OVERLAP clipparent = m_drawer2D->GetClippingBox().Intersect( absarea );
    if ( clipparent != _OUT )
    {
        if ( GetCanvasDocument()->GetLayerSetup() && 
             (  drawstyle == RenderLAYERED || 
                drawstyle == RenderWIREFRAME || 
                drawstyle == RenderWIREFRAME_ZERO_WIDTH 
             )  
           )
        {
            ic.SetPerLayerMode( true );

            if ( 0 ) //contextbased
            {
                unsigned int j;
                for ( j=0; j < wxMAXLAYER; j++ )
                {
                    a2dLayerInfo* layerobj;
                    if ( m_reverse_order )
                        layerobj = GetCanvasDocument()->GetLayerSetup()->GetReverseOrderIndex()[j];
                    else
                        layerobj = GetCanvasDocument()->GetLayerSetup()->GetOrderIndex()[j];

                    // non defined layers, being those that where not in the layer setup, are sorted to the end of the indexes.
                    // So the can be skipped.
                    if ( layerobj == wxNullLayerInfo )
                        break;

                    //wxLogDebug( wxT("index %d layername %s, layer %d order %d"), j, layerobj->GetName(), layerobj->GetLayer(), layerobj->GetOrder() ); 


                    //important!
                    //if layer is visible it will be rendered
                    //If an object on a layer is itself invisible it will not be drawn
                    //wxLAYER_ALL is reserved and should never be part of the layersettings
                    if ( GetLayerRenderArray()[ layerobj->GetLayer() ].DoRenderLayer() &&
                         layerobj->GetVisible() 
                       ) 
                    {
                        //wxLogDebug( "layer %d", layerobj->GetLayer() );
                        m_drawer2D->ResetStyle();
                        ic.SetObjectFilter( new a2dCanvasObjectFilterLayerMaskNoToolNoEdit( layerobj->GetLayer(), mask ) );  
                        ic.SetLayer( layerobj->GetLayer() );
                        
                        a2dIterCU cu( ic, cworld );
                        a2dWalker_RenderLayers renderLay( ic );
                        renderLay.Start( m_top );

                        ic.Reset();
                    }

                }
            }
            else
            {
                unsigned int j;
                for ( j=0; j < wxMAXLAYER; j++ )
                {
                    a2dLayerInfo* layerobj;
                    if ( m_reverse_order )
                        layerobj = GetCanvasDocument()->GetLayerSetup()->GetReverseOrderIndex()[j];
                    else
                        layerobj = GetCanvasDocument()->GetLayerSetup()->GetOrderIndex()[j];

                    // non defined layers, being those that where not in the layer setup, are sorted to the end of the indexes.
                    // So the can be skipped.
                    if ( layerobj == wxNullLayerInfo )
                        break;

                    //wxLogDebug( wxT("index %d layername %s, layer %d order %d"), j, layerobj->GetName(), layerobj->GetLayer(), layerobj->GetOrder() ); 

                    //important!
                    //if layer is visible it will be rendered
                    //If an object on a layer is itself invisible it will not be drawn
                    //wxLAYER_ALL is reserved and should never be part of the layersettings
                    if ( GetLayerRenderArray()[ layerobj->GetLayer() ].DoRenderLayer() &&
                         layerobj->GetVisible() 
                       ) 
                    {
                        //wxLogDebug( "layer %d", layerobj->GetLayer() );
                        m_drawer2D->ResetStyle();
                        ic.SetObjectFilter( new a2dCanvasObjectFilterLayerMaskNoToolNoEdit( layerobj->GetLayer(), mask ) );  
                        ic.SetLayer( layerobj->GetLayer() );
                        
                        a2dIterCU cu( ic, cworld );
                        m_top->Render( ic, clipparent );

                        ic.Reset();
                    }
                }
            }            
        }
        else if ( drawstyle == RenderWIREFRAME_HighLight )
        {
            ic.SetPerLayerMode( false );
            m_drawer2D->SetDisableDrawing( true );
            ic.SetObjectFilter( new a2dCanvasObjectFilterHighLighted( mask ) );  
            ic.SetLayer( wxLAYER_ALL );
            a2dIterCU cu( ic, cworld );
            m_top->Render( ic, clipparent );
            m_drawer2D->SetDisableDrawing( false );

            ic.Reset();
/*
            ic.SetPerLayerMode( false );   
            
            ic.SetObjectFilter( new a2dCanvasObjectFilterLayerMask( wxLAYER_ALL, mask )  );  
            ic.SetLayer( wxLAYER_ALL );
            a2dIterCU cu( ic, cworld );
            top->Render( ic, clipparent );
            ic.Reset();
*/
        }
        else if ( drawstyle == RenderRectangles )
        {
            ic.SetPerLayerMode( false );
            a2dCanvasObjectList::iterator iter = m_top->GetChildObjectList()->begin();
            while( iter != m_top->GetChildObjectList()->end() )
            {
                a2dCanvasObject *obj = (*iter);
                a2dIterCU cu( ic, cworld );
                a2dBoundingBox bbox = obj->GetBbox();
                if ( obj->CheckMask( mask ) )
                    m_drawer2D->DrawRoundedRectangle( bbox.GetMinX(), bbox.GetMinY(), bbox.GetWidth(), bbox.GetHeight() ,0 );
                iter++;
            }
        }
        else if ( drawstyle == RenderRectangleTOOL_OBJECTS )
        {
            ic.SetPerLayerMode( false );
            a2dCanvasObjectList::iterator iter = m_top->GetChildObjectList()->begin();
            while( iter != m_top->GetChildObjectList()->end() )
            {
                a2dCanvasObject *obj = (*iter);
                a2dIterCU cu( ic, cworld );
                a2dBoundingBox bbox = obj->GetBbox();
                if ( obj->CheckMask( mask ) && a2dCanvasObject::PROPID_ToolObject->GetPropertyValue( obj ))
                    m_drawer2D->DrawRoundedRectangle( bbox.GetMinX(), bbox.GetMinY(), bbox.GetWidth(), bbox.GetHeight() ,0 );
                iter++;
            }
        }
        else if ( drawstyle == RenderTOOL_OBJECTS || 
                  drawstyle == RenderTOOL_OBJECTS_STYLED
                )
        {
            ic.SetPerLayerMode( false );
            m_drawer2D->SetDisableDrawing( true );
            ic.SetObjectFilter( new a2dCanvasObjectFilterToolObjects( a2dCanvasObject::PROPID_ToolObject, mask ) );  
            ic.SetLayer( wxLAYER_ALL );

            a2dIterCU cu( ic, cworld );
            m_top->Render( ic, clipparent );
            m_drawer2D->SetDisableDrawing( false );

            ic.Reset();
        }
        else if ( drawstyle == RenderTOOL_DECORATIONS )
        {
            ic.SetPerLayerMode( false );
            m_drawer2D->SetDisableDrawing( true );
            ic.SetObjectFilter( new a2dCanvasObjectFilterToolObjects( a2dCanvasObject::PROPID_ToolDecoration, mask ) );  
            ic.SetLayer( wxLAYER_ALL );

            a2dIterCU cu( ic, cworld );
            m_top->Render( ic, clipparent );
            m_drawer2D->SetDisableDrawing( false );

            ic.Reset();
        }
        else if ( drawstyle == RenderWIREFRAME_SELECT || 
                  drawstyle == RenderWIREFRAME_SELECT_INVERT
                )
        {
            ic.SetPerLayerMode( false );
            m_drawer2D->SetDisableDrawing( true );
            ic.SetObjectFilter( new a2dCanvasObjectFilterSelected( mask ) );  
            ic.SetLayer( wxLAYER_ALL );
            a2dIterCU cu( ic, cworld );
            m_top->Render( ic, clipparent );
            m_drawer2D->SetDisableDrawing( false );

            ic.Reset();
        }
        else
        {
            ic.SetPerLayerMode( false );
            m_drawer2D->SetDisableDrawing( true );
            ic.SetObjectFilter( new a2dCanvasObjectFilterOnlyNoMaskBlind( mask ) );  
            ic.SetLayer( wxLAYER_ALL );
            a2dIterCU cu( ic, cworld );
            m_top->Render( ic, clipparent );
            m_drawer2D->SetDisableDrawing( false );

            ic.Reset();
        }

    }
}

void a2dCanvasView::AddPendingUpdateArea( const a2dBoundingBox& box, wxUint8 id )
{
    int xi = m_drawer2D->WorldToDeviceX( box.GetMinX());
    int yi = m_drawer2D->WorldToDeviceY( box.GetMinY());
    int wi = m_drawer2D->WorldToDeviceXRel( box.GetWidth());
    int hi = m_drawer2D->WorldToDeviceYRel( box.GetHeight());

    if ( m_drawer2D->GetYaxis())
    {
        wxRect rect( xi, yi+hi, wi, -hi );
        rect.Inflate( 2 ); //boundingbox is exact, to get rid of 1 pixel problems, always extend a little.
        AddPendingUpdateArea( rect, id );
        //wxLogDebug("update x=%d, y=%d w=%d h=%d", xi, yi+hi, wi, -hi );
    }
    else
    {
        wxRect rect( xi, yi, wi, hi );
        rect.Inflate( 2 ); //boundingbox is exact, to get rid of 1 pixel problems, always extend a little.
        AddPendingUpdateArea( rect, id );
        //wxLogDebug("update x=%d, y=%d w=%d h=%d", xi, yi, wi, hi );
    }
}

void a2dCanvasView::AddPendingUpdateArea( const wxRect& recnew, wxUint8 id )
{
    AddPendingUpdateArea( recnew.x, recnew.y, recnew.width, recnew.height, id );
}

void a2dCanvasView::AddPendingUpdateArea( int x, int y, int w, int h, wxUint8 id )
{
    // clip to buffer
    if (x < 0)
    {
        w += x;
        x = 0;
    }
    if (w <= 0) return;

    if (y < 0)
    {
        h += y;
        y = 0;
    }
    if (h <= 0) return;

    if (x+w > m_width)
    {
        w = m_width - x;
    }
    if (w <= 0) return;

    if (y+h > m_height)
    {
        h = m_height  - y;
    }
    if (h <= 0) return;

    int xmax = x + w;
    int ymax = y + h;

    if ( id == 0 )
        m_tiles.FillTiles(x, y, xmax-x, ymax-y, true );
    else
        m_tiles2.FillTiles(x, y, xmax-x, ymax-y, true );

    m_recur = false;
}

void a2dCanvasView::AddPendingUpdateArea( a2dCanvasObject* obj, wxUint8 id, bool refsalso )
{
    if (obj && ( obj->GetCanvasDocument() == GetCanvasDocument() || id == 1 ) )
    {
        a2dIterC ic( this );
        a2dIterCU cu( ic, a2dIDENTITY_MATRIX );
        wxRect absarea = obj->GetAbsoluteArea( ic );
        AddPendingUpdateArea( absarea, id );
/*
        //if this object is referenced somewhere else
        //Then there is a chance that it is inside this drawer, so update it.
        if ( refsalso && obj->GetOwnedBy() > 1)
        {
            obj->SetPending( true );
            //at the top level the group its matrix is to be ignored.
            //Since it is normally NOT ignored within a2dCanvasObject, do an inverse first here.
            a2dAffineMatrix cworld= m_top->GetTransformMatrix();
            cworld.Invert();

            a2dIterC ic( this );
            a2dIterCU cu( ic, cworld );

            m_top->AddPending( ic );      
            obj->SetPending( false );
        }
*/
    }
}

bool a2dCanvasView::AddObjectPendingUpdates()
{
    if (!GetCanvasDocument())
    {
        wxASSERT_MSG( GetCanvasDocument() != 0, wxT("invalid a2dCanvasDocument in a2dCanvasView") );
        return false;
    }

    if ( GetCanvasDocument()->GetUpdatesPending() )
    {
        //at the top level the group its matrix is to be ignored.
        //Since it is normally NOT ignored within a2dCanvasObject, do an inverse first here.
        a2dAffineMatrix cworld= m_top->GetTransformMatrix();
        cworld.Invert();

        a2dIterC ic( this );
        a2dIterCU cu( ic, cworld );

        m_top->AddPending( ic );      
        return true;
    }
    return false;
}

/** end of updating routines **/

a2dCanvasDocument* a2dCanvasView::GetCanvasDocument() const
{
    return wxStaticCastNull( m_viewDocument.Get(), a2dCanvasDocument );
}

void a2dCanvasView::OnSetDocument( a2dViewEvent& event )
{
    a2dCanvasDocument* doc = (a2dCanvasDocument*) ((a2dView*)event.GetEventObject())->GetDocument();

    m_capture = (a2dCanvasObject*)NULL;

    a2dCanvasDocument* canvasdoc;
    if ( doc && m_viewDocument )
    {
        canvasdoc = wxDynamicCast( doc , a2dCanvasDocument);
        wxASSERT_MSG(  canvasdoc != 0, wxT("a2dCanvasView::SetDocument not a a2dCanvasDocument") );

        m_top = GetCanvasDocument()->GetRootObject();
        //For tools need to have their corridor reset to this new document its top.
        //Else it would be invalid for all tools.
        a2dComEvent changedShow( this, m_top, &sm_changedShowObject );
        // controller is by default not connected to event distributer
        if ( m_toolcontroller )
        {
            m_toolcontroller->ProcessEvent( event );
            event.Skip();
        }
        a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedShow );

        //for save (if the user forgot it)
        if ( GetCanvasDocument() )
        {
            GetCanvasDocument()->SetCanvasDocumentRecursive();
            Set_UpdateAvailableLayers( true);
            GetCanvasDocument()->AddPendingUpdatesOldNew();
        }
    }
}

#if wxUSE_PRINTING_ARCHITECTURE
wxPrintout* a2dCanvasView::OnCreatePrintout( a2dCommand* typeOfPrint ) 
{
    return new a2dViewPrintout(this, m_printtitle ? GetCanvasDocument()->GetDescription() : (const wxString&)wxEmptyString, m_printfilename ? GetCanvasDocument()->GetFilename().GetFullPath() : wxString(wxT("")), typeOfPrint, m_printframe, m_printscalelimit, m_printfittopage );
}
#endif

a2dCanvasObject* a2dCanvasView::SetShowObject(const wxString& name)
{
    m_capture = (a2dCanvasObject*)NULL;

    if (!GetCanvasDocument())
    {
        wxASSERT_MSG( GetCanvasDocument() != 0, wxT("invalid a2dCanvasDocument in a2dCanvasView") );
        return (a2dCanvasObject*) NULL;
    }

    a2dCanvasObject* newtop = GetCanvasDocument()->Find(name, wxT(""), 0 );
    if (!newtop)
        newtop = GetCanvasDocument()->GetRootObject();

    m_top = newtop;

    SetCaptured( NULL );

    Update( a2dCANVIEW_UPDATE_OLDNEW | a2dCANVIEW_UPDATE_ALL );


    a2dComEvent changedShow( this, m_top, &sm_changedShowObject );
    // controller is by default not connected to event distributer
    if ( m_toolcontroller )
    {
        m_toolcontroller->ProcessEvent( changedShow );
        changedShow.Skip();
    }
    a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedShow );

    return newtop;
}

bool a2dCanvasView::SetShowObject(a2dCanvasObject* obj)
{
    m_capture = (a2dCanvasObject*)NULL;

    if (!GetCanvasDocument())
    {
        wxASSERT_MSG( GetCanvasDocument() != 0, wxT("invalid a2dCanvasDocument in a2dCanvasView") );
        return (a2dCanvasObject*) NULL;
    }

    //attached objects also because i like it
    a2dCanvasObject* found = GetCanvasDocument()->Find(obj);
    if (!found)
        m_top = GetCanvasDocument()->GetRootObject();
    else
        m_top = found;

    SetCaptured( NULL );

    Update( a2dCANVIEW_UPDATE_OLDNEW | a2dCANVIEW_UPDATE_ALL );

    a2dComEvent changedShow( this, m_top, &sm_changedShowObject );
    // controller is by default not connected to event distributer
    if ( m_toolcontroller )
    {
        m_toolcontroller->ProcessEvent( changedShow );
        changedShow.Skip();
    }
    a2dDocviewGlobals->GetEventDistributer()->ProcessEvent( changedShow );

    return (m_top.Get() != 0);
}

void a2dCanvasView::SetBackgroundFill( const a2dFill& backgroundfill )
{
    m_backgroundfill = backgroundfill;
    Update( a2dCANVIEW_UPDATE_ALL );
}

void a2dCanvasView::SetGridStroke( const a2dStroke& gridstroke)
{
    m_gridstroke = gridstroke;
    Update( a2dCANVIEW_UPDATE_ALL );
}

void a2dCanvasView::SetGridFill( const a2dFill& gridfill)
{
    m_gridfill = gridfill;
    Update( a2dCANVIEW_UPDATE_ALL );
}

void a2dCanvasView::SetMappingShowAll()
{
    if (!m_top || !GetCanvasDocument())
        return;

    a2dBoundingBox untr = m_top->GetBbox();
    a2dAffineMatrix cworld= m_top->GetTransformMatrix();
    cworld.Invert();
    untr.MapBbox(cworld);

    double worldw = untr.GetWidth();
    double worldh = untr.GetHeight();

    if ( worldw == 0 || worldh == 0 )
    {
        worldw = GetCanvasDocument()->GetInitialSizeX();
        worldh = GetCanvasDocument()->GetInitialSizeY();
        untr = a2dBoundingBox( 0, 0, worldw, worldh ); 
    }

    double xupp = worldw/m_width;
    double yupp = worldh/m_height;

    if (yupp == 0 || xupp == 0) //no drawing at all
    {
        yupp = 1; xupp = 1; //some value
    }

    if (yupp > xupp)
    {
        //centrate
        if ( worldw > yupp*m_width )
            untr.Translate( ( worldw - yupp*m_width ) / 2.0, 0 );
    }
    else
    {
        if ( worldh > xupp*m_height )
            untr.Translate( 0, ( worldh - xupp*m_height ) / 2.0 );
    }

    m_drawer2D->SetMappingWidthHeight( untr );
}

/*******************************************************************
a2dCanvasView  (grid and background)
********************************************************************/


void a2dCanvasView::DrawOrigin()
{
    if (m_showorigin)
    {
        //origin is in world coordinates at 0,0
        int x = m_drawer2D->WorldToDeviceX(0.0);
        int y = m_drawer2D->WorldToDeviceY(0.0);
        int w = 10;
        int h = 10;
        m_drawer2D->SetDrawerStroke( *a2dBLACK_STROKE );
        m_drawer2D->SetDrawerFill( *a2dBLACK_FILL );
        m_drawer2D->PushIdentityTransform();
        m_drawer2D->DrawLine(x-w, y, w+x, y);
        m_drawer2D->DrawLine(x, y-h, x, y+h);
        m_drawer2D->PopTransform();
    }
}

void a2dCanvasView::PaintGrid( int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
{
    m_drawer2D->SetDrawerStroke( m_gridstroke );
    m_drawer2D->SetDrawerFill( m_gridfill );

    double dvx = m_drawer2D->GetUppX()*m_width;
    double dvy = m_drawer2D->GetUppY()*m_height;

    double min_x = m_drawer2D->GetVisibleMinX();
    double max_x = m_drawer2D->GetVisibleMinX()+dvx;

    double min_y;
    double max_y;
    if (m_drawer2D->GetYaxis())
    {
        min_y = m_drawer2D->DeviceToWorldY(m_height);
        //the next would be wrong since GetVisibleMinY() is the miminum Y on screen
        //the buffer is bigger.
        //min_y = GetVisibleMinY();
        max_y = m_drawer2D->GetVisibleMinY()+dvy;
    }
    else
    {
        min_y = m_drawer2D->GetVisibleMinY();
        max_y = m_drawer2D->GetVisibleMinY()+dvy;
    }

    double temp_x = floor(min_x/m_gridx + 0.5);
    double temp_y = floor(min_y/m_gridy + 0.5);
    min_x = temp_x*m_gridx;
    min_y = temp_y*m_gridy;

    double gridx = m_gridx;
    double gridy = m_gridy;
    while ( m_drawer2D->DeviceToWorldXRel( m_gridthres ) > gridx )
        gridx *= 2;
    while ( m_drawer2D->DeviceToWorldXRel( m_gridthres ) > gridy )
        gridy *= 2;
    

    const a2dAffineMatrix worldtodevice = m_drawer2D->GetMappingMatrix();

    if (!m_gridlines)
    {
        double i,j;
        for (i = min_x; i < max_x; i += gridx)
        {
            for (j = min_y; j < max_y; j += gridy)
            {
                double xi, yi;
                worldtodevice.TransformPoint( i, j, xi, yi );
                m_drawer2D->PushIdentityTransform();
                if (m_gridsize)
                    m_drawer2D->DrawCircle(xi, yi, m_gridsize/2);
                else
                    m_drawer2D->DrawPoint(xi, yi );
                m_drawer2D->PopTransform();
            }
        }
    }
    else
    {
        double i,j;
        for (i = min_x; i < max_x; i += gridx)
        {
            double xi, yi;
            worldtodevice.TransformPoint( i, 0, xi, yi );
            m_drawer2D->PushIdentityTransform();
            m_drawer2D->DrawLine(xi, 0, xi, m_height);
            m_drawer2D->PopTransform();
        }
        for (j = min_y; j < max_y; j += gridy)
        {
            double xi, yi;
            worldtodevice.TransformPoint( 0, j, xi, yi );
            m_drawer2D->PushIdentityTransform();
            m_drawer2D->DrawLine(0, yi, m_width, yi);
            m_drawer2D->PopTransform();
        }
    }

    m_drawer2D->SetDrawerFill( *a2dTRANSPARENT_FILL );
    m_drawer2D->SetDrawerStroke( *a2dTRANSPARENT_STROKE );
}

void a2dCanvasView::PaintBackground( int x, int y, int width, int height )
{
    m_drawer2D->SetDrawerStroke( *a2dTRANSPARENT_STROKE );
    m_drawer2D->SetDrawerFill( m_backgroundfill );
    //clear the buffer using the canvas background colour
    //remark (a transparent pen must mean a fully filled rectangle)

    if ( m_backgroundfill.GetType() == a2dFILL_GRADIENT_FILL_LINEAR || m_backgroundfill.GetType() == a2dFILL_GRADIENT_FILL_RADIAL )
    {
        a2dVertexArray cpoints;
        //TODO it not completely rectangular
        //there is missing a scanline in the fill for horizontal lines.
        //But since the clipping regions should be set, this is a working hack.
        cpoints.AddPoint(  0, -10 );
        cpoints.AddPoint(  0, m_height+10 );
        cpoints.AddPoint(  m_width, m_height );
        cpoints.AddPoint(  m_width, 0 );

        m_drawer2D->PushIdentityTransform();
        m_drawer2D->DrawPolygon( &cpoints );
        m_drawer2D->PopTransform();
    }
    else
    {
        m_drawer2D->PushIdentityTransform();
        m_drawer2D->DrawRoundedRectangle( x, y, width, height, 0 );
        m_drawer2D->PopTransform();
    }
    m_drawer2D->SetDrawerFill( *a2dTRANSPARENT_FILL );
    m_drawer2D->SetDrawerStroke( *a2dTRANSPARENT_STROKE );

// the next gives you very good indication of what is updated or not on the canvas.
#if 0
    m_drawer2D->PushIdentityTransform();
    m_drawer2D->SetDrawerFill( a2dFill( wxColour(rand()%254,rand()%254,rand()%254) ) );
    m_drawer2D->DrawRoundedRectangle( x, y, width, height, 0 );
    m_drawer2D->PopTransform();
#endif
}

void a2dCanvasView::UpdateCrossHair( int x, int y )
{
    if ( !m_crosshair ) //&& m_mouseevents )
        return;

    m_drawer2D->BeginDraw();
    m_drawer2D->PushIdentityTransform();
    m_drawer2D->SetDrawStyle( a2dWIREFRAME_INVERT );

    wxRect rect1( m_crosshairx - m_crosshairLengthX/2-10, m_crosshairy - m_crosshairLengthY/2-10, 
                m_crosshairLengthX+20, m_crosshairLengthY+20 );

    //paint cross 
    m_drawer2D->SetDrawerStroke( m_crosshairStroke );

    m_drawer2D->DrawLine( m_crosshairx, m_crosshairy - m_crosshairLengthY/2, m_crosshairx, m_crosshairy + m_crosshairLengthY/2 );
    m_drawer2D->DrawLine( m_crosshairx - m_crosshairLengthX/2, m_crosshairy, m_crosshairx + m_crosshairLengthX/2, m_crosshairy );

    m_crosshairx = x;
    m_crosshairy = y;

    m_drawer2D->DrawLine( m_crosshairx, m_crosshairy - m_crosshairLengthY/2, m_crosshairx, m_crosshairy + m_crosshairLengthY/2 );
    m_drawer2D->DrawLine( m_crosshairx - m_crosshairLengthX/2, m_crosshairy, m_crosshairx + m_crosshairLengthX/2, m_crosshairy );

    m_drawer2D->BlitBuffer( rect1 );

    wxRect rect( m_crosshairx - m_crosshairLengthX/2-10, m_crosshairy - m_crosshairLengthY/2-10, 
                m_crosshairLengthX+20, m_crosshairLengthY+20 );
    m_drawer2D->BlitBuffer( rect );

    m_drawer2D->SetDrawerStroke( *a2dTRANSPARENT_STROKE );

    m_drawer2D->PopTransform();
    m_drawer2D->EndDraw();
    m_drawer2D->SetDrawStyle( a2dFILLED );
}

void a2dCanvasView::Scroll( int dxy, bool yscroll, bool  total)
{
    bool gradient = ( m_backgroundfill.GetType() == a2dFILL_GRADIENT_FILL_LINEAR || m_backgroundfill.GetType() == a2dFILL_GRADIENT_FILL_RADIAL );
    int bw = m_width;
    int bh = m_height;
    if (yscroll)
    {
        if ( total || gradient )
        {
            AddPendingUpdateArea( 0, 0, bw, bh );
        }
        else
        {
            if (dxy > 0 && dxy < bh )
            {
                m_drawer2D->ShiftBuffer( dxy, yscroll );
                AddPendingUpdateArea( 0, 0, bw, dxy);
            }
            else  if (dxy < 0 && dxy > -bh)
            {
                m_drawer2D->ShiftBuffer( dxy, yscroll );
                AddPendingUpdateArea( 0, bh+dxy, bw, -dxy);
            }
            else
                AddPendingUpdateArea( 0, 0, bw, bh);
        }
    }
    else
    {
        if ( total || gradient )
        {
            AddPendingUpdateArea( 0, 0, bw, bh );
        }
        else
        {
            if (dxy > 0 && dxy < bw)
            {
                m_drawer2D->ShiftBuffer( dxy, yscroll );
                AddPendingUpdateArea( 0, 0, dxy, bh );
            }
            else if (dxy < 0 && dxy > -bw )
            {
                m_drawer2D->ShiftBuffer( dxy, yscroll );
                AddPendingUpdateArea( bw+dxy, 0, -dxy, bh );
            }
            else
                AddPendingUpdateArea( 0,0, bw, bh );
        }
    }

    //now make sure the buffer is fully updated
    RedrawPendingUpdateAreas();
}

IMPLEMENT_CLASS( a2dZoomedView, wxWindow )

BEGIN_EVENT_TABLE( a2dZoomedView, wxWindow )
    EVT_UPDATE_VIEWS( a2dZoomedView::OnUpdate )
    EVT_COM_EVENT( a2dZoomedView::OnComEvent )
    EVT_PAINT( a2dZoomedView::OnPaint )
    EVT_SIZE( a2dZoomedView::OnSize )
    EVT_REMOVE_VIEW( a2dZoomedView::OnRemoveView )
END_EVENT_TABLE()

a2dZoomedView::a2dZoomedView( wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, a2dCanvasView* canvasview ):
    wxWindow( parent, id, pos, size, style )
{
    a2dDocviewGlobals->GetEventDistributer()->Register( this );

    m_canvasDocview = canvasview;
}

a2dZoomedView::~a2dZoomedView()
{
    a2dDocviewGlobals->GetEventDistributer()->Unregister( this );
}

void a2dZoomedView::OnUpdate( a2dDocumentEvent& event )
{
    if ( !m_canvasDocview || m_canvasDocview->GetCanvasDocument() != event.GetEventObject() )
        return;

    if ( !GetEvtHandlerEnabled() )
        return;

    if ( !m_canvasDocview || m_canvasDocview->GetCanvasDocument() )
        return;

    //update totalbbox or set dirty.
}

void a2dZoomedView::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
    if ( !m_canvasDocview || m_canvasDocview->IsClosed() )
    {
        wxPaintDC dc( this ); //needed to prevent looping
        return;
    }

    wxPaintDC dc(this);

    int dvx, dvy;
    GetClientSize(&dvx,&dvy);
    if ( dvx == 0 ) dvx = 1;
    if ( dvy == 0 ) dvy = 1;


    double w = m_canvasDocview->GetCanvasDocument()->GetBboxWidth();
    double h = m_canvasDocview->GetCanvasDocument()->GetBboxHeight();
    double xview = m_canvasDocview->GetDrawer2D()->GetVisibleMinX();
    double yview = m_canvasDocview->GetDrawer2D()->GetVisibleMinY();
    double wview = m_canvasDocview->GetDrawer2D()->GetVisibleWidth();
    double hview = m_canvasDocview->GetDrawer2D()->GetVisibleHeight();

    if ( h * dvx/w < dvy )
    {       
        //Do draw two rectangles, one of size document and one of size m_canvasDocview.
        dc.DrawRectangle(0,0, dvx, (int) (h * dvx/w) );
        dc.DrawRectangle( (int) (xview* dvx/w), (int) (yview* dvx/w), (int) (wview* dvx/w), (int) (hview* dvx/w) );
    }
    else
    {       
        //Do draw two rectangles, one of size document and one of size m_canvasDocview.
        dc.DrawRectangle(0,0, (int) (w * dvx/h), dvy );
        dc.DrawRectangle( (int) (xview* dvy/h), (int) (yview* dvy/h), (int) (wview* dvy/h), (int) (hview* dvy/h) );
    }

}

void a2dZoomedView::OnSize( wxSizeEvent& WXUNUSED(event) )
{
    Refresh();
}


void a2dZoomedView::OnComEvent( a2dComEvent& event )
{
    if ( event.GetEventComId() == &a2dDrawer2D::sm_changedZoom)
    {
            Refresh();
    }
}

void a2dZoomedView::OnRemoveView( a2dDocumentEvent& event )
{
    a2dView* viewremoved = (a2dView*) event.GetView();
    if ( viewremoved == m_canvasDocview )
        m_canvasDocview = NULL;
}

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