mastertool.cpp

Go to the documentation of this file.

/*! \file editor/src/mastertool.cpp
    \author Michael S�gtrop
    \date Created 02/06/2004

    Copyright: 2004-2004 (c) Michael S�gtrop

    Licence: wxWidgets Licence

    RCS-ID: $Id: mastertool.cpp,v 1.109 2009/08/07 20:31:32 titato Exp $
*/

// This file contains master tools. This are tools that customize GUI behaviour
// by intercepting events and then deligating work to other tools

#include "a2dprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/canvas/canmod.h"
//#include "wx/filename.h"

#include <float.h>
#include "wx/editor/sttool.h"
#include "wx/editor/sttool2.h"
#include "wx/editor/mastertool.h"
#include <wx/general/id.inl>

IMPLEMENT_CLASS(a2dGraphicsMasterTool,a2dStTool)

A2D_BEGIN_EVENT_TABLE( a2dGraphicsMasterTool,a2dStTool )
    A2D_EVT_MOUSE_EVENTS( a2dGraphicsMasterTool::OnMouseEvent )
    A2D_EVT_CHAR( a2dGraphicsMasterTool::OnChar )
    A2D_EVT_KEY_DOWN( a2dGraphicsMasterTool::OnKeyDown )
A2D_END_EVENT_TABLE()

a2dGraphicsMasterTool::a2dGraphicsMasterTool(a2dStToolContr* controller):a2dStTool(controller)
{
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  );
    m_mode = mode_none;
    m_canvasobject=0;
    m_modehit = 0;

    controller->SetDefaultBehavior( controller->GetDefaultBehavior() | wxTC_NoDefaultKeys | wxTC_NoDefaultMouseActions );
}

a2dGraphicsMasterTool::~a2dGraphicsMasterTool()
{
}

