sttool2.cpp

/*! \file editor/src/sttool2.cpp
    \author Klaas Holwerda

    Copyright: 2001-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: sttool2.cpp,v 1.36 2009/08/20 18:59:15 titato Exp $
*/

#include "a2dprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

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

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

IMPLEMENT_CLASS( a2dZoomFast, a2dStTool )
IMPLEMENT_CLASS( a2dFastSelect, a2dStTool )
IMPLEMENT_CLASS( a2dFastSelect2, a2dStTool )
IMPLEMENT_CLASS( a2dFastDragMultiTool, a2dStTool )
IMPLEMENT_CLASS( a2dFastCopyMultiTool, a2dFastDragMultiTool )
IMPLEMENT_CLASS( a2dStDrawToolFast, a2dStDrawTool )

const a2dCommandId a2dZoomFast::COMID_PushTool_ZoomFast( wxT( "PushTool_ZoomFast" ) );
const a2dCommandId a2dFastSelect::COMID_PushTool_FastSelect( wxT( "PushTool_FastSelect" ) );
const a2dCommandId a2dFastSelect2::COMID_PushTool_FastSelect2( wxT( "PushTool_FastDeSelect" ) );
const a2dCommandId a2dFastDragMultiTool::COMID_PushTool_FastDragMulti( wxT( "PushTool_FastDragMulti" ) );
const a2dCommandId a2dFastCopyMultiTool::COMID_PushTool_FastCopyMulti( wxT( "PushTool_FastCopyMulti" ) );
const a2dCommandId a2dDrawRectangleToolFast::COMID_PushTool_DrawRectangleFast( wxT( "PushTool_DrawRectangleFast" ) );
const a2dCommandId a2dDrawCircleToolFast::COMID_PushTool_DrawCircleFast( wxT( "PushTool_DrawCircleFast" ) );
const a2dCommandId a2dDrawPolygonLToolFast::COMID_PushTool_DrawPolygonLFast( wxT( "PushTool_DrawPolygonLFast" ) );
const a2dCommandId a2dDrawPolygonLToolFast::COMID_PushTool_DrawPolygonLFast_Splined( wxT( "PushTool_DrawPolygonLFast_Splined" ) );
const a2dCommandId a2dDrawPolylineLToolFast::COMID_PushTool_DrawPolylineLFast( wxT( "PushTool_DrawPolylineLFast" ) );
const a2dCommandId a2dDrawPolylineLToolFast::COMID_PushTool_DrawPolylineLFast_Splined( wxT( "PushTool_DrawPolylineLFast_Splined" ) );

/********************************************************************************
a2dStDrawToolFast
********************************************************************************/


BEGIN_EVENT_TABLE( a2dStDrawToolFast, a2dStDrawTool )
END_EVENT_TABLE()

a2dStDrawToolFast::a2dStDrawToolFast( a2dStToolContr* controller ): a2dStDrawTool( controller )
{
    // the base tool sets layer style using a2dBLACK_STROKE->Clone()->SetNoStroke() etc.
    // This for debug.
    m_stroke = a2dStroke( *wxBLACK, 0 );
    m_fill = a2dFill( *wxRED );
    m_AllowModifyTemplate = true;
}

a2dStDrawToolFast::~a2dStDrawToolFast()
{
}

bool a2dStDrawToolFast::CreateToolObjects()
{
    a2dStTool::CreateToolObjects();

    // Clone the original drag object
    m_canvasobject = m_original->TClone( clone_members | clone_childs | clone_seteditcopy | clone_setoriginal );
    GetDrawingPart()->AddOverlayObject( m_canvasobject );
    GetDrawingPart()->SetOverlayDrawStyle( RenderLAYERED );
    if ( GetDrawingPart()->GetDrawer2D()->HasAlpha() || GetDrawingPart()->GetTrippleBuf() )
    {
        m_canvasobject->SetFill( a2dFill( wxColour( 66, 159, 235, 50 ) ) );
        m_canvasobject->SetStroke( a2dStroke( wxColour( 66, 159, 235, 165 ), 2, a2dSTROKE_LONG_DASH ) );
    }
    else
    {
        m_canvasobject->SetFill( *a2dTRANSPARENT_FILL );
        m_canvasobject->SetStroke( m_stroke );
        //m_canvasobject->SetStroke( a2dStroke(*wxBLACK, 1, a2dSTROKE_LONG_DASH) );
    }

    m_canvasobject->SetSelected( false );

    a2dCanvasObject::SetIgnoreAllSetpending( true );
    AddCurrent( m_original );
    m_original->SetSnapTo( true );
    m_original->SetVisible( m_renderOriginal );
    m_original->SetVisible( false );
    a2dCanvasObject::SetIgnoreAllSetpending( false );
    return true;
}

void a2dStDrawToolFast::CleanupToolObjects()
{
    GetDrawingPart()->RemoveOverlayObject( m_canvasobject );
    GetDrawingPart()->SetOverlayDrawStyle( RenderWIREFRAME_HighLight );
    m_original->SetVisible( true );
}

void a2dStDrawToolFast::Render()
{
    if ( m_canvasobject && GetBusy() )
    {
    }
}

/********************************************************************************
a2dZoomFast
********************************************************************************/

BEGIN_EVENT_TABLE( a2dZoomFast, a2dStTool )
    EVT_CHAR( a2dZoomFast::OnChar )
    EVT_MOUSE_EVENTS( a2dZoomFast::OnMouseEvent )
END_EVENT_TABLE()

a2dZoomFast::a2dZoomFast( a2dStToolContr* controller ): a2dStTool( controller )
{
    m_eventHandler = new a2dStToolFixedToolStyleEvtHandler( controller );

    m_anotate = false;
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_MAGNIFIER );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );

    if ( GetDrawingPart()->GetDrawer2D()->HasAlpha() || GetDrawingPart()->GetTrippleBuf() )
    {
        SetFill( a2dFill( wxColour( 66, 159, 235, 50 ) ) );
        SetStroke( a2dStroke( wxColour( 66, 159, 235, 165 ), 2, a2dSTROKE_LONG_DASH ) );
    }
    else
    {
        SetFill( *a2dTRANSPARENT_FILL );
        SetStroke( a2dStroke( *wxBLACK, 1, a2dSTROKE_LONG_DASH ) );
    }
}

a2dZoomFast::a2dZoomFast( const a2dZoomFast& other, CloneOptions options, a2dRefMap* refs )
    : a2dStTool( other, options, refs )
{
    m_eventHandler = other.m_eventHandler;

    m_anotate = other.m_anotate;
    m_toolcursor = other.m_toolcursor;
    m_toolBusyCursor = other.m_toolBusyCursor;

    m_fill = other.m_fill;
    m_stroke = other.m_stroke;
}

a2dObject* a2dZoomFast::DoClone( CloneOptions options, a2dRefMap* refs ) const
{
    return new a2dZoomFast( *this, options, refs );
}

a2dZoomFast::~a2dZoomFast()
{
}

void a2dZoomFast::Render()
{
}

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

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

    wxCoord w, h, descent, external;
    GetTextExtent( m_anotation, &w, &h, &descent, &external );

    m_xanotation = m_x + h;
    m_yanotation = m_y + h;

    a2dStTool::AddAnotationToPendingUpdateArea();
}

void a2dZoomFast::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 a2dZoomFast::OnMouseEvent( wxMouseEvent& event )
{
    if ( !m_active )
    {
        event.Skip();
        return;
    }

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

    m_x = event.GetX();
    m_y = event.GetY();

    if ( event.LeftDClick() && !GetBusy() )
    {
        m_stcontroller->Zoomout();
    }
    else if ( event.LeftDown() && !GetBusy() )
    {
        SetIgnorePendingObjects( true );
        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );
        m_parentobject = GetDrawingPart()->GetShowObject();
        a2dRect* rec = new a2dRect( m_xwprev, m_ywprev, 0, 0, 0 );
        m_canvasobject = rec;
        if ( GetDrawingPart()->GetTrippleBuf() )
            GetDrawingPart()->AddOverlayObject( rec );
        else
            AddDecorationObject( rec );
        rec->SetRoot( GetDrawingPart()->GetDrawing() );
        rec->SetFill( m_fill );
        rec->SetStroke( m_stroke );
        rec->Update( a2dCanvasObject::updatemask_force );
        m_pending = true;

        //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();
        EnterBusyMode();
    }
    else if ( event.LeftUp() /*event.LeftDown()*/ && GetBusy() )
    {
        SetIgnorePendingObjects( false );
        a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );

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

        //to be able to intercept doubleclick
        //ignore the LeftDown and LeftUp if mouse position is the same
        if ( fabs( w ) < 3 && fabs( h ) < 3 )
        {
            GetDisplayWindow()->Refresh();
            FinishBusyMode();
            event.Skip();
        }
        else
        {
            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() ) );

            a2dGeneralGlobals->RecordF( this, _T( "zoom %f %f %f %f" ), x1, y1, x1 + rec->GetWidth(), y1 + rec->GetHeight() );

            //generate an OnPaint event in order to redraw
            //other tools that are busy at this moment
            //GetDrawingPart()->Refresh();

            FinishBusyMode();
            if ( GetDrawingPart()->GetTrippleBuf() )
                GetDrawingPart()->RemoveOverlayObject( rec );
            event.Skip();
        }
    }
    else  if ( ( event.Dragging() && GetBusy() )  /*|| (event.Moving() && GetBusy())*/ )
    {
        a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );

        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

        rec->SetWidth( m_xwprev - rec->GetPosX() );
        rec->SetHeight( m_ywprev - rec->GetPosY() );
        rec->SetPending( true );
        m_pending = true;
    }
    else
        event.Skip();
}

