zoomcur.cpp

Go to the documentation of this file.

/*! \file curves/src/zoomcur.cpp
    \author Klaas Holwerda

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: zoomcur.cpp,v 1.20 2008/08/19 23:17:11 titato Exp $
*/

#pragma warning(disable:4786)

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include <wx/wfstream.h>
#include <math.h>

#if wxART2D_USE_CANEXTOBJ
    #include "wx/canextobj/eval.h"
#endif //wxART2D_USE_CANEXTOBJ

#include "wx/curves/meta.h"

#include "wx/canvas/canobj.h"
#include "wx/canvas/candoc.h"
#include "wx/canvas/drawer.h"
#include "wx/canvas/canvas.h"
#include "wx/canvas/cancom.h"

#if wxART2D_USE_EDITOR
    #include "wx/editor/edit.h"
#endif //wxART2D_USE_EDITOR

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

IMPLEMENT_CLASS(a2dCurveZoomTool,a2dStTool)


//! used to set internal boundaries of canvas plot objects
/*!
*/
class a2dCommand_SetInternalBoundaries: public a2dCommand
{

public:

    static const a2dCommandId COMID_SetInternalBoundaries;

    a2dCommand_SetInternalBoundaries( a2dCanvasXYDisplayGroupAreas* object, a2dBboxHash* irectHash);
//          double x1, double y1, double x2, double y2 );
    ~a2dCommand_SetInternalBoundaries(void);

    bool Do(void);
    bool Undo(void);

    inline a2dCanvasCommandProcessor *GetCanvasCmp() { return wxStaticCast( m_cmp, a2dCanvasCommandProcessor); }

protected:

    a2dSmrtPtr<a2dBboxHash> m_irectHash;
//    double m_x1;
//    double m_y1;
//    double m_x2;
//    double m_y2;

    a2dSmrtPtr<a2dCanvasXYDisplayGroupAreas> m_canvasobject;


};

const a2dCommandId a2dCommand_SetInternalBoundaries::COMID_SetInternalBoundaries( wxT("SetInternalBoundaries") );

/*
*   a2dCommand_SetInternalBoundaries
*/

a2dCommand_SetInternalBoundaries::a2dCommand_SetInternalBoundaries(
        a2dCanvasXYDisplayGroupAreas* object, a2dBboxHash* irectHash) :
//      double x1, double y1, double x2, double y2):
        a2dCommand( true, COMID_SetInternalBoundaries ), m_irectHash(irectHash)
{
    m_canvasobject = object;
//    m_x1 = x1;
//    m_y1 = y1;
//    m_x2 = x2;
//    m_y2 = y2;
}

a2dCommand_SetInternalBoundaries::~a2dCommand_SetInternalBoundaries(void)
{
}

bool a2dCommand_SetInternalBoundaries::Do(void)
{
    a2dBboxHash* oldIRectHash = new a2dBboxHash;
    const a2dCurvesAreaList& areaList = m_canvasobject->GetCurvesAreaList();
    size_t i;
    for(i=0; i < areaList.GetCount(); i++)
    {
        a2dCurvesArea* area = areaList.Item(i);
        const a2dBoundingBox& aRect = area->GetInternalBoundaries();
        (*oldIRectHash)[area->GetName()] = aRect;
    }

    for(i=0; i < areaList.GetCount(); i++)
    {
        a2dCurvesArea* area = areaList.Item(i);
        const a2dBoundingBox& aRect = (*m_irectHash)[area->GetName()];
        area->SetInternalBoundaries(m_canvasobject->GetPlotAreaRect(),aRect);
    }
    m_canvasobject->SetPending(true);
    m_canvasobject->GetAxisX()->SetPending(true);
    if(m_canvasobject->GetCursor())
        m_canvasobject->GetCursor()->SetPending(true);

    m_irectHash = oldIRectHash;

    m_canvasobject->Update( a2dCanvasObject::updatemask_normal );

    GetCanvasCmp()->GetCanvasDocument()->Modify(true);
    GetCanvasCmp()->GetCanvasDocument()->UpdateAllViews( NULL, a2dCANVIEW_UPDATE_OLDNEW|a2dCANVIEW_UPDATE_VIEWDEPENDENT|a2dCANVIEW_UPDATE_VIEWDEPENDENT_RIGHTNOW );

    return true;
}