void a2dGraphicsMasterTool::PushDrawWireTool( a2dCanvasObject *WXUNUSED(hit) )
{
    a2dDrawWirePolylineLTool *tool = new a2dDrawWirePolylineLTool( GetStToolContr() );
    tool->SetOneShot();
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushDragTool( a2dCanvasObject *hit )
{
    SelectHitObject( hit );
    a2dDragTool *tool = new a2dDragTool( GetStToolContr() );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetDeleteOnOutsideDrop( true );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushDragMultiTool( a2dCanvasObject *WXUNUSED(hit) )
{
    a2dDragMultiTool *tool = new a2dDragMultiTool( GetStToolContr() );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushCopyTool( a2dCanvasObject *hit )
{
    SelectHitObject( hit );
    a2dCopyTool *tool = new a2dCopyTool( GetStToolContr() );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetDeleteOnOutsideDrop( true );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushCopyMultiTool( a2dCanvasObject *WXUNUSED(hit) )
{
    a2dCopyMultiTool *tool = new a2dCopyMultiTool( GetStToolContr() );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushSelectTool()
{
    a2dSelectTool *tool = new a2dSelectTool( GetStToolContr() );
    tool->SetShiftIsAdd();
    tool->SetOneShot();

    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushEditWireVertexTool( a2dCanvasObject *hit, int vertex )
{
    a2dPolygonL *poly = wxStaticCast( hit, a2dPolygonL );
    SelectHitObject( hit );
    a2dSimpleEditPolygonTool *tool = new a2dSimpleEditPolygonTool( GetStToolContr(), hit, vertex, poly->GetSegments()->size(), a2dSimpleEditPolygonTool::action_movevertex );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireVertex ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireVertex ) );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushEditWireSegmentHorizontalTool( a2dCanvasObject *hit, int segment )
{
    a2dPolygonL *poly = wxStaticCast( hit, a2dPolygonL );
    SelectHitObject( hit );
    a2dSimpleEditPolygonTool *tool = new a2dSimpleEditPolygonTool( GetStToolContr(), hit, segment, poly->GetSegments()->size(), a2dSimpleEditPolygonTool::action_movesegment );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireSegmentHorizontal ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireSegmentHorizontal ) );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushEditWireSegmentVerticalTool( a2dCanvasObject *hit, int segment )
{
    a2dPolygonL *poly = wxStaticCast( hit, a2dPolygonL );
    SelectHitObject( hit );
    a2dSimpleEditPolygonTool *tool = new a2dSimpleEditPolygonTool( GetStToolContr(), hit, segment, poly->GetSegments()->size(), a2dSimpleEditPolygonTool::action_movesegment );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireSegmentVertical ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireSegmentVertical ) );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::PushEditWireSegmentInsertTool( a2dCanvasObject *hit, int segment )
{
    a2dPolygonL *poly = wxStaticCast( hit, a2dPolygonL );
    SelectHitObject( hit );
    a2dSimpleEditPolygonTool *tool = new a2dSimpleEditPolygonTool( GetStToolContr(), hit, segment, poly->GetSegments()->size(), a2dSimpleEditPolygonTool::action_insertvertex );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_WireSegmentInsert ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_WireSegmentInsert ) );
    m_controller->PushTool( tool );
}

void a2dGraphicsMasterTool::DeselectAll()
{
    GetCanvasCommandProcessor()->Submit( new a2dCommand_Select( a2dCommand_Select::Args().what(a2dCommand_Select::DeSelectAll) ) );
}

bool a2dGraphicsMasterTool::ZoomSave()
{
    return true;
}

void a2dGraphicsMasterTool::DoStopTool( bool abort )
{
    a2dStTool::DoStopTool( abort );
}

void a2dGraphicsMasterTool::OnChar(wxKeyEvent& event)
{
    switch( event.GetKeyCode() )
    {
        case WXK_DELETE:
        {
            wxASSERT( m_parentobject == GetCanvasView()->GetShowObject() );
            // delete all selected objects
            OpenCommandGroupNamed( _("Delete selected objects") );
            a2dCanvasObjectList list;
            m_parentobject->CollectObjects(
                &list,
                wxT(""), a2dCanvasOFlags::SELECTED, NULL );

            for( a2dCanvasObjectList::iterator iter = list.begin(); iter != list.end(); ++iter )
            {
                a2dCanvasObject *obj = (*iter);
                // remove the pin connections in an undoable way
                obj->ClearAllPinConnections( GetCanvasCommandProcessor() );
                //delete object from document (actually move to command for redo)
                GetCanvasCommandProcessor()->Submit( new a2dCommand_ReleaseObject(  m_parentobject, obj ));
            }
            CloseCommandGroup( );
            break;
        }
        default:
            event.Skip();
    }
}


void a2dGraphicsMasterTool::OnKeyDown(wxKeyEvent& event)
{
    //wxLogDebug(wxT("key %d"), event.GetKeyCode());
    a2dBaseTool* first = m_stcontroller->GetFirstTool();

    switch(event.GetKeyCode())
    {
        case WXK_ESCAPE:
        {
            if ( first && first->AllowPop() )
                first->StopTool( false );
            return;
        }
        break;
        default:
            event.Skip();
    }

    if ( !m_active ) 
    {
        event.Skip();
        return;
    }

    switch(event.GetKeyCode())
    {

        case WXK_CONTROL:
        {
            if  ( !first || ( first && !first->GetBusy()) )
            {
                if ( !wxDynamicCast(first, a2dDragTool) )
                {
                    a2dDragTool* drag = new a2dDragTool(m_stcontroller);
                    m_stcontroller->PushTool(drag);
                    drag->SetOneShot();
                }
            }
        }
        break;
        case 'Z':
        case 'z':
        {
            if ( event.m_controlDown && event.m_shiftDown )
                GetCanvasCommandProcessor()->Redo();
            else if ( event.m_controlDown )
                GetCanvasCommandProcessor()->Undo();
            else if  ( !first || ( first && !first->GetBusy()) )
            {
                a2dZoomTool* zoom = new a2dZoomTool(m_stcontroller);
                m_stcontroller->PushTool(zoom);
            }
            break;
        }
        case 'Y':
        case 'y':
        {
            if ( event.m_controlDown )
                GetCanvasCommandProcessor()->Redo();
            break;
        }
        case WXK_NUMPAD_ADD:
        {
            if ( event.m_controlDown )
                m_stcontroller->ZoomIn2AtMouse();
            else
                m_stcontroller->Zoomin2();
            break;
        }
        case WXK_NUMPAD_SUBTRACT:
        {
            if ( event.m_controlDown )
                m_stcontroller->ZoomOut2AtMouse();
            else
                m_stcontroller->Zoomout2();
            break;
        }
        default:
            event.Skip();
    }
}

void a2dGraphicsMasterTool::OnMouseEvent(wxMouseEvent& event)
{
    if (!m_active)
    {
        event.Skip();
        return;
    }
    m_x = event.GetX();
    m_y = event.GetY();

    //to world coordinates to do hit test in world coordinates
    double xw;
    double yw;

    xw = GetDrawer2D()->DeviceToWorldX(m_x);
    yw = GetDrawer2D()->DeviceToWorldY(m_y);

    if ( event.Moving() && !GetBusy() && !event.ShiftDown() && !event.ControlDown() )
    {
        //there is no wire nor pin yet, therefore we can just feedback possible pin connection
        a2dPin::sm_feedbackOnPinmapConnect.SetMode( 2 );
        a2dPin::sm_feedbackOnPinmapConnect.SetTask( a2d_ToConnectPinClassWire_ObjectPinClass_InOut );
        a2dPin::sm_feedbackOnPinmapConnect.SetPinClass( a2dPinClass::Any );
        a2dIterC ic( GetCanvasView() );
        GetCanvasView()->GetShowObject()->EditFeedback( ic, &a2dPin::sm_feedbackOnPinmapConnect, NULL, 2, 0, xw, yw );
    }

    a2dHitEvent hitinfo( xw, yw, false, a2dCANOBJHITOPTION_NONE, true );
    a2dCanvasObject* hit = GetCanvasView()->IsHitWorld( hitinfo, wxLAYER_ALL );

/*
    if( hit )
    {
        wxLogDebug( hit->GetClassInfo()->GetClassName() );
        switch( how.m_hit )
        {
        case a2dHit::hit_none:
            wxLogDebug( "Hit NoHit" );
            break;
        case a2dHit::hit_stroke:
            wxLogDebug( "Hit Stroke" );
            break;
        case a2dHit::hit_fill:
            wxLogDebug( "Hit Fill" );
            break;
        default:
            wxLogDebug( "Hit ?" );
            break;
        }

        switch( how.m_stroke2 )
        {
        case a2dHit::stroke2_none:
            wxLogDebug( "Stroke None" );
            break;
        case a2dHit::stroke2_vertex:
            wxLogDebug( "Stroke Vertex" );
            break;
        case a2dHit::stroke2_edgehor:
            wxLogDebug( "Stroke Horizontal" );
            break;
        case a2dHit::stroke2_edgevert:
            wxLogDebug( "Stroke Vertical" );
            break;
        case a2dHit::stroke2_edgeother:
            wxLogDebug( "Stroke Other" );
            break;
        }
    }
    else
        wxLogDebug( "NoHit" );
*/

    if ( event.Moving() && !GetBusy() )
    {
        m_mode = mode_none;
        m_modehit = 0;
        m_modehitinfo = a2dHit();

        if( hit )
        {
            a2dHit how2;

            // Check if there is an unconnected pin
            // This has highest priority

            a2dPin* pin = NULL;
            if ( !event.ShiftDown() && !event.ControlDown() )
                pin = FindUnConnectedPin( GetCanvasView()->GetShowObject(), xw, yw );

            /* INSTEAD OFF?
            a2dPin *pin = 0;
            {
                //First try to find object pins which are not of connection/wire objects
                int i;
                float minDist = FLT_MAX;
                for( i=0; i< hitinfo.m_extended.size(); i++ )
                {
                    a2dPin *pin2 = wxDynamicCast( hitinfo.m_extended[i].GetObject(), a2dPin );
                    if( 
                        pin2 && 
                        !pin2->ConnectedTo() && 
                        pin2->GetPinClass() && pin2->GetPinClass()->IsObjectPin() && 
                        hitinfo.m_extended[i].GetHitType().m_distance < minDist
                    ) 
                    {
                        pin = pin2;
                        how2 = hitinfo.m_extended[i].GetHitType();
                        minDist = how2.m_distance;
                    }
                }
                if ( !pin )
                    //Now try to find object pins which are of connection/wire objects
                    for( i=0; i< hitinfo.m_extended.size(); i++ )
                    {
                        a2dPin *pin2 = wxDynamicCast( hitinfo.m_extended[i].GetObject(), a2dPin );
                        if( 
                            pin2 && 
                            !pin2->ConnectedTo() && 
                            pin2->GetPinClass() && !pin2->GetPinClass()->IsObjectPin() ) && 
                            hitinfo.m_extended[i].GetHitType().m_distance < minDist
                        ) 
                        {
                            pin = pin2;
                            how2 = hitinfo.m_extended[i].GetHitType();
                            minDist = how2.m_distance;
                        }
                    }
            }
            */

            // Check if there is a wire
            a2dWirePolylineL *wire = 0;
            if( !pin ) 
            {
                int i;
                float minDist = FLT_MAX;
                for( i=0; i< hitinfo.m_extended.size(); i++ )
                {
                    a2dWirePolylineL *wire2 = wxDynamicCast( hitinfo.m_extended[i].GetObject(), a2dWirePolylineL );
                    if( wire2 && hitinfo.m_extended[i].GetHitType().m_distance < minDist && hitinfo.m_extended[i].GetHitType().IsDirectStrokeHit() )
                    {
                        wire = wire2;
                        how2 = hitinfo.m_extended[i].GetHitType();
                        minDist = how2.m_distance;
                    }
                }
            }

            if( pin )
            {
                // wire drawing mode
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_DrawWire ) );
                m_mode = mode_drawwire;
                m_modehit = pin;
            }
            else if ( wire )
            {
                // wire edting mode
                // check, where the wire was hit:
                m_modehit = wire;
                m_modehitinfo = how2;
                switch( how2.m_stroke2 )
                {
                case a2dHit::stroke2_vertex:
                    GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireVertex ) );
                    m_mode = mode_editwire_vertex;
                    break;
                case a2dHit::stroke2_edgehor:
                    GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireSegmentHorizontal ) );
                    m_mode = mode_editwire_segmenthorizontal;
                    break;
                case a2dHit::stroke2_edgevert:
                    GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditWireSegmentVertical ) );
                    m_mode = mode_editwire_segmentvertical;
                    break;
                case a2dHit::stroke2_edgeother:
                    GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_WireSegmentInsert ) );
                    m_mode = mode_editwire_segmentinsert;
                    break;
                default:
                    assert(0);
                    m_modehit = 0;
                    m_modehitinfo = a2dHit();
                }
            }
            else if ( !event.ShiftDown() && hit->GetDraggable() && 
                      ( hitinfo.m_how.IsInsideHit() ||                     
                        wxDynamicCast( hit, a2dPolylineL ) 
                      )
                    ) 
            {
                if( !event.ControlDown() )
                {
                    if( hit->GetSelected() )
                    {
                        // drag selected mode
                        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
                        m_mode = mode_dragmulti;
                        m_modehit = hit;
                    }
                    else
                    {
                        // drag mode
                        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
                        m_mode = mode_drag;
                        m_modehit = hit;
                    }
                }
                else
                {
                    if( hit->GetSelected() )
                    {
                        // copy selected mode
                        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
                        m_mode = mode_copymulti;
                        m_modehit = hit;
                    }
                    else
                    {
                        // drag mode
                        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
                        m_mode = mode_copy;
                        m_modehit = hit;
                    }
                }
            }
            else if ( event.ShiftDown() && hitinfo.m_how.IsInsideHit()  )
            {
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  ) );
                m_mode = mode_select;
                m_modehit = hit;
            }
            else
            {
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  ) );
                m_mode = mode_select;
                m_modehit = hit;
            }
        }
        else
        {
            GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  ) );
            m_mode = mode_select;
            m_modehit = hit;
        }
        event.Skip();
    }
    else if( event.LeftDown() && !GetBusy() )
    {
        switch( m_mode )
        {
        case mode_none:
            event.Skip();
            break;
        case mode_select:
            PushSelectTool();
            event.Skip();
            break;
        case mode_drag:
            PushDragTool(m_modehit);
            event.Skip();
            break;
        case mode_dragmulti:
            PushDragMultiTool(m_modehit);
            event.Skip();
            break;
        case mode_copy:
            PushCopyTool(m_modehit);
            event.Skip();
            break;
        case mode_copymulti:
            PushCopyMultiTool(m_modehit);
            event.Skip();
            break;
        case mode_drawwire:
            PushDrawWireTool(m_modehit);
            event.Skip();
            break;
        case mode_editwire_vertex:
            PushEditWireVertexTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        case mode_editwire_segmenthorizontal:
            PushEditWireSegmentHorizontalTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        case mode_editwire_segmentvertical:
            PushEditWireSegmentVerticalTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        case mode_editwire_segmentinsert:
            PushEditWireSegmentInsertTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        default:
            event.Skip();
        }
    }
    else
    {
        event.Skip();
    }
}