BEGIN_EVENT_TABLE( a2dFastSelect, a2dStTool )
    EVT_CHAR( a2dFastSelect::OnChar )
    EVT_MOUSE_EVENTS( a2dFastSelect::OnMouseEvent )
END_EVENT_TABLE()

a2dFastSelect::a2dFastSelect( a2dStToolContr* controller ): a2dStTool( controller )
{
    m_eventHandler = new a2dStToolFixedToolStyleEvtHandler( controller );

    m_shift_is_add = false;

    m_anotate = false;
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );

    if ( GetDrawingPart()->GetDrawer2D()->HasAlpha() || GetDrawingPart()->GetTrippleBufHasAlpha() )
    {
        SetFill( a2dFill( wxColour( 233, 15, 23, 20 ) ) );
        SetStroke( a2dStroke( wxColour( 255, 59, 25, 65 ), 1, a2dSTROKE_LONG_DASH ) );
    }
    else
    {
        SetFill( *a2dTRANSPARENT_FILL );
        SetStroke( a2dStroke( *wxRED, 1, a2dSTROKE_LONG_DASH ) );
    }
}

a2dFastSelect::~a2dFastSelect()
{
}

void a2dFastSelect::Render()
{
}

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

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

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

    wxCoord w, h, descent, external;
    GetTextExtent( m_anotation, &w, &h, &descent, &external );

    m_xanotation = m_x + h;
    m_yanotation = m_y + h;

    a2dStTool::AddAnotationToPendingUpdateArea();
}

void a2dFastSelect::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 a2dFastSelect::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 );

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
    {
        restrict->SetShiftKeyDown( event.ShiftDown() );
        restrict->RestrictPoint( m_xwprev, m_ywprev );
    }

    if ( event.Moving() )
    {
        if ( !GetBusy() )
        {
            double xWorld, yWorld;
            GetDrawingPart()->MouseToToolWorld( m_x, m_y, xWorld, yWorld );

            static a2dCanvasObject* oldhitobject = NULL;
            a2dCanvasObject* hitobject = NULL;
            hitobject = GetDrawingPart()->IsHitWorld( xWorld, yWorld, wxLAYER_ALL, a2dCANOBJHITOPTION_LAYERS, true );
            if ( hitobject )
            {
                GetDrawingPart()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_HAND ) );

                if ( oldhitobject )
                {
                    if ( hitobject != oldhitobject )
                    {
                        GetDrawing()->SetIgnorePendingObjects( true );
                        GetDrawingPart()->RemoveOverlayObject( oldhitobject );
                        GetDrawingPart()->SetOverlayDrawStyle( RenderWIREFRAME_HighLight );
                        GetDrawingPart()->AddOverlayObject( hitobject );
                        hitobject->SetPending( true );
                        GetDrawing()->SetIgnorePendingObjects( false );
                        oldhitobject = hitobject;
                    }
                }
                else
                {
                    GetDrawing()->SetIgnorePendingObjects( true );
                    GetDrawingPart()->SetOverlayDrawStyle( RenderWIREFRAME_HighLight );
                    GetDrawingPart()->AddOverlayObject( hitobject );
                    hitobject->SetPending( true );
                    GetDrawing()->SetIgnorePendingObjects( false );
                    oldhitobject = hitobject;
                }
            }
            else if ( oldhitobject )
            {
                GetDrawingPart()->SetCursor( m_toolcursor );
                GetDrawing()->SetIgnorePendingObjects( true );
                GetDrawingPart()->RemoveOverlayObject( oldhitobject );
                GetDrawing()->SetIgnorePendingObjects( false );
                oldhitobject = NULL;
            }
            else
                GetDrawingPart()->SetCursor( m_toolcursor );
        }
        else
            GetDrawingPart()->SetCursor( m_toolBusyCursor );
    }
    else
    {
        GetDrawingPart()->SetOverlayDrawStyle( RenderLAYERED );
        if ( GetBusy() )
            GetDrawingPart()->SetCursor( m_toolBusyCursor );
        else
            GetDrawingPart()->SetCursor( m_toolcursor );
    }

    if ( event.LeftDClick() && !GetBusy() )
    {
        m_stcontroller->Zoomout();
    }
    else if ( event.LeftDown() && !GetBusy() )
    {
        SetIgnorePendingObjects( true );
        m_parentobject = GetDrawingPart()->GetShowObject();
        a2dRect* rec = new a2dRect( m_xwprev, m_ywprev, 0, 0, 0 );
        m_canvasobject = rec;
        rec->SetFill( m_fill );
        rec->SetStroke( m_stroke );
        rec->Update( a2dCanvasObject::updatemask_force );
        if ( GetDrawingPart()->GetTrippleBuf() )
            rec->SetRoot( GetDrawingPart()->GetDrawing() );
        else
            GetDrawingPart()->AddOverlayObject( rec );
        GetDrawingPart()->SetOverlayDrawStyle( RenderLAYERED );
        m_pending = true;

        //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();
        EnterBusyMode();
    }
    else if ( event.LeftUp() /*event.LeftDown()*/ && GetBusy() )
    {
        SetIgnorePendingObjects( false );

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

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

        if ( fabs( w ) < 3 && fabs( h ) < 3 )
        {
            // The user did click somewhere ( no drag )

            a2dCanvasObject* hitobject = GetDrawingPart()->IsHitWorld( m_xwprev, m_ywprev, wxLAYER_ALL, a2dCANOBJHITOPTION_LAYERS, true );

            if( m_shift_is_add )
            {
                if ( !event.m_shiftDown )
                {
                    //if NOT shift down, deselect all and  set selection to hit object.
                    DeselectAll();

                    if ( hitobject ) //set selection to hit object.
                    {
                        GetCanvasCommandProcessor()->Submit(
                            new a2dCommand_SetFlag( hitobject, a2dCanvasOFlags::SELECTED, !hitobject->GetSelected() )
                        );
                    }
                }
                else
                {
                    //if shift down, add to selection when hit on object, else nothing
                    if ( hitobject )
                    {
                        GetCanvasCommandProcessor()->Submit(
                            new a2dCommand_SetFlag( hitobject, a2dCanvasOFlags::SELECTED, true )
                        );
                    }
                }

                if ( !hitobject )
                {
                    if( !m_oneshot )
                        event.Skip();
                    FinishBusyMode();
                    return;
                }
            }
            else
            {
                if ( !hitobject )
                {
                    if( !m_oneshot )
                        event.Skip();
                    FinishBusyMode();
                    return;
                }

                if ( event.m_shiftDown || hitobject->GetSelected() )
                {
                    GetCanvasCommandProcessor()->Submit(
                        new a2dCommand_SetFlag( hitobject, a2dCanvasOFlags::SELECTED, false )
                    );
                }
                else
                {
                    GetCanvasCommandProcessor()->Submit(
                        new a2dCommand_SetFlag( hitobject, a2dCanvasOFlags::SELECTED, true )
                    );
                }
            }
        }
        else
        {
            if( m_shift_is_add )
            {
                //if shift is not down, start a new selection, by first deslecting all,
                //and dragging a new selection rectangle

                if ( !event.m_shiftDown )
                {
                    DeselectAll();
                    GetCanvasCommandProcessor()->Submit(
                        new a2dCommand_Select( m_parentobject, a2dCommand_Select::Args()
                                               .what( a2dCommand_Select::SelectRect )
                                               .x1( rec->GetBbox().GetMinX() )
                                               .y1( rec->GetBbox().GetMinY() )
                                               .x2( rec->GetBbox().GetMaxX() )
                                               .y2( rec->GetBbox().GetMaxY() )
                                             )
                    );
                }
                else
                {
                    GetCanvasCommandProcessor()->Submit(
                        new a2dCommand_Select( m_parentobject, a2dCommand_Select::Args()
                                               .what( a2dCommand_Select::SelectRect )
                                               .x1( rec->GetBbox().GetMinX() )
                                               .y1( rec->GetBbox().GetMinY() )
                                               .x2( rec->GetBbox().GetMaxX() )
                                               .y2( rec->GetBbox().GetMaxY() )
                                             )
                    );
                }
            }
            else
            {
                if ( event.m_shiftDown )
                {
                    GetCanvasCommandProcessor()->Submit(
                        new a2dCommand_Select( m_parentobject, a2dCommand_Select::Args()
                                               .what( a2dCommand_Select::DeSelectRect )
                                               .x1( rec->GetBbox().GetMinX() )
                                               .y1( rec->GetBbox().GetMinY() )
                                               .x2( rec->GetBbox().GetMaxX() )
                                               .y2( rec->GetBbox().GetMaxY() )
                                             )
                    );
                }
                else
                {
                    GetCanvasCommandProcessor()->Submit(
                        new a2dCommand_Select( m_parentobject, a2dCommand_Select::Args()
                                               .what( a2dCommand_Select::SelectRect )
                                               .x1( rec->GetBbox().GetMinX() )
                                               .y1( rec->GetBbox().GetMinY() )
                                               .x2( rec->GetBbox().GetMaxX() )
                                               .y2( rec->GetBbox().GetMaxY() )
                                             )
                    );
                }
            }
        }

        m_pending = true;
        FinishBusyMode();
        //if ( GetDrawingPart()->GetTrippleBuf() )
        GetDrawingPart()->RemoveOverlayObject( rec );
        GetDrawingPart()->Update( a2dCANVIEW_UPDATE_SYNC_DRAWERS );
    }
    else  if ( ( event.Dragging() && GetBusy() ) /*|| (event.Moving() && GetBusy())*/ )
    {
        a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );
        if ( GetDrawingPart()->GetTrippleBuf() )
        {
            GetDrawing()->SetIgnorePendingObjects( true );

            int x, y, width, height;
            a2dIterC ic( GetDrawingPart() );
            a2dIterCU cu( ic, a2dIDENTITY_MATRIX );
            wxRect absarea = rec->GetAbsoluteArea( ic );
            x = absarea.GetX();
            y = absarea.GetY();
            width = absarea.GetWidth();
            height = absarea.GetHeight();

            rec->SetWidth( m_xwprev - rec->GetPosX() );
            rec->SetHeight( m_ywprev - rec->GetPosY() );
            rec->Update( a2dCanvasObject::updatemask_force );
            rec->SetPending( false );

            wxRect absarea2 = rec->GetAbsoluteArea( ic );
            absarea2.Union( absarea );
            x = absarea2.GetX();
            y = absarea2.GetY();
            width = absarea2.GetWidth();
            height = absarea2.GetHeight();

            GetDrawingPart()->ClearArea( x, y, width, height );
            GetDrawingPart()->SetOverlayDrawStyle( RenderTOOL_OBJECTS_STYLED );
            GetDrawingPart()->RenderChildObject( rec );
            GetDrawingPart()->BlitBuffer( x, y, width, height, 0, 0 );

            GetDrawing()->SetIgnorePendingObjects( false );
            GetDrawingPart()->SetOverlayDrawStyle( RenderTOOL_OBJECTS_STYLED );
        }
        else
        {
            rec->SetWidth( m_xwprev - rec->GetPosX() );
            rec->SetHeight( m_ywprev - rec->GetPosY() );
            rec->SetPending( true );
        }
    }
    else
        event.Skip();
}

