cansim.cpp

Go to the documentation of this file.

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

    Copyright: 2001-2004 (C) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: cansim.cpp,v 1.34 2008/08/01 18:32:29 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/canvas/candoc.h"
#include "wx/canvas/cansim.h"
#include "wx/canvas/tools.h"
#include "wx/artbase/dcdrawer.h"

#include <wx/wfstream.h>


//----------------------------------------------------------------------------
// globals
//----------------------------------------------------------------------------

#define WIDTHSCROLLBAR 20

//----------------------------------------------------------------------------
// a2dCanvas
//----------------------------------------------------------------------------

//! drawer is actually m_view of base class, only specialized

IMPLEMENT_CLASS(a2dCanvasSim,a2dDocumentViewScrolledWindow)

BEGIN_EVENT_TABLE(a2dCanvasSim,a2dDocumentViewScrolledWindow)
    EVT_PAINT( a2dCanvasSim::OnPaint )
    EVT_ERASE_BACKGROUND( a2dCanvasSim::OnEraseBackground )
    EVT_SIZE( a2dCanvasSim::OnSize )
END_EVENT_TABLE()


a2dCanvasSim::a2dCanvasSim( wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ):
    a2dDocumentViewScrolledWindow( parent, id, pos, size, style )
{
    m_border = 0;
    m_delta = 100;
    
    int dvx = size.GetWidth();
    int dvy = size.GetHeight();

    if ( size == wxDefaultSize )
    {
        dvx = 1000;
        dvy = 1000;
    }
    else
        GetClientSize(&dvx,&dvy); //this will be visible width and height in  world coordinates

    a2dCanvasView* view = new a2dCanvasView( dvx, dvy );
    a2dDrawer2D* drawer2d = new a2dMemDcDrawer( dvx, dvy );
    view->SetDisplayWindow( this );
    view->SetDrawer2D( drawer2d );
    SetView( view ); 

    m_frozen = false;

    // One a2dCanvasDocument to draw
    m_doc = new a2dCanvasDocument();
    m_view->SetDocument( m_doc );
}


void a2dCanvasSim::ClearBackground() 
{
    SetBackgroundColour( GetCanvasView()->GetBackgroundFill().GetColour() );

    wxWindow::ClearBackground();
}

void a2dCanvasSim::Refresh( bool eraseBackground, const wxRect* rect )
{
    if ( m_view && !rect )
    {        
        m_view->Update( a2dCANVIEW_UPDATE_ALL );
    }
    wxWindow::Refresh( eraseBackground, rect );
}

a2dCanvasSim::~a2dCanvasSim()
{
    if ( !m_view )
        return;
    GetCanvasView()->Close();
}

a2dCanvasDocument* a2dCanvasSim::GetCanvasDocument() 
{ 
    if (!m_view)
        return NULL;
    return GetCanvasView()->GetCanvasDocument(); 
}

a2dCanvasObject* a2dCanvasSim::SetShowObject(const wxString& name)
{
    if ( !GetCanvasView() )
        return false;
    return GetCanvasView()->SetShowObject(name);
}

bool a2dCanvasSim::SetShowObject(a2dCanvasObject* obj)
{
    if ( !GetCanvasView() )
        return false;
    return GetCanvasView()->SetShowObject(obj);
}

void a2dCanvasSim::SetBackgroundFill( const a2dFill& backgroundfill )
{
    if ( !GetCanvasView() )
        return;
    GetCanvasView()->SetBackgroundFill( backgroundfill );

    m_view->Update( a2dCANVIEW_UPDATE_ALL );
}

bool a2dCanvasSim::GetYaxis() const 
{ 
    if ( !GetCanvasView() )
        return true;
    return GetDrawer2D()->GetYaxis(); 
}

void a2dCanvasSim::Freeze()
{
    wxWindow::Freeze();
    m_frozen = true;
}

void a2dCanvasSim::Thaw()
{
    wxWindow::Thaw();
    m_frozen = false;
}