void a2dGraphicsMasterTool::SelectHitObject( a2dCanvasObject *hit )
{
    OpenCommandGroupNamed( _("Select") );

    DeselectAll();

    GetCanvasCommandProcessor()->Submit(
        new a2dCommand_SetFlag( hit, a2dCanvasOFlags::SELECTED, true ));

    CloseCommandGroup();
}

IMPLEMENT_CLASS(a2dSimpleEditPolygonTool,a2dStTool)

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

a2dSimpleEditPolygonTool::a2dSimpleEditPolygonTool( a2dStToolContr* controller, a2dCanvasObject *hit, int index, int count, Action action )
:
    a2dStTool(controller)
{
    a2dDocviewGlobals->GetEventDistributer()->Register( this );

    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  );
    m_original = hit;
    m_index = index;
    m_count = count;
    m_action = action;
    
    m_mode = 1;
    GetCanvasView()->SetMouseEvents(false);
}

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

    if ( GetCanvasView() )
        GetCanvasView()->SetMouseEvents(true);
}

bool a2dSimpleEditPolygonTool::EnterBusyMode()
{
    m_preserve_select = m_original->GetSelected();

    if( !a2dStTool::EnterBusyMode() )
        return false;

    m_controller->GetCanvasView()->FindAndSetCorridorPath( m_canvasobject, true );
    return true;
}

void a2dSimpleEditPolygonTool::FinishBusyMode()
{
    if ( GetCanvasView() ) 
    {
        GetCanvasView()->ClearCorridorPath( true );
    }

    wxASSERT( GetBusy() );

    // The pin which is edited may reconnect
    a2dCanvasObject::a2dDoUpdateImmediateData data( true, this, NULL );
    if( m_action == action_movevertex )
    {
        if( m_index == 0 )
            data.m_allowreconnectbegin = true;
        else if( m_index == m_count-1 )
            data.m_allowreconnectend = true;
    }
    m_connectedwirecopies.UpdateImmediate( true, this, m_canvasobject, NULL, &data );

    m_original->SetSelected( m_preserve_select );

    a2dStTool::FinishBusyMode();
}

void a2dSimpleEditPolygonTool::AbortBusyMode()
{
    if ( GetCanvasView() ) 
        GetCanvasView()->ClearCorridorPath( true );

    a2dStTool::FinishBusyMode();
}

void a2dSimpleEditPolygonTool::DoStopTool( bool abort ) 
{ 
    if ( GetCanvasView() ) 
        GetCanvasView()->ClearCorridorPath( true );

    a2dStTool::DoStopTool( abort ); 
}

void a2dSimpleEditPolygonTool::OnChar(wxKeyEvent& event)
{
    event.Skip();
}

void a2dSimpleEditPolygonTool::OnMouseEvent(wxMouseEvent& event)
{
    if (!m_active)
    {
        event.Skip();
        return;
    }
    m_x = event.GetX();
    m_y = event.GetY();

    //to world coordinates to do hit test in world coordinates
    double xw;
    double yw;

    xw = GetDrawer2D()->DeviceToWorldX(m_x);
    yw = GetDrawer2D()->DeviceToWorldY(m_y);

    if( event.LeftDown() && !GetBusy() )
    {
        if ( !EnterBusyMode() )
            return; //not editable object
        
        //we generate some help handles, which get events sent to them via the event corridor to m_canvasobject.

        // m_original->StartEdit() did add m_canvasobject as an editcopy, so eventually those temporary handles will 
        // be deleted when m_canvasobject is released.
        a2dPolygonL* poly = wxDynamicCast( m_canvasobject.Get(), a2dPolygonL );
        a2dPolygonL* original = wxDynamicCast( poly->GetOriginal(), a2dPolygonL );
        a2dVertexList::iterator iter = poly->GetSegments()->begin();
        a2dVertexList::iterator iterorg = original->GetSegments()->begin();
        switch( m_action )
        {
        case action_movevertex:
            m_handle = new a2dPolyHandleL( poly, iter, iterorg, poly->GetSegments(), original->GetSegments(), 0.0, 0.0, wxT("__index__") );
            break;
        
        case action_movesegment:
            m_handle = new a2dPolyHandleL( poly, iter, iterorg, poly->GetSegments(), original->GetSegments(), 0.0, 0.0, wxT("__segment__") );
            break;

        case action_insertvertex:
            m_handle = new a2dPolyHandleL( poly, iter, iterorg, poly->GetSegments(), original->GetSegments(), 0.0, 0.0, wxT("__insert__") );
            break;

        default:
            wxASSERT(0);
        }
    }

/*
        pin.FindConnectablePin( tool->GetCanvasView()->GetShowObject(), 1.0, false );
    if( event.Dragging() && m_action == action_movevertex )
    {
        a2dWirePolyline *wire = 
        a2dPin *FindEdnPin();
        a2dPin tmp(
            m_canvasobject, wxT("end"), 
            m_thePinClassMap ? *m_thePinClassMap->m_wireEnd : a2dPinClass::Standard,
            m_xwprev, m_ywprev
        );
        a2dIterC ic( GetCanvasView() );
        GetCanvasView()->GetShowObject()->EditFeedback( ic, &a2dPin::sm_feedbackGeneratePin, &tmp, 2, 0, m_xw, m_yw );
    }
*/

    if( event.LeftDown() || event.LeftUp() || event.Dragging() )
    {
        a2dPolygonL* poly = wxDynamicCast( m_canvasobject.Get(), a2dPolygonL );
        poly->SetHandleToIndex( m_handle, m_index );

        a2dHandleMouseEvent handleEvent( 0, m_handle.Get(), xw, yw, event );
        bool isHit;
        GetCanvasView()->ProcessCanvasObjectEvent( handleEvent, isHit, xw, yw, 5 );

        //! todo have this all inside the object itself.
        //bool isHit;
        //GetCanvasView()->ProcessCanvasObjectEvent( event, isHit, xw, yw, 5 );

        m_connectedwirecopies.UpdateImmediate( false, this );
    }

    if( event.LeftUp() && GetBusy() )
    {
        FinishBusyMode();
    }
}