bool a2dCommand_SetInternalBoundaries::Undo(void)
{
    a2dBboxHash* oldIRectHash = new a2dBboxHash;
    const a2dCurvesAreaList& areaList = m_canvasobject->GetCurvesAreaList();
    size_t i;
    for(i=0; i < areaList.GetCount(); i++)
    {
        a2dCurvesArea* area = areaList.Item(i);
        const a2dBoundingBox& aRect = area->GetInternalBoundaries();
        (*oldIRectHash)[area->GetName()] = aRect;
    }

    for(i=0; i < areaList.GetCount(); i++)
    {
        a2dCurvesArea* area = areaList.Item(i);
        const a2dBoundingBox& aRect = (*m_irectHash)[area->GetName()];
        area->SetInternalBoundaries(m_canvasobject->GetPlotAreaRect(),aRect);
    }
    m_canvasobject->SetPending(true);
    m_canvasobject->GetAxisX()->SetPending(true);
    if(m_canvasobject->GetCursor())
        m_canvasobject->GetCursor()->SetPending(true);

    m_irectHash = oldIRectHash;

    m_canvasobject->Update( a2dCanvasObject::updatemask_normal );

    GetCanvasCmp()->GetCanvasDocument()->Modify(true);
    GetCanvasCmp()->GetCanvasDocument()->UpdateAllViews( NULL, a2dCANVIEW_UPDATE_OLDNEW|a2dCANVIEW_UPDATE_VIEWDEPENDENT|a2dCANVIEW_UPDATE_VIEWDEPENDENT_RIGHTNOW );

    return true;
}


//----------------------------------------------------------------------------
// a2dCurveZoomTool
//----------------------------------------------------------------------------

#if wxART2D_USE_EDITOR

#define CONTRDRAWER m_controller->GetCanvasView()
#define CONTRDRAWER2D m_controller->GetCanvasView()->GetDrawer2D()

A2D_BEGIN_EVENT_TABLE(a2dCurveZoomTool,a2dStTool)
    A2D_EVT_CHAR(a2dCurveZoomTool::OnChar)
    A2D_EVT_MOUSE_EVENTS(a2dCurveZoomTool::OnMouseEvent)
A2D_END_EVENT_TABLE()

a2dCurveZoomTool::a2dCurveZoomTool(a2dStToolContr* controller):a2dStTool(controller)
{
    m_anotate = true;//false;
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_MAGNIFIER );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );

    //stroke and fill should not change as in base class for m_canvasobject
    if(a2dDocviewGlobals->GetEventDistributer())
        a2dDocviewGlobals->GetEventDistributer()->Unregister( this );

    //i like transparent fill and specific stroke
    SetFill( *a2dTRANSPARENT_FILL );
    SetStroke( a2dStroke(*wxBLACK, 1, a2dSTROKE_LONG_DASH) );
}

a2dCurveZoomTool::~a2dCurveZoomTool()
{
}

void a2dCurveZoomTool::GenerateAnotation()
{
    // Add old (and later new) annotation area to pending region
    a2dStTool::AddAnotationToPendingUpdateArea();

    a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );
    m_anotation.Printf( wxT("w %6.3f h %6.3f") , rec->GetWidth(), rec->GetHeight() );
    m_xanotation = m_x;
    m_yanotation = m_y;

    wxDC *dc = GetDrawer2D()->GetRenderDC();
    if ( dc )
    {
        wxCoord w, h;
        dc->SetFont( m_annotateFont );
        dc->GetTextExtent( m_anotation, &w, &h );
        m_xanotation = m_x + (int) h;
        m_yanotation = m_y + (int) h;
        a2dStTool::AddAnotationToPendingUpdateArea();
    }
}

void a2dCurveZoomTool::OnChar(wxKeyEvent& event)
{
    if (!GetBusy())
    {
        switch(event.GetKeyCode())
        {
            case WXK_RETURN:
            {
                m_stcontroller->Zoomout();
            }
            break;
            case WXK_SUBTRACT:
            {
                m_stcontroller->ZoomUndo();
            }
            break;
            default:
                event.Skip();
        }
    }
    else
        event.Skip();
}