void a2dCanvasSim::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
    wxPaintDC dc( this ); //needed to prevent looping
    
    // extra wxDC's are created, so we use CalcUnscrolledPosition() instead.
    //DoPrepareDC(dc);

    if ( !GetCanvasView() || m_view->IsClosed() )
    {
        return;
    }

    if (GetCanvasView()->IsFrozen()) return;
    
    //TODOif (!GetDrawer2D()->GetBuffer()->Ok()) return;

    //first redraw/update that were not yet updated pending areas (if available)
    //with the magic flag wxNO_FULL_REPAINT_ON_RESIZE blitting
    //also what is in the blitting list is not usefull
    //because Onpaint ignores blits outside the rectangles
    //that it finds damaged, therefore no blit flag for blitting areas.
    //This is done in idle time.

    //Mind that Onpaint events received from the GetCanvasView() is done with that eventhandler of that specific view disabled, else 
    // the event would directly loop back to that view.
    //So we enable the event handler here temporarely if needed, in order to get the update event handled.
    bool eventHandlerEnabledState = GetCanvasView()->GetEvtHandlerEnabled();
    if ( !eventHandlerEnabledState )
        GetCanvasView()->SetEvtHandlerEnabled(true);
    
    // now sent the update event 
    //Onpaint events are always coming trough even if OnIdle events are not, for batch redraw etc. we make sure that all pending 
    //areas or first redrawn in the buffer
    GetCanvasView()->Update( a2dCANVIEW_UPDATE_AREAS );
    
    //restore state
    GetCanvasView()->SetEvtHandlerEnabled(eventHandlerEnabledState);

    //ininiate the wxDc's etc. in a2dCanvasView.
    GetDrawer2D()->BeginDraw();

    //get the regions to update and add to the list
    //of areas that need to be blitted
    wxRegionIterator it( GetUpdateRegion() );
    while (it)
    {
        int x = it.GetX();
        int y = it.GetY();

        int w = it.GetWidth();
        int h = it.GetHeight();

        int xx; 
        int yy;
        CalcUnscrolledPosition( x, y, &xx, &yy);
        GetDrawer2D()->BlitBuffer( xx, yy, w, h );

        it++;
    }
    GetDrawer2D()->EndDraw();
}

void a2dCanvasSim::SetMouseEvents(bool onoff)
{
    if ( !m_view )
        return;

    GetCanvasView()->SetMouseEvents( onoff );
}

void a2dCanvasSim::OnEraseBackground(wxEraseEvent& WXUNUSED(event) )
{
}

a2dCanvasObject* a2dCanvasSim::IsHitWorld( 
    double x, double y,
    int layer,
    a2dHitOption option
)
{
    if ( !m_view )
        return NULL;
    return GetCanvasView()->IsHitWorld( x, y, layer, option );
}

bool a2dCanvasSim::WriteSVG(const wxString& filename, double Width, double Height, wxString unit)
{
    if ( !m_view || !GetDrawer2D() )
        return false;

    //to make sure
    return GetCanvasView()->GetCanvasDocument()->WriteSVG( GetCanvasView(), filename, GetCanvasView()->GetShowObject(), Width, Height, unit);
}

void a2dCanvasSim::SetMappingWidthHeight( double vx1, double vy1, double width, double height )
{
    int dxn,dyn;
    GetVirtualSize(&dxn,&dyn);

    if ( dxn == 0 ) dxn = 1000;
    if ( dyn == 0 ) dyn = 1000;

    double xupp=width/dxn;
    double yupp=height/dyn;

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

    if (yupp > xupp)
        SetMappingUpp(vx1,vy1,yupp,yupp);
    else
        SetMappingUpp(vx1,vy1,xupp,xupp);
}

// maps the virtual window (Real drawing to the window coordinates
// also used for zooming
void a2dCanvasSim::SetMappingUpp( double vx1, double vy1, double xpp, double ypp)
{
    if ( !m_view || !GetDrawer2D() )
        return;

    int dxn,dyn;
    GetVirtualSize(&dxn,&dyn);

    if ( dxn == 0 ) dxn = 1000;
    if ( dyn == 0 ) dyn = 1000;

    GetDrawer2D()->SetMappingDeviceRect( 0, 0, dxn, dyn );
    GetDrawer2D()->SetMappingUpp( vx1, vy1, xpp, ypp );
}

void a2dCanvasSim::SetYaxis(bool up)
{
    if ( !m_view || !GetDrawer2D() )
        return;

    GetDrawer2D()->SetYaxis( up);

    m_view->Update( a2dCANVIEW_UPDATE_ALL );
}

bool a2dCanvasSim::GetMouseEvents() 
{ 
    if ( !m_view || !GetDrawer2D() )
        return false;

    return GetCanvasView()->GetMouseEvents(); 
}