bool a2dSimpleEditPolygonTool::CreateToolObjects()
{
    // Clone the original object
    m_canvasobject = m_original->StartEdit( this, m_mode, wxEDITSTYLE_COPY | wxEDITSTYLE_NOHANDLES | wxEDITSTYLE_CONNECTED );
    if ( !m_canvasobject )
        return false; //not editable object

    // Collect and clone the connected wires
    a2dCanvasObjectList connectedwires;
    connectedwires.push_back( m_original );
    m_original->CreateWireEditCopies( &connectedwires, &m_connectedwirecopies );
    m_canvasobject->RestoreConnectionsAfterCloning();
    m_connectedwirecopies.RestoreConnectionsAfterCloning();

    // Set the visibility of the original dragged object and the original connected wires
    AdjustRenderOptions();
    m_original->SetVisible( m_renderOriginal );
    connectedwires.SetSpecificFlags( m_renderOriginal, a2dCanvasOFlags::VISIBLE );

    // Add the draged object clone and connected object clones to the parent
    // Note: m_canasobject is added by startedit
    for( a2dCanvasObjectList::iterator iter = m_connectedwirecopies.begin(); iter != m_connectedwirecopies.end(); ++iter )
    {
        a2dCanvasObject *obj = (*iter);
        AddEditobject( obj );
    }

    m_pending = true;

    return true;
}

void a2dSimpleEditPolygonTool::CleanupToolObjects()
{
    a2dStTool::CleanupToolObjects();
    m_connectedwirecopies.clear();
}

//----------------------------------------------------------------------------
// a2dMasterDrawBase
//----------------------------------------------------------------------------

IMPLEMENT_CLASS(a2dMasterDrawBase,a2dStTool)

A2D_BEGIN_EVENT_TABLE( a2dMasterDrawBase,a2dStTool )
    A2D_EVT_MOUSE_EVENTS( a2dMasterDrawBase::OnMouseEvent )
    A2D_EVT_CHAR( a2dMasterDrawBase::OnChar )
    A2D_EVT_KEY_DOWN( a2dMasterDrawBase::OnKeyDown )
    A2D_EVT_KEY_UP( a2dMasterDrawBase::OnKeyUp )
A2D_END_EVENT_TABLE()

a2dMasterDrawBase::a2dMasterDrawBase(a2dStToolContr* controller):a2dStTool(controller)
{
    m_dragStarted = false;
    m_toolBusy = false;

    m_fastTools = false;
    m_spaceDown = false;
    m_allowMultiEdit = true;
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_Select  );
    m_mode = mode_none;
    m_canvasobject=0;
    m_modehit = 0;

    controller->SetDefaultBehavior( controller->GetDefaultBehavior() | wxTC_NoDefaultKeys | wxTC_NoDefaultMouseActions );

    m_eventHandler = new a2dStToolFixedToolStyleEvtHandler( controller );

    if ( GetCanvasView()->GetDrawer2D()->HasAlpha() || GetCanvasView()->GetTrippleBufHasAlpha() )
    {
        SetFill( a2dFill( wxColour( 66, 159, 235, 150 ) ) );
        SetStroke( a2dStroke( wxColour( 66, 159, 235, 165 ), 2, a2dSTROKE_LONG_DASH) );
    }
    else
    {
        SetFill( *a2dTRANSPARENT_FILL );
        SetStroke( a2dStroke(*wxBLACK, 2, a2dSTROKE_LONG_DASH) );
    }

    if ( GetCanvasView()->GetDrawer2D()->HasAlpha()  || GetCanvasView()->GetTrippleBufHasAlpha() )
    {
        m_selectFill = a2dFill( wxColour( 233, 15, 23, 150 ) );
        m_selectStroke = a2dStroke( wxColour( 255, 59, 25, 255 ), 2, a2dSTROKE_LONG_DASH );
    }
    else
    {
        m_selectFill = *a2dTRANSPARENT_FILL;
        m_selectStroke = a2dStroke(*wxRED, 2, a2dSTROKE_LONG_DASH);
    }

}

a2dMasterDrawBase::~a2dMasterDrawBase()
{
}

void a2dMasterDrawBase::PushZoomTool()
{
    a2dStTool* tool;
    if ( m_fastTools )
        tool = new a2dZoomFast( GetStToolContr() );
    else
        tool = new a2dZoomTool( GetStToolContr() );

    tool->SetOneShot();
    tool->SetFill( m_fill );
    tool->SetStroke( m_stroke );
    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushDragTool( a2dCanvasObject *hit )
{
    SelectHitObject( hit );
    a2dDragTool* tool;
    if ( m_fastTools )
        tool = new a2dDragTool( GetStToolContr() );
    else
        tool = new a2dDragTool( GetStToolContr() );

    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetDeleteOnOutsideDrop( true );
    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushDragMultiTool( a2dCanvasObject *WXUNUSED(hit) )
{
    a2dStTool* tool;
    if ( m_fastTools )
        tool = new a2dFastDragMultiTool( GetStToolContr() );
    else
        tool = new a2dDragMultiTool( GetStToolContr() );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushCopyTool( a2dCanvasObject *hit )
{
    SelectHitObject( hit );
    a2dCopyTool* tool;
    if ( m_fastTools )
        tool = new a2dCopyTool( GetStToolContr() );
    else
        tool = new a2dCopyTool( GetStToolContr() );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
    tool->SetDeleteOnOutsideDrop( true );
    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushCopyMultiTool( a2dCanvasObject *WXUNUSED(hit) )
{
    a2dStTool* tool;
    if ( m_fastTools )
        tool = new a2dFastCopyMultiTool( GetStToolContr() );
    else
        tool = new a2dCopyMultiTool( GetStToolContr() );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushSelectTool()
{
    a2dStTool* tool;
    if ( m_fastTools )
    {
        tool = new a2dFastSelect( GetStToolContr() );
        ((a2dFastSelect*)tool)->SetShiftIsAdd();
    }
    else
    {
        tool = new a2dSelectTool( GetStToolContr() );
        ((a2dSelectTool*)tool)->SetShiftIsAdd();
    }
    tool->SetOneShot();
    tool->SetFill( m_selectFill );
    tool->SetStroke( m_selectStroke );

    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushDeSelectTool()
{
    a2dStTool* tool;
    if ( m_fastTools )
    {
        tool = new a2dFastSelect2( GetStToolContr() );
        ((a2dFastSelect2*)tool)->SetSelectMode(false);
    }
    else
    {
        tool = new a2dFastSelect2( GetStToolContr() );
        ((a2dFastSelect2*)tool)->SetSelectMode(false);
    }
    tool->SetOneShot();
    tool->SetFill( m_selectFill );
    tool->SetStroke( m_selectStroke );

    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushEditVertexTool( a2dCanvasObject *hit, int vertex )
{
    a2dPolygonL *poly = wxStaticCast( hit, a2dPolygonL );
    SelectHitObject( hit );
    a2dSimpleEditPolygonTool *tool = new a2dSimpleEditPolygonTool( GetStToolContr(), hit, vertex, poly->GetSegments()->size(), a2dSimpleEditPolygonTool::action_movevertex );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditVertex ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditVertex ) );
    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushEditSegmentTool( a2dCanvasObject *hit, int segment )
{
    a2dPolygonL *poly = wxStaticCast( hit, a2dPolygonL );
    SelectHitObject( hit );
    a2dSimpleEditPolygonTool *tool = new a2dSimpleEditPolygonTool( GetStToolContr(), hit, segment, poly->GetSegments()->size(), a2dSimpleEditPolygonTool::action_movesegment );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Edit ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_Edit ) );
    m_controller->PushTool( tool );
}

void a2dMasterDrawBase::PushEditTool( a2dCanvasObject *hit )
{
    SelectHitObject( hit );
    a2dObjectEditTool* tool = new a2dObjectEditTool( m_stcontroller );
    tool->StartToEdit( hit );
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditSegment ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditSegment ) );
    m_stcontroller->PushTool( tool );
}

void a2dMasterDrawBase::PushMultiEditTool( a2dCanvasObject *hit )
{
    a2dMultiEditTool* tool = new a2dMultiEditTool( m_stcontroller );
    tool->StartEditingSelected();
    tool->SetOneShot();
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditSegment ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_EditSegment ) );
    m_stcontroller->PushTool( tool );
}