void a2dCurveZoomTool::OnMouseEvent(wxMouseEvent& event)
{
    if (!m_active)
    {
        event.Skip();
        return;
    }

    if ( GetBusy() )
        GetCanvasView()->SetCursor( m_toolBusyCursor );
    else
        GetCanvasView()->SetCursor( m_toolcursor );

    m_x = event.GetX();
    m_y = event.GetY();
    MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

    if (event.LeftDClick() && !GetBusy())
    {

        a2dCanvasObject* object;
        object = GetCanvasView()->IsHitWorld( m_xwprev, m_ywprev );

        if (!object)
            return;
        if (0 == wxDynamicCast(object , a2dCanvasXYDisplayGroupAreas))
        {
            m_curves=0;
            return;
        }
        m_curves=(a2dCanvasXYDisplayGroupAreas*)object;

        a2dBboxHash* aHash = new a2dBboxHash;
//      m_curves->AppendInternalBoundaries(aHash);
        m_curves->AppendCurvesBoundaries(aHash);

        GetCanvasDocument()->GetCommandProcessor()->Submit(
                        new a2dCommand_SetInternalBoundaries( m_curves, aHash));

        m_curves->SetPending( true );
    }
    else if (event.LeftDown() && !GetBusy())
    {
        a2dCanvasObject* object;
        object = GetCanvasView()->IsHitWorld( m_xwprev, m_ywprev );

        if (!object)
            return;
        if ( 0 == wxDynamicCast(object , a2dCanvasXYDisplayGroupAreas) )
        {
            m_curves = 0;
            return;
        }
        m_curves = (a2dCanvasXYDisplayGroupAreas*)object;

        a2dRect* rec = new a2dRect( m_xwprev, m_ywprev, 0, 0, 0);
        m_parentobject = GetCanvasView()->GetShowObject();
        m_canvasobject = rec;
        AddDecorationObject( rec );

        rec->SetCanvasDocument( GetCanvasView()->GetCanvasDocument() );
        rec->SetFill( m_fill );
        rec->SetStroke( m_stroke );
        rec->Update( a2dCanvasObject::updatemask_force );
        m_pending = true;
        EnterBusyMode();

        //special case to have the canvas itself recieve at least this one also.
        //because often the zoomtool is active as only tool, but
        //some object on the canvas are meant to react to MD (Href's etc.)
        event.Skip();
    }
    else if ( event.LeftUp() /*event.LeftDown()*/ && GetBusy())
    {
        a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );

        double w = GetDrawer2D()->WorldToDeviceXRel( rec->GetWidth() );
        double h = GetDrawer2D()->WorldToDeviceYRel( rec->GetHeight() );

        a2dAffineMatrix tworld = m_curves->GetTransformMatrix();

        a2dAffineMatrix inverse = tworld;
        inverse.Invert();

        //to be able to intercept doubleclick
        //ignore the LeftDown and LeftUp if mouse position is the same
        if (fabs( w ) < 3 && fabs( h )< 3)
        {
            FinishBusyMode();
            SetPending( true );
            a2dCursor* aCursor = m_curves->GetCursor();
            if(aCursor)
            {
//              m_curves->SetCursorPosition(rec->GetPosX(),rec->GetPosY());
                double xwi;
                double ywi;
                inverse.TransformPoint( rec->GetPosX(),rec->GetPosY(), xwi, ywi );
                a2dSmrtPtr<a2dCurvesArea> area = m_curves->GetCurvesAreaList().GetBaseCurvesArea();
                double xcurve, ycurve;
                area->World2Curve( xwi, ywi, xcurve, ycurve );
                aCursor->SetPosition(xcurve, ycurve, area->GetCurveAreaTransform());
            }
            event.Skip();
        }
        else
        {
            double xwi;
            double ywi;
            double x2wi;
            double y2wi;
            inverse.TransformPoint( rec->GetBbox().GetMinX(), rec->GetBbox().GetMinY(), xwi, ywi );
            inverse.TransformPoint( rec->GetBbox().GetMaxX(), rec->GetBbox().GetMaxY(), x2wi, y2wi );

            a2dBboxHash* aHash = new a2dBboxHash;

            const a2dCurvesAreaList& areaList = m_curves->GetCurvesAreaList();
            for(size_t i=0; i < areaList.GetCount(); i++)
            {
                a2dCurvesArea* area = areaList.Item(i);

                double xcurve, ycurve;
                double xcurve2, ycurve2;
                area->World2Curve( xwi, ywi, xcurve, ycurve );
                area->World2Curve( x2wi, y2wi, xcurve2, ycurve2 );

                a2dBoundingBox aRect(xcurve, ycurve, xcurve2, ycurve2);
                (*aHash)[area->GetName()] = aRect;
            }

            GetCanvasDocument()->GetCommandProcessor()->Submit(
                            new a2dCommand_SetInternalBoundaries( m_curves, aHash ) );

            m_curves->SetPending( true );

            FinishBusyMode();
            event.Skip();
        }
    }
    else  if ((event.Dragging() && GetBusy()) /*|| (event.Moving() && GetBusy())*/ )
    {
        a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );
        rec->SetWidth( m_xwprev - rec->GetPosX() );
        rec->SetHeight( m_ywprev - rec->GetPosY() );

        m_pending = true;
    }
    else
        event.Skip();
}

#endif //wxART2D_USE_EDITOR

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