BEGIN_EVENT_TABLE( a2dFastSelect2, a2dStTool )
    EVT_CHAR( a2dFastSelect2::OnChar )
    EVT_MOUSE_EVENTS( a2dFastSelect2::OnMouseEvent )
END_EVENT_TABLE()

a2dFastSelect2::a2dFastSelect2( a2dStToolContr* controller ): a2dStTool( controller )
{
    m_eventHandler = new a2dStToolFixedToolStyleEvtHandler( controller );

    m_selectMode = true;

    m_anotate = false;
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );

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

a2dFastSelect2::~a2dFastSelect2()
{
}

void a2dFastSelect2::SelectAll( bool select )
{
    a2dCanvasObjectList objects;
    m_parentobject->GetChildObjectList()->CollectObjects( &objects, wxT( "" ), a2dCanvasOFlags::SELECTED );
    GetCanvasCommandProcessor()->SubmitMultiple(
        new a2dCommand_SetFlag( 0, a2dCanvasOFlags::SELECTED, select  ),
        &objects
    );
}

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

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

    wxCoord w, h, descent, external;
    GetTextExtent( m_anotation, &w, &h, &descent, &external );

    m_xanotation = m_x + h;
    m_yanotation = m_y + h;

    a2dStTool::AddAnotationToPendingUpdateArea();
}

void a2dFastSelect2::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 a2dFastSelect2::OnMouseEvent( wxMouseEvent& event )
{
    if ( !m_active )
    {
        event.Skip();
        return;
    }

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

    m_x = event.GetX();
    m_y = event.GetY();

    MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
    {
        restrict->SetShiftKeyDown( event.ShiftDown() );
        restrict->RestrictPoint( m_xwprev, m_ywprev );
    }

    if ( event.Moving() )
    {
        if ( !GetBusy() )
        {
            double xWorld, yWorld;
            GetDrawingPart()->MouseToToolWorld( m_x, m_y, xWorld, yWorld );
            if ( GetDrawingPart()->IsHitWorld( xWorld, yWorld, wxLAYER_ALL, a2dCANOBJHITOPTION_LAYERS, true ) )
                GetDrawingPart()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_HAND ) );
            else
                GetDrawingPart()->SetCursor( m_toolcursor );

        }
        else
            GetDrawingPart()->SetCursor( m_toolBusyCursor );
    }

    if ( event.LeftDClick() && !GetBusy() )
    {
        m_stcontroller->Zoomout();
    }
    else if ( event.LeftDown() && !GetBusy() )
    {
        SetIgnorePendingObjects( true );
        m_parentobject = GetDrawingPart()->GetShowObject();
        a2dRect* rec = new a2dRect( m_xwprev, m_ywprev, 0, 0, 0 );
        m_canvasobject = rec;
        rec->SetRoot( GetDrawingPart()->GetDrawing() );
        rec->SetFill( m_fill );
        rec->SetStroke( m_stroke );
        rec->Update( a2dCanvasObject::updatemask_force );
        m_pending = true;

        //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();
        EnterBusyMode();
    }
    else if ( event.LeftUp() /*event.LeftDown()*/ && GetBusy() )
    {
        SetIgnorePendingObjects( false );

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

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

        if ( fabs( w ) < 3 && fabs( h ) < 3 )
        {
            // The user did click somewhere ( no drag )

            a2dCanvasObject* hitobject = GetDrawingPart()->IsHitWorld( m_xwprev, m_ywprev, wxLAYER_ALL, a2dCANOBJHITOPTION_LAYERS, true );

            if ( event.m_shiftDown && event.m_controlDown )
            {
                if ( !hitobject )
                {
                    if( !m_oneshot )
                        event.Skip();
                    FinishBusyMode();
                    return;
                }

                //if NOT shift down, deselect all and  set selection to hit object.
                SelectAll( m_selectMode );

                GetCanvasCommandProcessor()->Submit(
                    new a2dCommand_SetFlag( hitobject, a2dCanvasOFlags::SELECTED, !hitobject->GetSelected() )
                );
            }
        }
        else
        {
            a2dWalker_CollectCanvasObjects collector( a2dCanvasOFlags::VISIBLE );
            collector.SetRecursionDepth( 2 );
            //collector.SetCheckLayerVisible( true );
            //collector.SetCheckLayerSelectable( true );
            collector.SetBoundingBox( rec->GetBbox() );
            collector.SetSkipNotRenderedInDrawing( true );
            collector.Start( GetDrawingPart()->GetShowObject() );

            if ( event.m_shiftDown && event.m_controlDown )
            {
                GetCanvasCommandProcessor()->SubmitMultiple(
                    new a2dCommand_SetFlag( 0, a2dCanvasOFlags::SELECTED, !m_selectMode ),
                    &collector.m_found
                );
            }
            else
            {
                GetCanvasCommandProcessor()->SubmitMultiple(
                    new a2dCommand_SetFlag( 0, a2dCanvasOFlags::SELECTED, m_selectMode ),
                    &collector.m_found
                );
            }
        }

        m_pending = true;
        FinishBusyMode();
        GetDrawingPart()->Update( a2dCANVIEW_UPDATE_SYNC_DRAWERS );
    }
    else  if ( ( event.Dragging() && GetBusy() ) /*|| (event.Moving() && GetBusy())*/ )
    {
        a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );

        GetDrawer2D()->BeginDraw();
        GetDrawer2D()->ResetStyle();
        GetDrawer2D()->SetDrawStyle( a2dWIREFRAME_INVERT );
        GetDrawer2D()->SetDrawerFill( m_fill );
        GetDrawer2D()->SetDrawerStroke( *a2dBLACK_STROKE );//m_stroke );
        GetDrawer2D()->DrawRoundedRectangle( rec->GetPosX(), rec->GetPosY(),
                                             rec->GetWidth(), rec->GetHeight(), 0 );

        rec->SetWidth( m_xwprev - rec->GetPosX() );
        rec->SetHeight( m_ywprev - rec->GetPosY() );

        GetDrawer2D()->DrawRoundedRectangle( rec->GetPosX(), rec->GetPosY(),
                                             rec->GetWidth(), rec->GetHeight(), 0 );

        GetDrawer2D()->BlitBuffer();

        GetDrawer2D()->EndDraw();
        GetDrawer2D()->SetDrawStyle( a2dFILLED );

    }
    else
        event.Skip();
}