void a2dMasterDrawBase::DeselectAll()
{
    GetCanvasCommandProcessor()->Submit( new a2dCommand_Select( a2dCommand_Select::Args().what(a2dCommand_Select::DeSelectAll) ) );
}

bool a2dMasterDrawBase::ZoomSave()
{
    return true;
}

void a2dMasterDrawBase::DoStopTool( bool abort )
{
    a2dStTool::DoStopTool( abort );
}

void a2dMasterDrawBase::OnChar(wxKeyEvent& event)
{
    switch( event.GetKeyCode() ) 
    {
        case WXK_DELETE:
        {
            wxASSERT( m_parentobject == GetCanvasView()->GetShowObject() );

            GetCanvasCommandProcessor()->Submit( new a2dCommand_DeleteMask() );
            break;
        }
        default:
            event.Skip();
    }
}


void a2dMasterDrawBase::OnKeyDown(wxKeyEvent& event)
{
    a2dBaseTool* first = m_stcontroller->GetFirstTool();

    switch(event.GetKeyCode())
    {
        case WXK_ESCAPE:
        {
            if ( first && first->AllowPop() )
                first->StopTool( false );
            return;
        }
        break;
        default:;
    }

    if ( !m_active ) 
    {
        event.Skip();
        return;
    }

    //wxLogDebug(wxT("key %d"), event.GetKeyCode());
    
    switch(event.GetKeyCode())
    {
        case WXK_CONTROL:
        {
            if  (  !first || ( first && !first->GetBusy()) )
            {
                if ( !wxDynamicCast(first, a2dDragTool) )
                {
                    //a2dDragTool* drag = new a2dDragTool(m_stcontroller);
                    //m_stcontroller->PushTool(drag);
                    //drag->SetOneShot();
                }
            }
        }
        break;
        case 'Z':
        case 'z':
        {
            if  ( !first || ( first && !first->GetBusy()) )
                PushZoomTool();
            else
                event.Skip();
            
            break;
        }
        case WXK_NUMPAD_ADD:
        {
            if ( event.m_controlDown )
                m_stcontroller->ZoomIn2AtMouse();
            else
                m_stcontroller->Zoomin2();
            break;
        }
        case WXK_NUMPAD_SUBTRACT:
        {
            if ( event.m_controlDown )
                m_stcontroller->ZoomOut2AtMouse();
            else
                m_stcontroller->Zoomout2();
            break;
        }
        case WXK_SPACE:
        {
            m_spaceDown = true;
            m_mode = mode_zoom;
            m_modehit = NULL;
            event.Skip();
            break;
        }
        default:
            event.Skip();
    }
}

void a2dMasterDrawBase::OnKeyUp(wxKeyEvent& event)
{
    if ( !m_active ) 
    {
        event.Skip();
        return;
    }
    event.Skip();
}

void a2dMasterDrawBase::SelectHitObject( a2dCanvasObject *hit )
{
    OpenCommandGroupNamed( _("Select") );

    DeselectAll();

    GetCanvasCommandProcessor()->Submit(
        new a2dCommand_SetFlag( hit, a2dCanvasOFlags::SELECTED, true ));

    CloseCommandGroup();
}

//----------------------------------------------------------------------------
// a2dMasterDrawSelectFirst
//----------------------------------------------------------------------------

IMPLEMENT_CLASS(a2dMasterDrawSelectFirst,a2dMasterDrawBase)

A2D_BEGIN_EVENT_TABLE( a2dMasterDrawSelectFirst,a2dMasterDrawBase )
    A2D_EVT_MOUSE_EVENTS( a2dMasterDrawSelectFirst::OnMouseEvent )
    A2D_EVT_CHAR( a2dMasterDrawSelectFirst::OnChar )
    A2D_EVT_KEY_DOWN( a2dMasterDrawSelectFirst::OnKeyDown )
    A2D_EVT_KEY_UP( a2dMasterDrawSelectFirst::OnKeyUp )
A2D_END_EVENT_TABLE()

a2dMasterDrawSelectFirst::a2dMasterDrawSelectFirst(a2dStToolContr* controller):a2dMasterDrawBase( controller )
{
    controller->SetDefaultBehavior( controller->GetDefaultBehavior() | wxTC_NoDefaultKeys | wxTC_NoDefaultMouseActions );
}

a2dMasterDrawSelectFirst::~a2dMasterDrawSelectFirst()
{
}

void a2dMasterDrawSelectFirst::OnChar(wxKeyEvent& event)
{
    event.Skip();
}

void a2dMasterDrawSelectFirst::OnKeyDown(wxKeyEvent& event)
{
    if ( !m_active ) 
    {
        event.Skip();
        return;
    }

    //wxLogDebug(wxT("key %d"), event.GetKeyCode());
    a2dBaseTool* first = m_stcontroller->GetFirstTool();
    
    switch(event.GetKeyCode())
    {
        case WXK_SPACE:
        {
            m_spaceDown = true;
            m_mode = mode_zoom;
            m_modehit = NULL;
            break;
        }
        case WXK_CONTROL:
        {
            m_mode = mode_copy;
            m_modehit = NULL;
            break;
        }
        case WXK_SHIFT:
        {
            DecideMode( m_modehit, true, false );
            break;
        }
        default:
            event.Skip();
    }
}

void a2dMasterDrawSelectFirst::OnKeyUp(wxKeyEvent& event)
{
    if ( !m_active ) 
    {
        event.Skip();
        return;
    }

    switch(event.GetKeyCode())
    {
        case WXK_SPACE:
        {
            m_spaceDown = false;
            m_mode = mode_zoom;
            m_modehit = NULL;
            break;
        }
        case WXK_SHIFT:
        {
            DecideMode( m_modehit, false, false );
            break;
        }
        default:
            event.Skip();
    }
}


void a2dMasterDrawSelectFirst::DecideMode( a2dCanvasObject* hit, bool shift, bool control )
{
    // show cursor different depending on the object hit, and set mode for tool to push in case of leftdown.
    m_mode = mode_select;
    GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Select  ) );
    m_modehit = 0;
    m_modehitinfo = a2dHit();

    if ( m_spaceDown )
    {
        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Zoom  ) );
        m_mode = mode_zoom;
    }
    else if( hit )
    {
        m_modehit = hit;
        if ( !shift && hit->GetDraggable() && hit->GetSelected() )
        {
            if ( control )
            {
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
                // copy selected mode
                m_mode = mode_copymulti;
            }
            else 
            {
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
                m_mode = mode_dragmulti;
            }
        }
        if ( shift && hit->GetDraggable() )
        {
            GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Select ) );
        }
    }
}