void a2dCanvasSim::OnSize(wxSizeEvent& WXUNUSED(event) )
{
    if ( !m_view )
        return;

    if (!GetDrawer2D())
        return;

    //TRICKS!
    //The buffer is a little bigger then the clientsize.
    //This is for two reasons.
    //1- A small resize on the window does not result in redrawing
    //everything.
    //1- To be able to ignore onsize events when only scrollbars (dis)appear
    //which also would cause a redraw here

    int oldw = GetDrawer2D()->GetBuffer().GetWidth();
    int oldh = GetDrawer2D()->GetBuffer().GetHeight();

    int w,h;

    GetVirtualSize( &w, &h );

    //the client size may be with are without scrollbars
    //always draw to a buffer that is inclusif scrollbars
    w = w+WIDTHSCROLLBAR+m_delta;
    h = h+WIDTHSCROLLBAR+m_delta;

    if (abs(oldw-w) > m_delta || abs(oldh-h) > m_delta)
    {
        //first redraw/update that were not yet updated pending areas (if available)
        //blit pending updates to the window/screen
        m_view->Update( a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT );

        GetCanvasView()->SetBufferSize( w, h );

        //only redraw/repaint what was added, so if smaller
        //do nothing else update only the new areas

        if (GetDrawer2D()->GetYaxis())
        {
            if (oldw < w)
                GetCanvasView()->AddPendingUpdateArea(oldw,0, w-oldw, h);
            if (oldh < h)
                GetCanvasView()->AddPendingUpdateArea(0,oldh,w, h-oldh);
        }
        else
        {
            if (oldw < w)
                GetCanvasView()->AddPendingUpdateArea(oldw,0, w-oldw, h);
            if (oldh < h)
                GetCanvasView()->AddPendingUpdateArea(0,oldh,w, h-oldh);
        }
    }
    m_view->Update( a2dCANVIEW_UPDATE_ALL | a2dCANVIEW_UPDATE_BLIT );
}

void a2dCanvasSim::SetMappingShowAll( bool centre )
{
    if ( !m_view || !GetDrawer2D() )
        return;

    if (!GetShowObject() || !GetCanvasDocument())
        return;

    m_view->Update( a2dCANVIEW_UPDATE_OLDNEW );
    a2dBoundingBox untr = GetShowObject()->GetBbox();
    a2dAffineMatrix cworld = GetShowObject()->GetTransformMatrix();
    cworld.Invert();
    untr.MapBbox(cworld);

    double w = untr.GetWidth();
    double h = untr.GetHeight();

    if ( w == 0 )
        w=1000;
    if ( h== 0 )
        h=1000;

    double uppx, uppy;
    int clientw, clienth;
    GetVirtualSize( &clientw, &clienth );

    //what is needed in units per pixel to make height of bbox fit.
    if ( clientw - m_border > 0 )
        uppx = w/(clientw - m_border);
    else
        uppx = w/clientw;

    //what is needed in units per pixel to make width of bbox fit.
    if ( clienth - m_border > 0 )
        uppy = h/(clienth - m_border);
    else
        uppy = h/clienth;

    // now take the largets, to make sure it will fit either in x or y
    if ( uppy > uppx )
        uppx = uppy;

    GetDrawer2D()->StartRefreshDisplayDisable();
    GetDrawer2D()->SetMappingDeviceRect( 0, 0, clientw, clienth);

    if ( !centre )
    {
        SetMappingWidthHeight( untr.GetMinX(),
                               untr.GetMinY(),
                               w,
                               h
                             );
    }
    else
    {
        double middlexworld = untr.GetMinX()+w/2.0;
        double middleyworld = untr.GetMinY()+h/2.0;
        GetDrawer2D()->SetMappingUpp( middlexworld - clientw/2.0*uppx, middleyworld - clienth/2.0*uppx, uppx, uppx );
    }

    // if scrolling bars were added are removed because of the above, we do it once more.
    int clientwNew, clienthNew;
    GetVirtualSize( &clientwNew, &clienthNew );
    if ( clientw != clientwNew || clienth != clienthNew )    
    {
        //what is needed in units per pixel to make height of bbox fit.
        if ( clientw - m_border > 0 )
            uppx = w/(clientw - m_border);
        else
            uppx = w/clientw;

        //what is needed in units per pixel to make width of bbox fit.
        if ( clienth - m_border > 0 )
            uppy = h/(clienth - m_border);
        else
            uppy = h/clienth;

        // now take the largets, to make sure it will fit either in x or y
        if ( uppy > uppx )
            uppx = uppy;

        GetDrawer2D()->SetMappingDeviceRect( 0, 0, clientwNew, clienthNew );
        if ( !centre )
        {
            SetMappingWidthHeight( untr.GetMinX(),
                                   untr.GetMinY(),
                                   w,
                                   h
                                 );
        }
        else
        {
            double middlexworld = untr.GetMinX()+w/2.0;
            double middleyworld = untr.GetMinY()+h/2.0;
            GetDrawer2D()->SetMappingUpp( middlexworld - clientwNew/2.0*uppx, middleyworld - clienthNew/2.0*uppx, uppx, uppx );
        }
    }

    m_view->Update( a2dCANVIEW_UPDATE_ALL ); 
    GetDrawer2D()->EndRefreshDisplayDisable();
    Refresh();
}

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