BEGIN_EVENT_TABLE( a2dFastDragMultiTool, a2dStTool )
    EVT_IDLE( a2dFastDragMultiTool::OnIdle )
    EVT_CHAR( a2dFastDragMultiTool::OnChar )
    EVT_MOUSE_EVENTS( a2dFastDragMultiTool::OnMouseEvent )
END_EVENT_TABLE()

a2dFastDragMultiTool::a2dFastDragMultiTool( a2dStToolContr* controller ): a2dStTool( controller )
{
    m_eventHandler = new a2dStToolFixedToolStyleEvtHandler( controller );

    m_anotate = false;
    m_mode = 0;
    SetFill( *a2dTRANSPARENT_FILL );
    SetStroke( a2dStroke( *wxRED, 0, a2dSTROKE_SOLID ) );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );
}

a2dFastDragMultiTool::~a2dFastDragMultiTool()
{
}

void a2dFastDragMultiTool::OnChar( wxKeyEvent& event )
{
    switch( event.GetKeyCode() )
    {
        case WXK_TAB:
        {
            m_mode++;
            SetMode( m_mode );
        }
        break;
        case WXK_SPACE:
        {
            if ( GetBusy() )
            {}
        }
        break;

        default:
            event.Skip();
    }
}

bool a2dFastDragMultiTool::StartDragging( int x, int y, a2dCanvasObject* original )
{
    m_x = x;
    m_y = y;
    MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

    GetDrawing()->GetHabitat()->SetLastXyEntry( m_xwprev, m_ywprev );

    m_original = original;

    if ( !m_original || !m_original->IsSelected() || !m_original->GetDraggable() )
    {
        m_original = 0;
        return false;
    }

    // collect selected objects
    GetDrawingPart()->GetShowObject()->CollectObjects( &m_objects, _T( "" ), a2dCanvasOFlags::SELECTED );
    EnterBusyMode();

    GetDrawingPart()->Freeze();
    SetIgnorePendingObjects( true );

    m_startMousexw = m_xwprev;
    m_startMouseyw = m_ywprev;
    m_startObjectx = m_original->GetPosX();
    m_startObjecty = m_original->GetPosY();
    m_prevxanotation = m_x;
    m_prevyanotation = m_y;

    m_pending = true;

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
    {
        restrict->SetRestrictPoint( m_startObjectx, m_startObjecty );
    }
    return true;
}

void a2dFastDragMultiTool::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 );

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
    {
        restrict->SetShiftKeyDown( event.ShiftDown() );
        restrict->RestrictPoint( m_xwprev, m_ywprev );
    }

    if ( event.LeftDown() )
    {
        a2dCanvasObject* original = GetDrawingPart()->IsHitWorld( m_xwprev, m_ywprev, wxLAYER_ALL, a2dCANOBJHITOPTION_LAYERS, true  );
        if ( !StartDragging( m_x, m_y, original ) )
            return;
    }
    else if ( event.LeftUp() && GetBusy() )
    {
        GetDrawingPart()->Thaw( false );
        SetIgnorePendingObjects( false );
        FinishBusyMode();

        //GetDrawingPart()->GetDrawing()->UpdateAllViews( NULL, a2dCANVIEW_UPDATE_ALL );
        //if (m_oneshot)
        //    StopTool();
    }
    else if ( GetBusy() )
    {
        double dxm = m_xwprev - m_startMousexw;
        double dym = m_ywprev - m_startMouseyw;
        AdjustShift( &dxm, &dym );
        // drag and restrict main object
        // calculate the shift resulting from this
        double dx = m_canvasobject->GetPosX();
        double dy = m_canvasobject->GetPosY();
        m_canvasobject->SetPosXY( dxm + m_startObjectx, dym + m_startObjecty );
        dx = m_canvasobject->GetPosX() - dx;
        dy = m_canvasobject->GetPosY() - dy;

        DragRelative( dx, dy );
    }
    else
    {
        event.Skip();
    }
}

bool a2dFastDragMultiTool::EnterBusyMode()
{
    if( !a2dStTool::EnterBusyMode() )
        return false;
    CaptureMouse();
    return true;
}

void a2dFastDragMultiTool::FinishBusyMode()
{
    ReleaseMouse();

    double dx = m_canvasobject->GetPosX() - m_startObjectx;
    double dy = m_canvasobject->GetPosY() - m_startObjecty;

    GetCanvasCommandProcessor()->Submit( new a2dCommand_MoveMask( GetDrawingPart()->GetShowObject(), dx, dy ) );

    m_objects.clear();

    a2dStTool::FinishBusyMode();
}

void a2dFastDragMultiTool::AbortBusyMode()
{
    ReleaseMouse();
    a2dStTool::AbortBusyMode();
}

void a2dFastDragMultiTool::CaptureMouse()
{
    wxASSERT( m_canvasobject );
    GetDrawingPart()->SetCaptured( m_canvasobject );
    GetDrawingPart()->GetDisplayWindow()->CaptureMouse();
}

void a2dFastDragMultiTool::ReleaseMouse()
{
    GetDrawingPart()->SetCaptured( NULL );
    GetDrawingPart()->GetDisplayWindow()->ReleaseMouse();
}