void a2dMasterDrawSelectFirst::OnMouseEvent(wxMouseEvent& event)
{
    if (!m_active)
    {
        event.Skip();
        return;
    }
    m_x = event.GetX();
    m_y = event.GetY();

    double xWorld, yWorld;
    GetCanvasView()->MouseToToolWorld( m_x, m_y, xWorld, yWorld );

    GetCanvasView()->Update( a2dCANVIEW_UPDATE_PENDING );
    a2dIterC ic( GetCanvasView() );
    ic.SetLayer( wxLAYER_ALL );
    ic.SetObjectFilter( new a2dCanvasObjectFilterLayerMask( wxLAYER_ALL, a2dCanvasOFlags::VISIBLE | a2dCanvasOFlags::SELECTABLE ) );  
    a2dHitEvent hitinfo( xWorld, yWorld );
    if ( event.ShiftDown() && event.ControlDown() )
        hitinfo.m_option |= a2dCANOBJHITOPTION_NOTSELECTED;
    //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* hit = GetCanvasView()->GetShowObject()->ChildIsHitWorld( ic, hitinfo, true );

    // if left double click and hit on a selected object, go and edit it
    if ( hit && event.LeftDClick() && !GetBusy())
    {
        int i = 0;
        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  ) );
        m_modehit = hit;
        a2dCanvasObjectList* objects = m_parentobject->GetChildObjectList();
        forEachIn( a2dCanvasObjectList, objects )
        {
            a2dCanvasObject *obj = *iter;
            if ( obj->GetSelected() )
                i++;
        }

        if ( i <= 1 )
        {
            m_mode = mode_edit;
            PushEditTool( m_modehit );
        }
        else
        {
            m_mode = mode_multiedit;
            PushMultiEditTool( m_modehit );
        }
    }
    else if ( event.Moving() && !GetBusy() )
    {
        DecideMode( hit, event.ShiftDown(), event.ControlDown() );
        event.Skip();
    }
    else if( event.LeftDown() && !GetBusy() )
    {
        DecideMode( hit, event.ShiftDown(), event.ControlDown() );
        // decide tool depending on mode

        switch( m_mode )
        {
        case mode_none:
            event.Skip();
            break;
        case mode_zoom:
            PushZoomTool();
            event.Skip();
            break;
        case mode_zoomdrag:
            break;
        case mode_select:
            PushSelectTool();
            event.Skip();
            break;
        case mode_dragmulti:
            PushDragMultiTool(m_modehit);
            event.Skip();
            break;
        case mode_copymulti:
            PushCopyMultiTool(m_modehit);
            event.Skip();
            break;
        case mode_vertex:
            PushEditVertexTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        case mode_segment:
            PushEditSegmentTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        default:
            event.Skip();
        }
    }
    else if( event.RightDown() && !GetBusy() )
    {
        PushZoomTool();
        event.Skip();
    }
    else
    {
        event.Skip();
    }
}

//----------------------------------------------------------------------------
// a2dMasterDrawZoomFirst
//----------------------------------------------------------------------------

IMPLEMENT_CLASS(a2dMasterDrawZoomFirst,a2dMasterDrawBase)

A2D_BEGIN_EVENT_TABLE( a2dMasterDrawZoomFirst, a2dMasterDrawBase )
    A2D_EVT_MOUSE_EVENTS( a2dMasterDrawZoomFirst::OnMouseEvent )
    A2D_EVT_CHAR( a2dMasterDrawZoomFirst::OnChar )
    A2D_EVT_KEY_DOWN( a2dMasterDrawZoomFirst::OnKeyDown )
    A2D_EVT_KEY_UP( a2dMasterDrawZoomFirst::OnKeyUp )
A2D_END_EVENT_TABLE()

a2dMasterDrawZoomFirst::a2dMasterDrawZoomFirst(a2dStToolContr* controller):a2dMasterDrawBase(controller)
{
    controller->SetDefaultBehavior( controller->GetDefaultBehavior() | wxTC_NoDefaultKeys | wxTC_NoDefaultMouseActions );
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_Zoom  );
}

a2dMasterDrawZoomFirst::~a2dMasterDrawZoomFirst()
{
}

void a2dMasterDrawZoomFirst::Render()
{
}

void a2dMasterDrawZoomFirst::OnChar(wxKeyEvent& event)
{
    //wxLogDebug(wxT("key %d"), event.GetKeyCode());
    a2dBaseTool* first = m_stcontroller->GetFirstTool();
    
    switch(event.GetKeyCode())
    {
        case WXK_SPACE:
        {
            m_stcontroller->Zoomout();
            break;
        }
        default:
            event.Skip();
    }
}

void a2dMasterDrawZoomFirst::OnKeyDown(wxKeyEvent& event)
{
    if ( !m_active ) 
    {
        event.Skip();
        return;
    }
    event.Skip();
}

void a2dMasterDrawZoomFirst::OnKeyUp(wxKeyEvent& event)
{
    if ( !m_active ) 
    {
        event.Skip();
        return;
    }
    event.Skip();
}