void a2dFastDragMultiTool::DragRelative( double x, double y )
{
    if( !x && !y )
        return;

    m_canvasobject->Translate( -x, -y );

    GetDrawer2D()->BeginDraw();
    GetDrawer2D()->ResetStyle();
    GetDrawer2D()->SetDrawStyle( a2dWIREFRAME_INVERT );
    GetDrawer2D()->SetDrawerFill( m_fill );
    GetDrawer2D()->SetDrawerStroke( *a2dBLACK_STROKE );//m_stroke );

    a2dIterC ic( GetDrawingPart() );
    ic.SetDisableInvert( 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 = GetDrawingPart()->GetShowObject()->GetTransformMatrix();
    cworld.Invert();

    OVERLAP clipparent = _IN;
    ic.SetObjectFilter( new a2dCanvasObjectFilterToolObjects( a2dCanvasObject::PROPID_ToolObject, a2dCanvasOFlags::VISIBLE ) );
    ic.SetLayer( wxLAYER_ALL );

    a2dCanvasObjectList::iterator iter;
    for( iter = m_copies.begin(); iter != m_copies.end(); ++iter )
    {
        a2dCanvasObject* copy = *iter;
        a2dIterCU cu( ic, cworld );
        GetDrawer2D()->SetDisableDrawing( true );
        copy->SetHasToolObjectsBelow( true );
        copy->Render( ic, clipparent );
        ic.Reset();
        GetDrawer2D()->SetDisableDrawing( false );
    }

    //Translate all items selected

    for( iter = m_copies.begin(); iter != m_copies.end(); ++iter )
    {
        a2dCanvasObject* obj = *iter;
        obj->Translate( x, y );
    }

    for( iter = m_copies.begin(); iter != m_copies.end(); ++iter )
    {
        a2dCanvasObject* copy = *iter;
        a2dIterCU cu( ic, cworld );
        GetDrawer2D()->SetDisableDrawing( true );
        copy->SetHasToolObjectsBelow( true );
        copy->Render( ic, clipparent );
        ic.Reset();
        GetDrawer2D()->SetDisableDrawing( false );
    }

    GenerateAnotation();

    GetDrawer2D()->BlitBuffer();

    GetDrawer2D()->EndDraw();
    GetDrawer2D()->SetDrawStyle( a2dFILLED );


    m_pending = true;
}

void a2dFastDragMultiTool::Render()
{
    return;
    if ( m_canvasobject && GetBusy() )
    {
        a2dDrawer2D* draw =  GetDrawer2D();
        GetDrawer2D()->BlitBuffer();

        wxClientDC* dc = new wxClientDC( GetDrawingPart()->GetDisplayWindow() );

        a2dDcDrawer* dcdrawer = new a2dDcDrawer( *GetDrawer2D() );
        dcdrawer->SetRenderDC( dc );
        dcdrawer->BeginDraw();
        dcdrawer->ResetStyle();
        dcdrawer->SetDrawerFill( m_fill );
        dcdrawer->SetDrawerStroke( m_stroke );
        dcdrawer->SetDrawerStroke( *a2dBLACK_STROKE );//m_stroke );
        dcdrawer->SetDrawStyle( a2dFIX_STYLE );

        a2dSmrtPtr< a2dDrawingPart > view = new a2dDrawingPart( dcdrawer );
        //view is a a2dView and therefore gets events, but this is not wanted here.
        view->SetEvtHandlerEnabled( false );
        view->SetShowObject( view->GetShowObject() );


        a2dIterC ic( view );
        ic.SetDisableInvert( 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 = GetDrawingPart()->GetShowObject()->GetTransformMatrix();
        cworld.Invert();

        OVERLAP clipparent = _IN;
        ic.SetObjectFilter( new a2dCanvasObjectFilterToolObjects( a2dCanvasObject::PROPID_ToolObject, a2dCanvasOFlags::VISIBLE ) );
        ic.SetLayer( wxLAYER_ALL );

        for( a2dCanvasObjectList::iterator iter = m_copies.begin(); iter != m_copies.end(); ++iter )
        {
            a2dCanvasObject* copy = *iter;
            a2dIterCU cu( ic, cworld );
            ic.GetDrawer2D()->SetDisableDrawing( true );
            copy->SetHasToolObjectsBelow( true );
            copy->Render( ic, clipparent );
            ic.Reset();
            ic.GetDrawer2D()->SetDisableDrawing( false );
        }

        if ( m_anotate )
        {
            dcdrawer->DeviceDrawAnnotation( m_anotation, m_xanotation, m_yanotation, m_annotateFont );
        }

        dcdrawer->EndDraw();
        dcdrawer->OverRuleFixedStyle();
        dcdrawer->SetRenderDC( NULL );
        delete dc;
    }
}

void a2dFastDragMultiTool::AdjustShift( double* WXUNUSED( dx ), double* WXUNUSED( dy ) )
{
}

bool a2dFastDragMultiTool::CreateToolObjects()
{
    m_objects.AssertUnique();

    a2dCanvasObjectList::iterator iter;
    // Clone all selected objects
    for( iter = m_objects.begin(); iter != m_objects.end(); ++iter )
    {
        a2dCanvasObjectPtr original = *iter;
        a2dCanvasObject* copy = original->TClone( clone_flat );

        copy->SetAlgoSkip( true );
        a2dCanvasObject::PROPID_ToolObject->SetPropertyToObject( copy, this );
        //a2dCanvasObject::PROPID_viewSpecific->SetPropertyToObject( copy, GetDrawingPart() );

        m_copies.push_back( copy );
        copy->SetSelected( false );

        if( original == m_original )
            m_canvasobject = copy;
    }

    m_pending = true;

    return true;
}

void a2dFastDragMultiTool::CleanupToolObjects()
{
    a2dStTool::CleanupToolObjects();
    // Clone all selected objects
    m_copies.clear();
}


void a2dFastDragMultiTool::OnIdle( wxIdleEvent& event )
{
    if ( m_canvasobject && m_pending && GetBusy() )
    {
        m_pending = false;

    }
    else
        event.Skip();
}

void a2dFastDragMultiTool::GenerateAnotation()
{
    if ( m_anotate )
    {
        m_anotation.Printf( _T( "x %6.3f y %6.3f" ), m_canvasobject->GetPosX(), m_canvasobject->GetPosY() );
        wxCoord w, h, descent, external;
        GetTextExtent( m_anotation, &w, &h, &descent, &external );
        m_xanotation = m_x + h;
        m_yanotation = m_y + h;

        GetDrawer2D()->DeviceDrawAnnotation( m_anotation, m_prevxanotation, m_prevyanotation, m_annotateFont );

        GetDrawer2D()->DeviceDrawAnnotation( m_anotation, m_xanotation, m_yanotation, m_annotateFont );

        m_prevxanotation = m_xanotation;
        m_prevyanotation = m_yanotation;
    }
}

void a2dFastDragMultiTool::SetMode( int mode )
{
    m_mode = mode;
    if ( m_mode > 2 ) m_mode = 0;

    if ( !m_canvasobject )
        return;

    m_pending = true;
}

BEGIN_EVENT_TABLE( a2dFastCopyMultiTool, a2dFastDragMultiTool )
    EVT_CHAR( a2dFastCopyMultiTool::OnChar )
    EVT_MOUSE_EVENTS( a2dFastCopyMultiTool::OnMouseEvent )
END_EVENT_TABLE()

a2dFastCopyMultiTool::a2dFastCopyMultiTool( a2dStToolContr* controller ): a2dFastDragMultiTool( controller )
{
    m_mindist = GetDrawer2D()->DeviceToWorldXRel( 5 ); //GetDrawing()->GetHabitat()->GetCopyMinDistance();
}

void a2dFastCopyMultiTool::OnChar( wxKeyEvent& event )
{
    if ( GetBusy() )
    {
        switch( event.GetKeyCode() )
        {
            case WXK_SPACE:
            {
            }
            break;
            default:
                event.Skip();
        }
    }
    else
        event.Skip();

}

bool a2dFastCopyMultiTool::StartDragging( int x, int y, a2dCanvasObject* original )
{
    m_x = x;
    m_y = y;
    MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

    GetDrawing()->GetHabitat()->SetLastXyEntry( m_xwprev, m_ywprev );

    m_original = original;

    if ( !m_original || !m_original->IsSelected() || !m_original->GetDraggable() )
    {
        m_original = 0;
        return false;
    }

    // OpenCommandGroup must be issued before new objects are added
    // This is also done in EnterBusyMode, but it can be done more than once
    OpenCommandGroup( false );

    a2dRefMap refs;

    // Copy all selected objects
    // Deselect the original selected objects
    // Select the copied objects
    {
        bool originalfound = false;
        a2dCanvasObjectList::iterator iter;
        for( iter = m_parentobject->GetChildObjectList()->begin(); iter != m_parentobject->GetChildObjectList()->end(); ++iter )
        {
            a2dCanvasObject* obj = *iter;
            if( obj->GetSelected() )
            {
                a2dCanvasObject* objn = obj->TClone( clone_members | clone_childs, &refs );
                // Collect the new object into the active object list
                m_objects.push_back( objn );
                // Deselect the original objects
                GetCanvasCommandProcessor()->Submit( new a2dCommand_SetFlag( obj, a2dCanvasOFlags::SELECTED, false ), true );
                // m_original must point to the copied object
                if( obj == m_original )
                {
                    m_original = objn;
                    originalfound = true;
                }
            }
        }
        wxASSERT( originalfound );

        for( iter = m_objects.begin(); iter != m_objects.end(); ++iter )
        {
            ( *iter )->SetSelected( true );
            // Add the new object
            GetCanvasCommandProcessor()->Submit( new a2dCommand_AddObject( m_parentobject, ( *iter ) ), true );
        }

        // Connect pins in copy as in source
        refs.LinkReferences();
    }
    EnterBusyMode();

    GetDrawingPart()->Freeze();
    SetIgnorePendingObjects( true );

    m_startMousexw = m_xwprev;
    m_startMouseyw = m_ywprev;
    m_startObjectx = m_original->GetPosX();
    m_startObjecty = m_original->GetPosY();

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
        restrict->SetRestrictPoint( m_startObjectx, m_startObjecty );

    // Make one shift so that the copy is not over the original
    {
        double dxm = m_xwprev - m_startMousexw;
        double dym = m_ywprev - m_startMouseyw;
        AdjustShift( &dxm, &dym );
        // drag and restrict main object
        // calculate the shift resulting from this
        double dx = m_canvasobject->GetPosX();
        double dy = m_canvasobject->GetPosY();
        m_canvasobject->SetPosXY( dxm + m_startObjectx, dym + m_startObjecty );
        dx = m_canvasobject->GetPosX() - dx;
        dy = m_canvasobject->GetPosY() - dy;
        DragRelative( dx, dy );
    }
    m_pending = true;
    return true;
}

void a2dFastCopyMultiTool::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 );

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
    {
        restrict->SetShiftKeyDown( event.ShiftDown() );
        restrict->RestrictPoint( m_xwprev, m_ywprev );
    }

    if ( event.LeftDown() )
    {
        a2dCanvasObject* original = GetDrawingPart()->IsHitWorld( m_xwprev, m_ywprev, wxLAYER_ALL, a2dCANOBJHITOPTION_LAYERS, true  );
        if ( !StartDragging( m_x, m_y, original ) )
            return;
    }
    else if ( event.LeftUp() && GetBusy() )
    {
        event.Skip();
    }
    else if ( GetBusy() )
    {
        event.Skip();
    }
    else
    {
        event.Skip();
    }
}

void a2dFastCopyMultiTool::AdjustShift( double* dx, double* dy )
{
    if( ( *dx ) * ( *dx ) + ( *dy ) * ( *dy ) < m_mindist )
    {
        if( ( *dx ) == 0 && ( *dy ) == 0 )
        {
            ( *dx ) = m_mindist * 1.0;
            ( *dy ) = m_mindist * 0.5;
        }
        else
        {
            double fac = m_mindist / sqrt( ( *dx ) * ( *dx ) + ( *dy ) * ( *dy ) );
            ( *dx ) *= fac;
            ( *dy ) *= fac;
        }
    }
}

void a2dFastCopyMultiTool::FinishBusyMode()
{
    ReleaseMouse();

    double dx = m_canvasobject->GetPosX() - m_startObjectx;
    double dy = m_canvasobject->GetPosY() - m_startObjecty;

    GetCanvasCommandProcessor()->Submit( new a2dCommand_CopyMask( GetDrawingPart()->GetShowObject(), dx, dy ) );
    a2dCanvasObjectList::iterator iter;
    for( iter = m_objects.begin(); iter != m_objects.end(); ++iter )
    {
        a2dCanvasObject* obj = *iter;
        // Deselect the original objects
        obj->SetPending( true );
        GetCanvasCommandProcessor()->Submit( new a2dCommand_SetFlag( obj, a2dCanvasOFlags::SELECTED, false ), true );
    }
    m_objects.clear();
    a2dStTool::FinishBusyMode();
}

//----------------------------------------------------------------------------
// a2dDrawRectangleToolFast
//----------------------------------------------------------------------------

IMPLEMENT_CLASS( a2dDrawRectangleToolFast, a2dStDrawToolFast )

BEGIN_EVENT_TABLE( a2dDrawRectangleToolFast, a2dStDrawToolFast )
    EVT_COM_EVENT( a2dDrawRectangleToolFast::OnComEvent )
    EVT_MOUSE_EVENTS( a2dDrawRectangleToolFast::OnMouseEvent )
END_EVENT_TABLE()

a2dDrawRectangleToolFast::a2dDrawRectangleToolFast( a2dStToolContr* controller ): a2dStDrawToolFast( controller )
{
    m_radius = 0;
    SetFill( *a2dTRANSPARENT_FILL );
    SetStroke( a2dStroke( *wxBLACK, 2, a2dSTROKE_LONG_DASH ) );
    m_xwlast = 0;
    m_ywlast = 0;
    m_didDraw = false;
}

a2dDrawRectangleToolFast::~a2dDrawRectangleToolFast()
{
}

void a2dDrawRectangleToolFast::OnComEvent( a2dComEvent& event )
{
    if ( GetBusy() &&
            event.GetId() == a2dStToolContr::sm_showCursor &&
            m_stcontroller->GetFrame() &&
            m_stcontroller->GetFrame()->GetStatusBar() )
    {
        double mouse_worldx = m_xwprev;
        double mouse_worldy = m_ywprev;

        wxString unitmeasure = GetDrawing()->GetUnits();
        double scaleToMeters = GetDrawing()->GetUnitsScale();

        double multi = 1;
        a2dDoMu::GetMultiplierFromString( unitmeasure, multi );

        mouse_worldx *= scaleToMeters / multi;
        mouse_worldy *= scaleToMeters / multi;

        a2dRect* rec = wxStaticCast( m_original.Get(), a2dRect );
        wxString str;
        str.Printf( _T( "x=%6.3f, y=%6.3f, width=%6.3f, height=%6.3f" ),
                    mouse_worldx, mouse_worldy,
                    rec->GetWidth(), rec->GetHeight() );
        str = str + _T( " " ) + unitmeasure + _T( " :" ) + GetClassInfo()->GetClassName();
        m_stcontroller->GetFrame()->SetStatusText( str );
    }
    else
        event.Skip();
}

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

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

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

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
    {
        restrict->SetShiftKeyDown( event.ShiftDown() );
        restrict->RestrictPoint( m_xwprev, m_ywprev );
    }

    double wr = GetDrawer2D()->DeviceToWorldXRel( 30 );
    if ( event.LeftDown() && !GetBusy() )
    {
        EnterBusyMode();
    }
    else if ( event.LeftDown() && GetBusy() )
    {
        a2dRect* rec = wxStaticCast( m_original.Get(), a2dRect );
        a2dGeneralGlobals->RecordF( this, _T( "rect %f %f %f %f" ), rec->GetPosX(), rec->GetPosY(), rec->GetWidth(), rec->GetHeight() );
        FinishBusyMode();
    }
    else  if ( ( event.Dragging() && GetBusy() ) || ( event.Moving() && GetBusy() ) )
    {
        a2dRect* rec = wxStaticCast( m_canvasobject.Get(), a2dRect );
        //adjust the tool object
        rec->SetWidth( m_xwprev - rec->GetPosX() );
        rec->SetHeight( m_ywprev - rec->GetPosY() );
        a2dCanvasObject::SetIgnoreAllSetpending( true );
        a2dRect* recorg = wxStaticCast( m_original.Get(), a2dRect );
        recorg->SetWidth( rec->GetWidth() );
        recorg->SetHeight( rec->GetHeight() );        //event.Skip();
        a2dCanvasObject::SetIgnoreAllSetpending( false );
    }
    else  if ( !GetBusy() )
    {
        event.Skip();
    }
    else
        event.Skip();
}

bool a2dDrawRectangleToolFast::CreateToolObjects()
{
    a2dRect* rec = new a2dRect( m_xwprev, m_ywprev, 0, 0, m_radius );
    m_original = rec;
    rec->SetFill( m_fill );
    rec->SetStroke( m_stroke );

    return a2dStDrawToolFast::CreateToolObjects();
}

//----------------------------------------------------------------------------
// a2dDrawCircleToolFast
//----------------------------------------------------------------------------

IMPLEMENT_CLASS( a2dDrawCircleToolFast, a2dStDrawToolFast )

BEGIN_EVENT_TABLE( a2dDrawCircleToolFast, a2dStDrawToolFast )
    EVT_COM_EVENT( a2dDrawCircleToolFast::OnComEvent )
    EVT_CHAR( a2dDrawCircleToolFast::OnChar )
    EVT_MOUSE_EVENTS( a2dDrawCircleToolFast::OnMouseEvent )
END_EVENT_TABLE()

a2dDrawCircleToolFast::a2dDrawCircleToolFast( a2dStToolContr* controller ): a2dStDrawToolFast( controller )
{
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_PENCIL );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );
}

void a2dDrawCircleToolFast::OnComEvent( a2dComEvent& event )
{
    if ( GetBusy() &&
            event.GetId() == a2dStToolContr::sm_showCursor &&
            m_stcontroller->GetFrame() &&
            m_stcontroller->GetFrame()->GetStatusBar() )
    {
        double mouse_worldx = m_xwprev;
        double mouse_worldy = m_ywprev;

        wxString unitmeasure = GetDrawing()->GetUnits();
        double scaleToMeters = GetDrawing()->GetUnitsScale();

        double multi = 1;
        a2dDoMu::GetMultiplierFromString( unitmeasure, multi );

        mouse_worldx *= scaleToMeters / multi;
        mouse_worldy *= scaleToMeters / multi;

        a2dCircle* cir = wxStaticCast( m_original.Get(), a2dCircle );
        wxString str;
        str.Printf( _T( "x=%6.3f, y=%6.3f, radius=%6.3f" ), mouse_worldx, mouse_worldy, cir->GetRadius() );
        str = str + _T( " " ) + unitmeasure + _T( " :" ) + GetClassInfo()->GetClassName();
        m_stcontroller->GetFrame()->SetStatusText( str );
    }
    else
        event.Skip();
}


void a2dDrawCircleToolFast::OnChar( wxKeyEvent& event )
{
    if ( GetBusy() )
    {
        switch( event.GetKeyCode() )
        {
            case WXK_TAB:
            {
                m_mode++;
            }
            break;

            default:
                event.Skip();
        }
    }
    else
        event.Skip();

}

void a2dDrawCircleToolFast::SetMode( int mode )
{
    m_mode = mode;
    if ( m_mode > 2 ) m_mode = 0;

    if ( !m_canvasobject )
        return;

    a2dCircle* cir = wxStaticCast( m_canvasobject.Get(), a2dCircle );
    a2dCircle* cirorg = wxStaticCast( m_original.Get(), a2dCircle );
    switch ( m_mode )
    {
        case 0:
        {
            double dx, dy;

            if ( fabs( m_xwprev - m_start_x ) > fabs( m_ywprev - m_start_y ) )
            {
                dx = ( m_xwprev - m_start_x ) / 2 ;
                m_radius = fabs( dx );
                if ( m_ywprev > m_start_y )
                    dy = m_radius;
                else
                    dy = -m_radius;
            }
            else
            {
                dy = ( m_ywprev - m_start_y ) / 2 ;
                m_radius = fabs( dy );
                if ( m_xwprev > m_start_x )
                    dx = m_radius;
                else
                    dx = -m_radius;
            }
            cir->SetPosXY( m_start_x + dx , m_start_y + dy );
            cirorg->SetPosXY( m_start_x + dx , m_start_y + dy );
            break;
        }
        case 1:
        {
            cir->SetPosXY( m_start_x, m_start_y );
            cirorg->SetPosXY( m_start_x, m_start_y );
            m_radius = sqrt( pow( m_xwprev - cir->GetPosX(), 2 ) + pow( m_ywprev - cir->GetPosY(), 2 ) );
            break;
        }
        case 2:
        {
            cir->SetPosXY( ( m_xwprev + m_start_x ) / 2, ( m_ywprev + m_start_y ) / 2 );
            cirorg->SetPosXY( ( m_xwprev + m_start_x ) / 2, ( m_ywprev + m_start_y ) / 2 );
            m_radius = sqrt( pow( m_xwprev - m_start_x, 2 ) + pow( m_ywprev - m_start_y, 2 ) ) / 2;
            break;
        }
        default:
            break;
    }

    cir->SetRadius( m_radius );
    cirorg->SetRadius( m_radius );
    m_pending = true;
}

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

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

    m_x = event.GetX();
    m_y = event.GetY();
    double newx, newy;
    MouseToToolWorld( m_x, m_y, newx, newy );

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if( restrict )
    {
        restrict->SetShiftKeyDown( event.ShiftDown() );
        restrict->RestrictPoint( newx, newy );
    }

    if ( event.LeftDown() && !GetBusy() )
    {
        m_radius = 0;
        m_xwprev = newx;
        m_ywprev = newy;
        m_start_x = m_xwprev;
        m_start_y = m_ywprev;
        EnterBusyMode();
    }
    else if ( event.LeftDown() && GetBusy() )
    {
        a2dGeneralGlobals->RecordF( this, _T( "circle %f %f %f" ), m_original->GetPosX(), m_original->GetPosY(), m_radius );

        FinishBusyMode();
    }
    else  if ( ( event.Dragging() && GetBusy() ) || ( event.Moving() && GetBusy() ) )
    {
        m_xwprev = newx;
        m_ywprev = newy;
        a2dCanvasObject::SetIgnoreAllSetpending( true );
        SetMode( m_mode );
        a2dCanvasObject::SetIgnoreAllSetpending( false );
        m_canvasobject->SetPending( true );
    }
    else
        event.Skip();
}