void a2dMasterDrawZoomFirst::OnMouseEvent(wxMouseEvent& event)
{
    if (!m_active)
    {
        event.Skip();
        return;
    }
    m_x = event.GetX();
    m_y = event.GetY();

    MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

    //GetCanvasView()->Update( a2dCANVIEW_UPDATE_PENDING );
    a2dIterC ic( GetCanvasView() );
    ic.SetLayer( wxLAYER_ALL );
    ic.SetObjectFilter( new a2dCanvasObjectFilterLayerMask( wxLAYER_ALL, a2dCanvasOFlags::VISIBLE | a2dCanvasOFlags::SELECTABLE ) );  
    a2dHitEvent hitinfo( m_xwprev, m_ywprev );
    hitinfo.m_option = a2dCANOBJHITOPTION_LAYERS;
    //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;

    if ( event.LeftDClick() && !m_toolBusy && !GetBusy())
    {
        a2dCanvasObject* hit = GetCanvasView()->GetShowObject()->ChildIsHitWorld( ic, hitinfo, true );
        if ( hit )
        {
            hit->SetSelected( m_modehitLastSelectState );
            int i = 0;
            GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Select ) );
            m_modehit = hit;
            a2dCanvasObjectList* objects = m_parentobject->GetChildObjectList();
            forEachIn( a2dCanvasObjectList, objects )
            {
                a2dCanvasObject *obj = *iter;
                if ( obj->GetSelected() )
                    i++;
            }

            if ( i > 1 && m_allowMultiEdit )
            {
                m_mode = mode_multiedit;
                PushMultiEditTool( m_modehit );
            }
            else
            {
                m_mode = mode_edit;
                PushEditTool( m_modehit );
            }
        }
    }
    else if ( event.Dragging() && m_toolBusy && !m_dragStarted && !event.AltDown())
    {
        if (abs( m_x - m_dragstartx ) > 3 && abs( m_y - m_dragstarty ) > 3)
        {
            if ( event.ControlDown() )
            {
                a2dCanvasObject* hit = GetCanvasView()->GetShowObject()->ChildIsHitWorld( ic, hitinfo, true );
                m_mode = mode_cntrlselect;
                m_modehit = hit;
            }
            else if ( event.ShiftDown() )
            {
                a2dCanvasObject* hit = GetCanvasView()->GetShowObject()->ChildIsHitWorld( ic, hitinfo, true );
                m_mode = mode_select;
                m_modehit = hit;
            }
            else
            {
                m_mode = mode_zoom;
                m_modehit = NULL;
            }

            switch( m_mode )
            {
            case mode_zoom:
            case mode_select:
            case mode_cntrlselect:
                {
                    m_dragStarted = true;
                    m_parentobject = GetCanvasView()->GetShowObject();
                    MouseToToolWorld(  m_dragstartx, m_dragstarty, m_xwprev, m_ywprev );

                    a2dRect* rec = new a2dRect(  m_xwprev, m_ywprev , 0, 0, 0);
                    m_canvasobject = rec;
                    if ( m_mode == mode_select || m_mode == mode_cntrlselect )
                    {
                        rec->SetFill( m_selectFill );
                        rec->SetStroke( m_selectStroke );
                    }
                    else
                    {
                        rec->SetFill( m_fill );
                        rec->SetStroke( m_stroke );
                    }
                    rec->Update( a2dCanvasObject::updatemask_force );
                    GetCanvasDocument()->SetIgnorePendingObjects( true );
                    if ( GetCanvasView()->GetTrippleBuf() )
                        GetCanvasView()->AddOverlayObject( rec );
                    else
                        GetCanvasView()->AddOverlayObject( rec );
                        //AddDecorationObject( rec );
                    GetCanvasDocument()->SetIgnorePendingObjects( false );
                    GetCanvasView()->AddOverlayAreas( true );
                    m_pending = true;
                    event.Skip();
                    EnterBusyMode();
                }
            default:
                break;
            }
            switch( m_mode )
            {
            case mode_zoom:
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Zoom ) );
                break;
            case mode_select:
            case mode_cntrlselect:
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Select ) );
                break;
            default:
                break;
            }
        }
    }
    else if ( event.Dragging() && m_toolBusy && m_dragStarted )
    {
        switch( m_mode )
        {
        case mode_zoom:
        case mode_select:
        case mode_cntrlselect:
        {
            a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );

            MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

            GetCanvasDocument()->SetIgnorePendingObjects( true );
            rec->SetWidth( m_xwprev - rec->GetPosX() );
            rec->SetHeight( m_ywprev - rec->GetPosY() );
            rec->SetPending( true );
            GetCanvasDocument()->SetIgnorePendingObjects( false );
            GetCanvasView()->AddOverlayAreas( true );
            //m_pending = true;
            break;
        }
        default:
            break;
        }
    }
    else if ( event.Moving() && !GetBusy() && event.AltDown() )
    {
        // show cursor different depending on the object hit, and set mode for tool to push in case of leftdown.
        m_mode = mode_none;
        m_modehit = 0;
        m_modehitinfo = a2dHit();
        a2dCanvasObject* hit = GetCanvasView()->GetShowObject()->ChildIsHitWorld( ic, hitinfo, true );

        if( hit && hit->GetDraggable() && hit->GetSelected() )
        {
            m_modehit = hit;
            if( event.ControlDown() )
            {
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Copy ) );
                m_mode = mode_copymulti;
            }
            else
            {  
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Drag ) );
                m_mode = mode_dragmulti;
            }
        }
        event.Skip();
    }
    else if ( event.Moving() && !GetBusy() )
    {
        m_mode = mode_none;
        a2dCanvasObject* hit = GetCanvasView()->GetShowObject()->ChildIsHitWorld( ic, hitinfo, true );
        if ( hit )
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_HAND ) );
        else
                GetCanvasView()->SetCursor( m_toolcursor );
    }
    else if( event.LeftDown() && !GetBusy() )
    {
        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Select ) );
        m_modehit = 0;
        a2dCanvasObject* hit = GetCanvasView()->GetShowObject()->ChildIsHitWorld( ic, hitinfo, true );
        if( hit )
            m_modehit = hit;

        m_dragStarted = false;
        m_xprev = m_x;
        m_yprev = m_y;
        m_dragstartx = m_x;
        m_dragstarty = m_y;
        m_toolBusy = true;

        switch( m_mode )
        {
        case mode_dragmulti:
            PushDragMultiTool(m_modehit);
            event.Skip();
            break;
        case mode_copymulti:
            PushCopyMultiTool(m_modehit);
            event.Skip();
            break;
        case mode_vertex:
            PushEditVertexTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        case mode_segment:
            PushEditSegmentTool( m_modehit, m_modehitinfo.m_index );
            event.Skip();
            break;
        default:
            m_mode = mode_none;
            event.Skip();
        }
    }
    else if( event.LeftUp() && GetBusy() && m_dragStarted )
    {
        m_toolBusy = false;
        m_dragStarted = false;
        switch( m_mode )
        {
        case mode_zoom:
            {
                a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );

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

                rec->Update( a2dCanvasObject::updatemask_force );
                double x1 = rec->GetBbox().GetMinX();

                double y1 = rec->GetBbox().GetMinY();

                //Get the current window size to put on zoomstack
                a2dBoundingBox* bbox = new a2dBoundingBox(GetDrawer2D()->GetVisibleMinX(),
                                                       GetDrawer2D()->GetVisibleMinY(),
                                                       GetDrawer2D()->GetVisibleMaxX(),
                                                       GetDrawer2D()->GetVisibleMaxY()
                                                      );

                m_stcontroller->GetZoomList().Insert(bbox);
                GetDrawer2D()->SetMappingWidthHeight(x1,y1, fabs(rec->GetWidth()),fabs(rec->GetHeight()));

                FinishBusyMode();
                GetCanvasView()->RemoveOverlayObject( rec );

                event.Skip();
                break;
            }
        case mode_select:
            {
                SetIgnorePendingObjects( false );

                a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );
                rec->Update( a2dCanvasObject::updatemask_force );
                GetCanvasView()->AddPendingUpdateArea(rec->GetBbox());

                GetCanvasCommandProcessor()->Submit(
                    new a2dCommand_Select( a2dCommand_Select::Args()
                    .what(a2dCommand_Select::SelectRect) 
                    .x1( rec->GetBbox().GetMinX() )
                    .y1( rec->GetBbox().GetMinY() )
                    .x2( rec->GetBbox().GetMaxX() )
                    .y2( rec->GetBbox().GetMaxY() )
                    )
                );
                FinishBusyMode();
                GetCanvasView()->RemoveOverlayObject( rec );
                event.Skip();
                break;
            }
        case mode_cntrlselect:
            {
                DeselectAll();
                SetIgnorePendingObjects( false );

                a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );
                rec->Update( a2dCanvasObject::updatemask_force );
                GetCanvasView()->AddPendingUpdateArea(rec->GetBbox());

                GetCanvasCommandProcessor()->Submit(
                    new a2dCommand_Select( a2dCommand_Select::Args()
                    .what(a2dCommand_Select::SelectRect) 
                    .x1( rec->GetBbox().GetMinX() )
                    .y1( rec->GetBbox().GetMinY() )
                    .x2( rec->GetBbox().GetMaxX() )
                    .y2( rec->GetBbox().GetMaxY() )
                    )
                );
                FinishBusyMode();
                GetCanvasView()->RemoveOverlayObject( rec );
                event.Skip();
                break;
            }
        default:
            break;
        }
        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Zoom ) );
    }
    else if( event.LeftUp() && m_toolBusy )
    {
        m_toolBusy = false;
        //reserve for double clcik if it happens
        m_modehitLastSelectState = false;
        if ( m_modehit )
           m_modehitLastSelectState = m_modehit->GetSelected();


        if ( event.ControlDown() )
        {
            DeselectAll();
            if ( m_modehit && m_modehit->GetSelectable() )
                m_modehit->SetSelected( true );
        }
        else if ( event.ShiftDown() )
        {
            if ( m_modehit && m_modehit->GetSelectable() )
                m_modehit->SetSelected( true );
        }
        else
        {
            if ( !m_modehit )
                DeselectAll();
            if ( m_modehit && m_modehit->GetSelectable() )
                m_modehit->SetSelected( ! m_modehit->GetSelected() );
        }
        GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_Zoom ) );
    }
    else if( event.RightDown() && !GetBusy() )
    {
        PushZoomTool();
        event.Skip();
    }
    else
    {
        event.Skip();
    }
}