bool a2dDrawCircleToolFast::CreateToolObjects()
{
    m_original = new a2dCircle( m_xwprev, m_ywprev, m_radius );
    m_original->SetFill( m_fill );
    m_original->SetStroke( m_stroke );

    return a2dStDrawToolFast::CreateToolObjects();
}

IMPLEMENT_CLASS( a2dDrawPolygonLToolFast, a2dStDrawToolFast )

BEGIN_EVENT_TABLE( a2dDrawPolygonLToolFast, a2dStDrawToolFast )
    EVT_IDLE( a2dDrawPolygonLToolFast::OnIdle )
    EVT_CHAR( a2dDrawPolygonLToolFast::OnChar )
    EVT_MOUSE_EVENTS( a2dDrawPolygonLToolFast::OnMouseEvent )
    EVT_UNDO( a2dDrawPolygonLToolFast::OnUndoEvent )
    EVT_REDO( a2dDrawPolygonLToolFast::OnRedoEvent )
END_EVENT_TABLE()

void a2dDrawPolygonLToolFast::AddPoint( a2dLineSegment* point )
{
    if ( m_reverse )
        m_points->push_front( point );
    else
        m_points->push_back( point );
}

a2dDrawPolygonLToolFast::a2dDrawPolygonLToolFast( a2dStToolContr* controller, a2dPolygonL* templateObject ): a2dStDrawToolFast( controller )
{
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_PENCIL );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_CROSS );
    m_contourwidth = GetDrawing()->GetHabitat()->GetContourWidthInDataBaseUnits();

    m_canvasobject = ( a2dCanvasObject* )0;
    m_points = ( a2dVertexList* ) 0;

    m_spline = GetDrawing()->GetHabitat()->GetSpline();
    m_reverse = false;

    m_templateObject = templateObject;
    if ( templateObject )
        m_spline = m_templateObject->GetSpline();
}

a2dDrawPolygonLToolFast::~a2dDrawPolygonLToolFast()
{
}

void a2dDrawPolygonLToolFast::SetSpline( bool spline )
{
    m_spline = spline;
}

void a2dDrawPolygonLToolFast::OnIdle( wxIdleEvent& event )
{
    if ( m_pending && GetBusy() )
    {
        RemoveAllDecorations();

        a2dPolygonL* poly = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
        a2dRect* around = NULL;
        a2dPolygonL* nonSplined = NULL;

        switch ( m_mode )
        {
            case 2:
            {
                //a nice to see normal polygon around it and if stroke transparent show it.
                if ( poly->GetSpline() )
                {
                    nonSplined = ( a2dPolygonL* ) poly->TClone( clone_childs );
                    nonSplined->SetVisible( true );
                    nonSplined->SetSpline( false );
                    nonSplined->SetFill( *a2dTRANSPARENT_FILL );

                    nonSplined->SetStroke( *wxBLACK, 0, a2dSTROKE_DOT_DASH );
                    AddDecorationObject( nonSplined );

                }
            }
            case 1:
            {
                around = new a2dRect( poly->GetBboxMinX(), poly->GetBboxMinY(), poly->GetBboxWidth(), poly->GetBboxHeight() );
                around->SetStroke( *wxRED, 0, a2dSTROKE_DOT_DASH );
                around->SetFill( *a2dTRANSPARENT_FILL );
                around->SetRoot( GetDrawingPart()->GetDrawing() );
                AddDecorationObject( around );
                break;
            }
            default:
                break;
        }

        event.Skip();
    }
    else
        event.Skip();
}

void a2dDrawPolygonLToolFast::OnUndoEvent( a2dCommandProcessorEvent& event )
{
/*  
    NOT like this, goes wrong if several instances of same tool.
    static long lastProcessedEventTimeStamp = -1; // for a2d...Events
    if( lastProcessedEventTimeStamp == event.GetTimestamp() )
        return;
    lastProcessedEventTimeStamp = event.GetTimestamp();
*/

    if ( GetBusy() && !m_halted )
    {
        // recreate edit copies so the edit copy becomes updated from the original.

        a2dPolygonL* poly = wxStaticCast( m_original.Get(), a2dPolygonL );
        if ( poly->GetNumberOfSegments() )
        {
            a2dLineSegmentPtr lastpoint = poly->GetSegments()->back();
            CleanupToolObjects();
            GetDrawingPart()->Update( a2dCANVIEW_UPDATE_OLDNEW );
            CreateToolObjects();
            m_points = wxStaticCast( m_canvasobject.Get(), a2dPolygonL )->GetSegments();
            m_point = lastpoint;
            m_points->push_back( m_point );
        }
    }
}

void a2dDrawPolygonLToolFast::OnRedoEvent( a2dCommandProcessorEvent& event )
{
    OnUndoEvent( event );
}

void a2dDrawPolygonLToolFast::SetMode( int mode )
{
    m_mode = mode;
    if ( m_mode > 2 ) m_mode = 0;

    if ( !m_canvasobject )
        return;

    m_pending = true;
}

void a2dDrawPolygonLToolFast::OnChar( wxKeyEvent& event )
{
    if ( GetBusy() && m_canvasobject )
    {
        double shiftx;
        double shifty;
        GetKeyIncrement( &shiftx, &shifty );

        switch( event.GetKeyCode() )
        {
            case WXK_TAB:
            {
                m_mode++;
                SetMode( m_mode );
            }
            break;

            case WXK_UP:
                shiftx = 0;
                break;

            case WXK_DOWN:
                shiftx = 0;
                shifty = -shifty;
                break;

            case WXK_LEFT:
                shiftx = -shiftx;
                shifty = 0;
                break;

            case WXK_RIGHT:
                shifty = 0;
                break;

            default:
            {
                shiftx = 0;
                shifty = 0;
                event.Skip();
            }
        }

        if ( event.m_controlDown )
        {
            m_point->m_x += shiftx;
            m_point->m_y += shifty;
        }
        else
        {
            double x = m_canvasobject->GetPosX();
            double y = m_canvasobject->GetPosY();
            m_canvasobject->SetPosXY( x + shiftx, y + shifty, true );
            a2dPolygonL* poly = wxStaticCast( m_canvasobject.Get(), a2dPolygonL );
            poly->EliminateMatrix();
        }

        GetDisplayWindow()->WarpPointer( GetDrawer2D()->WorldToDeviceX( m_point->m_x ), GetDrawer2D()->WorldToDeviceY( m_point->m_y ) );

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

}

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

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

    m_x = event.GetX();
    m_y = event.GetY();

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if ( event.LeftDown() && !GetBusy() )
    {
        SetIgnorePendingObjects( true );
        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );
        if( restrict )
        {
            restrict->SetShiftKeyDown( event.ShiftDown() );
            restrict->RestrictPoint( m_xwprev, m_ywprev );
        }
        GetDrawing()->GetHabitat()->SetLastXyEntry( m_xwprev, m_ywprev );

        if ( m_templateObject )
        {
            m_original = m_templateObject->TClone( clone_childs );
            m_original->Translate( m_xwprev, m_ywprev );
            m_original->EliminateMatrix();
        }
        else
        {
            m_original = new a2dPolygonL( new a2dVertexList(), m_spline );
            m_original->SetStroke( m_stroke );
            m_original->SetFill( m_fill );
            m_original->SetLayer( m_layer );
        }

        EnterBusyMode();

        // Append first point to original
        GetCanvasCommandProcessor()->Submit(
            new a2dCommand_AddPoint( m_original, m_xwprev, m_ywprev, -1 )
        );
        // Append first point to editcopy
        m_points = wxStaticCast( m_canvasobject.Get(), a2dPolygonL )->GetSegments();
        m_point = new a2dLineSegment( m_xwprev, m_ywprev );
        m_points->push_back( m_point );

        // Record commands
        a2dGeneralGlobals->RecordF( this, _T( "polygon" ) );
        a2dGeneralGlobals->RecordF( this, _T( "addpoint %f %f" ), m_xwprev, m_ywprev );

        //add second point to drag
        m_point = new a2dLineSegment( m_xwprev, m_ywprev );
        m_points->push_back( m_point );

        m_prev_x = m_xwprev;
        m_prev_y = m_ywprev;
        m_pending = true;
        if( restrict )
            restrict->SetRestrictPoint( m_xwprev, m_ywprev );
    }
    else if ( event.LeftDown() && GetBusy() )
    {
        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );
        if( restrict )
            restrict->RestrictPoint( m_xwprev, m_ywprev );

        GetDrawing()->GetHabitat()->SetLastXyEntry( m_xwprev, m_ywprev );
        int x = GetDrawer2D()->WorldToDeviceX( m_prev_x );
        int y = GetDrawer2D()->WorldToDeviceY( m_prev_y );
        if ( abs( m_x - x ) >= 3 || abs( m_y - y ) >= 3 )
        {
            GetCanvasCommandProcessor()->Submit(
                new a2dCommand_AddPoint( m_original, m_xwprev, m_ywprev, -1 )
            );

            a2dGeneralGlobals->RecordF( this, _T( "addpoint %f %f " ), m_xwprev, m_ywprev );

            m_point = new a2dLineSegment( m_xwprev, m_ywprev );
            m_points->push_back( m_point );
            m_prev_x = m_xwprev;
            m_prev_y = m_ywprev;
        }
        if( restrict )
            restrict->SetRestrictPoint( m_xwprev, m_ywprev );
    }
    else if ( event.Moving() && GetBusy() )
    {
        SetMode( m_mode );

        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );
        if( restrict )
            restrict->RestrictPoint( m_xwprev, m_ywprev );
        m_point->m_x = m_xwprev;
        m_point->m_y = m_ywprev;
        m_canvasobject->SetPending( true );

        event.Skip();
    }
    else if ( event.LeftDClick() && GetBusy() )
    {
        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );
        if( restrict )
            restrict->RestrictPoint( m_xwprev, m_ywprev );
        GetDrawing()->GetHabitat()->SetLastXyEntry( m_xwprev, m_ywprev );
        a2dGeneralGlobals->RecordF( this, _T( "end" ) );
        FinishBusyMode();
    }
    else
        event.Skip();
}

bool a2dDrawPolygonLToolFast::CreateToolObjects()
{
    return a2dStDrawToolFast::CreateToolObjects();
}

IMPLEMENT_CLASS( a2dDrawPolylineLToolFast, a2dDrawPolygonLToolFast )

BEGIN_EVENT_TABLE( a2dDrawPolylineLToolFast, a2dDrawPolygonLToolFast )
    EVT_MOUSE_EVENTS( a2dDrawPolylineLToolFast::OnMouseEvent )
    EVT_DO( a2dDrawPolylineLToolFast::OnDoEvent )
END_EVENT_TABLE()

a2dDrawPolylineLToolFast::a2dDrawPolylineLToolFast( a2dStToolContr* controller, a2dPolylineL* templateObject ):
    a2dDrawPolygonLToolFast( controller, templateObject )
{
    m_xscale = 1;
    m_yscale = 1;
    m_begin = 0;
    m_end = 0;
    m_pathtype = GetDrawing()->GetHabitat()->GetPathType();
    m_contourwidth = GetDrawing()->GetHabitat()->GetContourWidthInDataBaseUnits();
}

a2dDrawPolylineLToolFast::~a2dDrawPolylineLToolFast()
{
}

void a2dDrawPolylineLToolFast::SetPathType( a2dPATH_END_TYPE pathtype )
{
    if ( GetBusy() )
    {
        a2dPolylineL* poly = wxStaticCastNull( m_canvasobject.Get(), a2dPolylineL );
        poly->SetPathType( m_pathtype );
        a2dPolylineL* polyorg = wxStaticCastNull( m_original.Get(), a2dPolylineL );
        polyorg->SetPathType( m_pathtype );
    }

    m_pathtype = pathtype;
}

void a2dDrawPolylineLToolFast::SetLineBegin( a2dCanvasObject* begin )
{
    if ( GetBusy() )
    {
        a2dPolylineL* poly = wxStaticCastNull( m_canvasobject.Get(), a2dPolylineL );
        poly->SetEndScaleX( m_yscale );
        poly->SetEndScaleY( m_xscale );
        poly->SetBegin( begin );
        a2dPolylineL* polyorg = wxStaticCastNull( m_original.Get(), a2dPolylineL );
        polyorg->SetEndScaleX( m_yscale );
        polyorg->SetEndScaleY( m_xscale );
        polyorg->SetBegin( begin );
    }
    m_begin = begin;
}

void a2dDrawPolylineLToolFast::SetLineEnd( a2dCanvasObject* end )
{
    if ( GetBusy() )
    {
        a2dPolylineL* poly = wxStaticCastNull( m_canvasobject.Get(), a2dPolylineL );
        poly->SetEndScaleX( m_yscale );
        poly->SetEndScaleY( m_xscale );
        poly->SetEnd( end );
        a2dPolylineL* polyorg = wxStaticCastNull( m_original.Get(), a2dPolylineL );
        polyorg->SetEndScaleX( m_yscale );
        polyorg->SetEndScaleY( m_xscale );
        polyorg->SetEnd( end );
    }
    m_end = end;
}

void a2dDrawPolylineLToolFast::OnDoEvent( a2dCommandProcessorEvent& event )
{
    if ( !m_templateObject )
    {
        if ( event.GetId() == a2dHabitat::sig_SetContourWidth )
        {
            m_contourwidth = GetDrawing()->GetHabitat()->GetContourWidthInDataBaseUnits();
            if ( GetBusy() )
            {
                m_canvasobject->SetContourWidth( m_contourwidth );
                m_original->SetContourWidth( m_contourwidth );
            }
        }
        if ( event.GetId() == a2dHabitat::sig_SetPathType )
        {
            m_pathtype = GetDrawing()->GetHabitat()->GetPathType();
            if ( GetBusy() )
            {
                a2dPolylineL* poly = wxStaticCast( m_original.Get(), a2dPolylineL );
                poly->SetPathType( m_pathtype );
                poly = wxStaticCast( m_canvasobject.Get(), a2dPolylineL );
                poly->SetPathType( m_pathtype );
            }
        }
    }
    event.Skip();
}

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

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

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

    a2dRestrictionEngine* restrict = GetDrawing()->GetHabitat()->GetRestrictionEngine();
    if ( event.LeftDown() && !GetBusy() )
    {
        SetIgnorePendingObjects( true );
        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );

        if( restrict )
        {
            restrict->SetShiftKeyDown( event.ShiftDown() );
            restrict->RestrictPoint( m_xwprev, m_ywprev );
        }
        GetDrawing()->GetHabitat()->SetLastXyEntry( m_xwprev, m_ywprev );

        if ( m_templateObject )
        {
            m_original = m_templateObject->TClone( clone_childs | clone_members );
            m_original->Translate( m_xwprev, m_ywprev );
            m_original->EliminateMatrix();
        }
        else
        {
            m_original = new a2dPolylineL( new a2dVertexList(), m_spline );
            m_original->SetContourWidth( m_contourwidth );
            m_original->SetStroke( m_stroke );
            m_original->SetFill( m_fill );
            m_original->SetLayer( m_layer );
            a2dPolylineL* poly = wxStaticCast( m_original.Get(), a2dPolylineL );
            poly->SetPathType( m_pathtype );
            if ( m_begin || m_end )
            {
                poly->SetEndScaleX( m_yscale );
                poly->SetEndScaleY( m_xscale );
                //we clone to have each line an endobject that is not shared with the tool line ends
                //Meaning it does not change when tool changes.
                if ( m_begin )
                    poly->SetBegin( m_begin->TClone( clone_flat ) );
                if ( m_end )
                    poly->SetEnd( m_end->TClone( clone_flat ) );
            }
        }

        EnterBusyMode();
        m_canvasobject->SetContourWidth( m_contourwidth );
        a2dPolylineL* poly = wxStaticCast( m_canvasobject.Get(), a2dPolylineL );
        poly->SetPathType( m_pathtype );

        m_points = poly->GetSegments();

        a2dGeneralGlobals->RecordF( this, _T( "polyline" ) );

        m_canvasobject->SetRoot( GetDrawingPart()->GetDrawing() );

        // add point to the original
        if ( m_reverse )
            GetCanvasCommandProcessor()->Submit(
                new a2dCommand_AddPoint( m_original, m_xwprev, m_ywprev, 0 )
            );
        else
            GetCanvasCommandProcessor()->Submit(
                new a2dCommand_AddPoint( m_original, m_xwprev, m_ywprev, -1 )
            );

        m_point = new a2dLineSegment( m_xwprev, m_ywprev );
        AddPoint( m_point );

        a2dGeneralGlobals->RecordF( this, _T( "addpoint %f %f " ), m_xwprev, m_ywprev );

        //add second point to drag
        m_point = new a2dLineSegment( m_xwprev, m_ywprev );
        AddPoint( m_point );

        m_prev_x = m_xwprev;
        m_prev_y = m_ywprev;

        if( restrict )
            restrict->SetRestrictPoint( m_xwprev, m_ywprev );
    }
    else if ( event.Moving() && GetBusy() )
    {
        SetMode( m_mode );

        MouseToToolWorld( m_x, m_y, m_xwprev, m_ywprev );
        if( restrict )
            restrict->RestrictPoint( m_xwprev, m_ywprev );
        m_point->m_x = m_xwprev;
        m_point->m_y = m_ywprev;
        m_canvasobject->SetPending( true );
    }
    else
        event.Skip();
}

bool a2dDrawPolylineLToolFast::CreateToolObjects()
{
    return a2dStDrawToolFast::CreateToolObjects();
}