//----------------------------------------------------------------------------
// a2dToolProperty
//----------------------------------------------------------------------------

IMPLEMENT_CLASS( a2dToolProperty, a2dDynamicEventProperty );

// Property Id template instantiation
#ifdef _MSC_VER
#pragma warning(disable: 4660)
#endif

template class a2dPropertyIdProp<class a2dToolProperty>;

#ifdef _MSC_VER
#pragma warning(default: 4660)
#endif

const long SUBMASTER_PUSHTOOL = wxNewId();
const long SUBMASTER_MENUTOOL_DRAG = wxNewId();
const long SUBMASTER_MENUTOOL_REC = wxNewId();
const long SUBMASTER_MENUTOOL_EDIT = wxNewId();

const a2dPropertyIdDynamicEventProperty a2dSubDrawMasterTool::PROPID_toolMenu( wxT("PROPID_toolMenu"), a2dPropertyId::flag_multiple );

a2dToolProperty::a2dToolProperty(): a2dDynamicEventProperty()
{
    m_tool = NULL;
    m_key = ' ';
    m_menuItem = NULL;
}

a2dToolProperty::a2dToolProperty( const a2dPropertyIdDynamicEventProperty* id, a2dBaseTool* tool, wxMenuItem* menuItem, wxChar key )
        :a2dDynamicEventProperty( id, wxEVT_COMMAND_MENU_SELECTED, menuItem->GetId(),-1, 
         (a2dObjectEventFunction) (a2dCommandEventFunction) (&a2dSubDrawMasterTool::PushToolFromMouseMenu ) )
{
    m_tool = tool;
    m_menuItem = menuItem;
    m_key  = key;
}

a2dToolProperty::a2dToolProperty(const a2dToolProperty &other )
    :a2dDynamicEventProperty( other )
{
    m_tool = other.m_tool;
    m_menuItem = other.m_menuItem;
    m_key  = other.m_key;
}

a2dToolProperty::~a2dToolProperty()
{
}

a2dNamedProperty* a2dToolProperty::Clone( a2dObject::CloneOptions WXUNUSED(options) ) const
{
    return new a2dToolProperty( *this );
};

void a2dToolProperty::Assign( const a2dNamedProperty &other )
{
    a2dToolProperty *propcast = wxStaticCast( &other, a2dToolProperty);
    m_tool = propcast->m_tool;
    m_menuItem = propcast->m_menuItem;
    m_key  = propcast->m_key;
}

#if wxART2D_USE_CVGIO

void a2dToolProperty::DoSave( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerOut &WXUNUSED(out), a2dXmlSer_flag WXUNUSED(xmlparts) , a2dObjectList* WXUNUSED(towrite) )
{
    // Tools are not serialized, so tool properties shouldn't be serialized either
    wxASSERT(0);
}

#endif //wxART2D_USE_CVGIO

#if wxART2D_USE_CVGIO

void a2dToolProperty::DoLoad( wxObject* WXUNUSED(parent), a2dIOHandlerXmlSerIn& WXUNUSED(parser), a2dXmlSer_flag WXUNUSED(xmlparts) )
{
    // Tools are not serialized, so tool properties shouldn't be serialized either
    wxASSERT(0);
}

#endif //wxART2D_USE_CVGIO

//----------------------------------------------------------------------------
// a2dSubDrawMasterTool
//----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(a2dSubDrawMasterTool,a2dStTool)

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

a2dSubDrawMasterTool::a2dSubDrawMasterTool(a2dStToolContr* controller):a2dStTool(controller)
{
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  );
    m_mode = 0;
    m_canvasobject=0;

    m_mousemenu = new wxMenu( _("Tool menu"),(long)0);

    a2dDragTool *tool = new a2dDragTool( controller );
    tool->SetCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  ) );
    tool->SetBusyCursorType( a2dCanvasGlobals->GetCursor( a2dCURSOR_HAND ) );
    tool->SetDeleteOnOutsideDrop( false );
    AppendTool( tool, new wxMenuItem( m_mousemenu, SUBMASTER_MENUTOOL_DRAG, _("drag"), _("pushes drag tool") ), 'd' );

    a2dRecursiveEditTool* edit = new a2dRecursiveEditTool( controller );
    edit->SetCorridor( m_corridor );
    AppendTool( edit, new wxMenuItem( m_mousemenu, SUBMASTER_MENUTOOL_EDIT, _("edit"), _("pushes edit tool") ), 'e' );

    a2dDrawRectangleTool* drawrec = new a2dDrawRectangleTool( controller );
    drawrec->SetEditAtEnd( true );
    AppendTool( drawrec, new wxMenuItem( m_mousemenu, SUBMASTER_MENUTOOL_REC, _("draw rectangle"), _("pushes draw rectangle tool") ), 'r' );

    m_curTool = drawrec;
}

a2dSubDrawMasterTool::~a2dSubDrawMasterTool()
{
}

void a2dSubDrawMasterTool::OnPostPushTool()
{
    m_curTool->SetCorridor( m_corridor );
    m_controller->PushTool( m_curTool );
}

void a2dSubDrawMasterTool::AppendTool( a2dBaseTool* tool, wxMenuItem* menuItem, wxChar key )
{
    //SetProperty( new a2dToolProperty( PROPID_toolMenu, tool, menuItem, key ) );    
    m_mousemenu->Append( menuItem );
}

bool a2dSubDrawMasterTool::ZoomSave()
{
    return true;
}

void a2dSubDrawMasterTool::DoStopTool( bool abort )
{
    a2dStTool::DoStopTool( abort );
}

void a2dSubDrawMasterTool::OnChar(wxKeyEvent& WXUNUSED(event) )
{
    //switch( event.GetKeyCode() )
    //{
    //}
}

void a2dSubDrawMasterTool::OnMouseEvent(wxMouseEvent& event)
{
    if (!m_active)
    {
        event.Skip();
        return;
    }
    m_x = event.GetX();
    m_y = event.GetY();

    //to world coordinates to do hit test in world coordinates
    double xw;
    double yw;

    xw = GetDrawer2D()->DeviceToWorldX(m_x);
    yw = GetDrawer2D()->DeviceToWorldY(m_y);

    a2dHitEvent hitinfo( xw, yw, false, a2dCANOBJHITOPTION_LAYERS, true );
    a2dCanvasObject* hit = GetCanvasView()->IsHitWorld( hitinfo, wxLAYER_ALL );

    if ( event.Moving() && !GetBusy() )
    {
        if( hit )
        {
            a2dHit how2;
        }
    }
    else if( event.LeftDown() && !GetBusy() )
    {
    }
    else
    {
        event.Skip();
    }
}

void a2dSubDrawMasterTool::PushToolFromMouseMenu( wxCommandEvent& event )
{
    a2dToolProperty *property = wxStaticCast( event.m_callbackUserData, a2dToolProperty );
    if ( property->GetMenuItem()->GetId() == event.GetId() )
    {
        a2dSmrtPtr< a2dBaseTool > tool; 
        if ( m_controller->GetFirstTool() != this )
            m_controller->PopTool( tool );

        property->GetToolObject()->SetCorridor( m_corridor );
        m_controller->PushTool( property->GetToolObject() );
    }
}

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