edit.cpp

Go to the documentation of this file.

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

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets Licence

    RCS-ID: $Id: edit.cpp,v 1.173 2009/07/04 10:26:39 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/editor/edit.h"

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

IMPLEMENT_CLASS(a2dRecursiveEditTool, a2dObjectEditTool)

const a2dCommandId a2dRecursiveEditTool::COMID_PushTool_RecursiveEdit( wxT("PushTool_RecursiveEdit") );
const a2dCommandId a2dMultiEditTool::COMID_PushTool_MultiEdit( wxT("PushTool_MultiEdit") );


A2D_BEGIN_EVENT_TABLE(a2dRecursiveEditTool,a2dObjectEditTool)
    A2D_EVT_COM_EVENT( a2dRecursiveEditTool::OnComEvent )
    A2D_EVT_MOUSE_EVENTS(a2dRecursiveEditTool::OnMouseEvent)
    A2D_EVT_IDLE( a2dRecursiveEditTool::OnIdle )
    A2D_EVT_CHAR( a2dRecursiveEditTool::OnChar )
    A2D_EVT_UNDO( a2dRecursiveEditTool::OnUndoEvent )
    A2D_EVT_REDO( a2dRecursiveEditTool::OnRedoEvent )
    A2D_EVT_KEY_UP( a2dRecursiveEditTool::OnKeyUp)
A2D_END_EVENT_TABLE()

a2dRecursiveEditTool::a2dRecursiveEditTool( a2dStToolContr* controller, a2dIterC& ic, int editmode, bool SingleClickToEnd )
    :a2dObjectEditTool(controller, ic, editmode, SingleClickToEnd )
{
    m_oneshot = false;
}

a2dRecursiveEditTool::a2dRecursiveEditTool(a2dStToolContr* controller, int editmode, bool SingleClickToEnd )
    :a2dObjectEditTool(controller, editmode, SingleClickToEnd )
{
    m_oneshot = false;
}

a2dRecursiveEditTool::~a2dRecursiveEditTool()
{
}

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

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

    //to world coordinates to do hit test in world coordinates
    double xw,yw;
    MouseToToolWorld( m_x, m_y, xw, yw );
    m_xwprev = xw;
    m_ywprev = yw;

    if ( event.Dragging() )
    {

    }
    else if ( event.Moving() && !GetBusy() )
    {
        a2dCanvasObject* hit = GetCanvasView()->IsHitWorld( xw, yw );                
        if ( hit && hit->GetDraggable() )
            GetCanvasView()->SetCursor( m_toolBusyCursor );
        else
            GetCanvasView()->SetCursor( m_toolcursor );

    }    

    if ( event.LeftDClick() )
    {
        if ( GetBusy() )
            FinishBusyMode();
        else 
            StopTool();
    }
    else if (event.LeftDown() && !GetBusy() )
    {
        // if there is a hit on a a2dCanvasObject, the editing starts on that object
        a2dIterC ic( GetCanvasView() );
        a2dIterCU cu( ic, m_corridor.GetInverseTransform() );
        a2dHitEvent hitevent = a2dHitEvent( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
        m_original = m_parentobject->ChildIsHitWorld( ic, hitevent );

        if ( !m_original.Get() )
            return; //no hit

        if ( !EnterBusyMode() )
            return; //not editable object

        RedirectToEditObject( event );
    }
    else if (event.LeftDown() && GetBusy() ) 
    {
        //maybe go to another object for editing, even subediting might 
        //have bin initiated in the a2dCanvasObject that is being edited.

        //goto the edit object itself, maybe for sub-editing.
        //Halted if sub-editing ( another tool is pushed on the tool stack )
        if ( RedirectToEditObject( event ) || m_stop || m_halted )
            return;

        //in case of not having a oneshot action, we can go to another object
        //while editing this one.
        if ( !m_oneshot )
        {
            a2dCanvasObject* neweditobject = NULL;
            a2dIterC ic( GetCanvasView() );
            a2dIterCU cu( ic, m_corridor.GetInverseTransform() );
            a2dHitEvent hitevent = a2dHitEvent( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
            neweditobject = m_parentobject->ChildIsHitWorld( ic, hitevent );

            if ( neweditobject == m_original || neweditobject == m_canvasobject)
                //nothing new, stay with the object until a double click.
                return;

            if ( !neweditobject )
            {
                if ( m_SingleClickToEnd )
                {
                    FinishBusyMode();
                    
                    a2dToolList::const_iterator iter = m_controller->GetToolList().begin();
                    iter++;

                    if ( iter != m_controller->GetToolList().end() )
                    {
                        //! test for subediting ( next tool is also editing tool )
                        a2dRecursiveEditTool *c = wxDynamicCast( (*iter).Get(), a2dRecursiveEditTool );
                        if (c)
                            StopTool();
                    }        
                }
                
                //nothing new, stay with the object until a double click.
                return;
            }

            if (!neweditobject->GetEditable() )
                return;

            //the other object is hit, and oke for editing
            //Stop the current one, and go to the new object
            FinishBusyMode();

            m_original = neweditobject;
        
            if ( !EnterBusyMode() )
                return;

            RedirectToEditObject( event );
        }
        else
        {
            a2dCanvasObject* neweditobject = NULL;
            a2dIterC ic( GetCanvasView() );
            a2dIterCU cu( ic, m_corridor.GetInverseTransform() );
            a2dHitEvent hitevent = a2dHitEvent( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
            neweditobject = m_parentobject->ChildIsHitWorld( ic, hitevent );

            if ( !neweditobject && !m_SingleClickToEnd || neweditobject == m_original || neweditobject == m_canvasobject)
                //nothing new so continue with current editobject
                return;

            StopTool();            
        }
    }
    else if (event.LeftUp() && GetBusy() ) 
    {
        if ( !RedirectToEditObject( event ) )
            event.Skip();
    }
    else if ( GetBusy() )
    {
        if ( !RedirectToEditObject( event ) )
            event.Skip();
    }
    else
    {
        event.Skip();
    }
}


void a2dRecursiveEditTool::OnComEvent( a2dComEvent& event )
{
    if (GetBusy())
    {
        if ( event.GetEventComId() == &a2dStTool::sm_toolBeforePush )
        {
            // If tool is busy, it will enter halted state    
            if ( GetBusy() && !m_halted )
            {
                m_halted = true;     
                CleanupToolObjects();
            }
            m_pending = true;
        }
        else if ( event.GetEventComId() == &a2dCanvasView::sm_changedShowObject )
        {
            a2dCanvasObject* newtop = wxStaticCast( event.GetProperty()->GetRefObject(), a2dCanvasObject );
            if ( newtop )
            {
                AbortBusyMode();
                a2dCorridor corridor;
                corridor.push_back( newtop );
                SetCorridor( corridor );
            }
            else
                StopTool();
        }
        else
            event.Skip();
    }

    event.Skip();
}


//! used to add object to a a2dCanvasDocument in the current parent
/*!

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_AddObjectToGroup: public a2dCommand
{

public:
    //! used to add object to a a2dCanvasDocument in the current parent
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_AddObjectToGroup( a2dMultiEditTool* tool = NULL, a2dCanvasObject* object = NULL );

    ~a2dCommand_AddObjectToGroup(void);

    bool Do();
    bool Undo();

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

    a2dCanvasObject *GetCanvasObject() { return m_canvasobject; }

protected:
    a2dCanvasObjectPtr m_canvasobject;
    a2dMultiEditTool* m_tool; 
};

//! used to release object from a a2dCanvasDocument in the current parent
/*!

    \ingroup commands
*/
class A2DCANVASDLLEXP a2dCommand_ReleaseObjectFromGroup: public a2dCommand
{
public:

    //! used to release object from a a2dCanvasDocument in the current parent
    /*! \ingroup commandid
    */
    static const a2dCommandId Id;

    a2dCommand_ReleaseObjectFromGroup( a2dMultiEditTool* tool = NULL, a2dCanvasObject* object = NULL );

    ~a2dCommand_ReleaseObjectFromGroup(void);

    bool Do();
    bool Undo();

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

protected:

    a2dCanvasObjectPtr m_canvasobject;
    int m_index;
    a2dMultiEditTool* m_tool; 
};

const a2dCommandId a2dCommand_AddObjectToGroup::Id( wxT("AddObjectToGroup") );
const a2dCommandId a2dCommand_ReleaseObjectFromGroup::Id( wxT("ReleaseObjectFromGroup") );

/*
*   a2dCommand_AddObjectToGroup
*/
a2dCommand_AddObjectToGroup::a2dCommand_AddObjectToGroup( a2dMultiEditTool* tool, a2dCanvasObject* object ):
a2dCommand( true, a2dCommand_AddObjectToGroup::Id )
{
    m_canvasobject = object;
    m_tool = tool;
}

a2dCommand_AddObjectToGroup::~a2dCommand_AddObjectToGroup(void)
{
}

bool a2dCommand_AddObjectToGroup::Do(void)
{
    m_tool->AddToGroup( m_canvasobject );
    return true;
}

bool a2dCommand_AddObjectToGroup::Undo(void)
{
    m_tool->RemoveFromGroup( m_canvasobject, 0 );
    return true;
}

/*
*   a2dCommand_ReleaseObjectFromGroup
*/
a2dCommand_ReleaseObjectFromGroup::a2dCommand_ReleaseObjectFromGroup( a2dMultiEditTool* tool, a2dCanvasObject *object ):
a2dCommand( true, a2dCommand_ReleaseObjectFromGroup::Id )
{
    m_canvasobject = object;
    //for undo preserve location
    m_index = 0;
    m_tool = tool;
}

a2dCommand_ReleaseObjectFromGroup::~a2dCommand_ReleaseObjectFromGroup(void)
{
}

bool a2dCommand_ReleaseObjectFromGroup::Do(void)
{
    m_tool->RemoveFromGroup( m_canvasobject, m_index );

    if ( m_index == -1 )
        a2dDocviewGlobals->ReportError( a2dError_canvasObjectRelease );

    return true;
}

bool a2dCommand_ReleaseObjectFromGroup::Undo(void)
{
    m_tool->AddToGroup( m_canvasobject );
    return true;
}


//----------------------------------------------------------------------------
// a2dMultiSelectGroup
//----------------------------------------------------------------------------
//! a2dRecursiveEditTool holds multiple edit object in here
/*! When this object is set pending also its child objects are set pending.

    \ingroup tools commands
*/
class A2DCANVASDLLEXP a2dMultiSelectGroup: public a2dCanvasObject
{
    A2D_DECLARE_EVENT_TABLE()

public:

    //!constructor
    a2dMultiSelectGroup();

    //!destructor
    ~a2dMultiSelectGroup(){};

    a2dMultiSelectGroup( const a2dMultiSelectGroup &other, CloneOptions options );

    a2dCanvasObject* CloneShallow();

    //! exact deep copy
    a2dObject* Clone( CloneOptions options ) const;

    virtual a2dCanvasObject* StartEdit( a2dBaseTool* tool, wxUint16 editmode, wxEditStyle editstyle = wxEDITSTYLE_COPY );

protected:

    virtual void RenderChildObjects( a2dIterC& ic, RenderChild& whichchilds, a2dAffineMatrix* tworld, OVERLAP clipparent );

    void OnCanvasObjectMouseEvent( a2dCanvasObjectMouseEvent& event );
    
    void OnHandleEvent(a2dHandleMouseEvent &event);


private:
    //!this is a not implemented copy constructor that avoids automatic creation of one
    a2dMultiSelectGroup( const a2dMultiSelectGroup &other );
};

template class A2DCANVASDLLEXP a2dSmrtPtr<a2dMultiSelectGroup>;


A2D_BEGIN_EVENT_TABLE( a2dMultiSelectGroup, a2dCanvasObject )
    A2D_EVT_CANVASOBJECT_MOUSE_EVENT( a2dMultiSelectGroup::OnCanvasObjectMouseEvent )
    A2D_EVT_CANVASHANDLE_MOUSE_EVENT( a2dMultiSelectGroup::OnHandleEvent )
A2D_END_EVENT_TABLE()

a2dMultiSelectGroup::a2dMultiSelectGroup():a2dCanvasObject()
{
    m_childobjects = new a2dCanvasObjectList();
}

a2dMultiSelectGroup::a2dMultiSelectGroup( const a2dMultiSelectGroup &other, CloneOptions options )
    :a2dCanvasObject( other, options )
{
}

a2dObject* a2dMultiSelectGroup::Clone( CloneOptions options ) const
{
    return new a2dMultiSelectGroup( *this, options );
}

a2dCanvasObject* a2dMultiSelectGroup::CloneShallow()
{
    a2dMultiSelectGroup* newgr = new a2dMultiSelectGroup();
    for( a2dCanvasObjectList::iterator iter = m_childobjects->begin(); iter != m_childobjects->end(); ++iter )
    {
        a2dCanvasObject *obj = *iter;
        newgr->Append( obj );
    }
    return newgr;
}

void a2dMultiSelectGroup::OnHandleEvent(a2dHandleMouseEvent &event)
{
    a2dIterC* ic = event.GetIterC();

    if ( m_flags.m_editingCopy && m_flags.m_editable )
    {
        a2dRestrictionEngine *restrictEngine = a2dCanvasGlobals->GetRestrictionEngine();

        a2dHandle* draghandle = event.GetCanvasHandle();

        //to world group coordinates to do hit test in world group coordinates
        double xw,yw;
        xw = event.GetX();
        yw = event.GetY();

        //matrix to convert from absolute world coordinates to local object coordinates,
        //with m_lworld included. 
        double xwi;
        double ywi;
        ic->GetInverseTransform().TransformPoint( xw, yw, xwi, ywi );

        bool __includeChildren__ = PROPID_IncludeChildren->GetPropertyValue( this );
        a2dBoundingBox untrans;
        if ( __includeChildren__ )
            untrans = GetUnTransformedBbox( a2dCANOBJ_BBOX_CHILDREN | a2dCANOBJ_BBOX_EDIT );
        else
            untrans = GetUnTransformedBbox( a2dCANOBJ_BBOX_EDIT );

        double xmin,ymin,xmax,ymax,w,h;
        xmin = untrans.GetMinX();
        ymin = untrans.GetMinY();
        xmax = untrans.GetMaxX();
        ymax = untrans.GetMaxY();
        w = untrans.GetWidth();
        h = untrans.GetHeight();

        a2dAffineMatrix origworld = m_lworld;
        double x1,y1,x2,y2;

        a2dCanvasObject* original = PROPID_Original->GetPropertyValue( this );

        if ( event.GetMouseEvent().LeftDown() )
        {
            if (restrictEngine )
                restrictEngine->SetRestrictPoint( xw, yw );
        }
        else if (event.GetMouseEvent().LeftUp() )
        {
            if ( m_lworld != original->GetTransformMatrix() )
            {
                for( a2dCanvasObjectList::iterator iter = original->GetChildObjectList()->begin(); iter != original->GetChildObjectList()->end(); iter++ )
                {
                    a2dCanvasObject* obj = *iter;
                    a2dAffineMatrix newtrans = m_lworld;
                    newtrans *= obj->GetTransformMatrix();
                    m_root->GetCommandProcessor()->Submit( new a2dCommand_SetCanvasProperty( obj, a2dCanvasObject::PROPID_TransformMatrix, newtrans ) );
                }                
                for( a2dCanvasObjectList::iterator iter2 = GetChildObjectList()->begin(); iter2 != GetChildObjectList()->end(); iter2++ )
                {
                    a2dCanvasObject* obj = *iter2;
                    if ( obj->GetBin2() )
                    {
                        a2dAffineMatrix newtrans = m_lworld;
                        newtrans *= obj->GetTransformMatrix();
                        obj->SetTransformMatrix( newtrans ); 
                    }
                }
                // matrix is set to children, now reset group matrix of editcopy (original is always identity matrix )
                SetTransformMatrix();
            }
        }
        else if ( event.GetMouseEvent().Dragging() )
        {
            if (restrictEngine )
                restrictEngine->RestrictPoint( xw, yw );
            ic->GetInverseTransform().TransformPoint( xw, yw, xwi, ywi );

            if ( draghandle->GetName() == wxT("handle1") )
            {
                //modify object
                double dx,dy;
                dx = xwi-xmin;
                dy = ywi-ymin;

                double sx;
                double sy;
                if ( w )
                    sx = (w-dx/2)/w;
                else
                    sx = 0;
                if ( h )
                    sy = (h-dy/2)/h;
                else
                    sy = 0;

                origworld.TransformPoint( xmax,ymax, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale(sx,sy);
                Transform( origworld );
                m_lworld.TransformPoint( xmax, ymax, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("handle2") )
            {
                //modify object
                double dx,dy;
                dx = xwi-xmin;
                dy = ywi-ymax;

                double sx;
                double sy;
                if ( w )
                    sx = (w-dx/2)/w;
                else
                    sx = 0;
                if ( h )
                    sy = (h+dy/2)/h;
                else
                    sy = 0;

                origworld.TransformPoint( xmax, ymin, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale(sx,sy);
                Transform( origworld );
                m_lworld.TransformPoint( xmax, ymin, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("handle3") )
            {
                //modify object
                double dx,dy;
                dx = xwi-xmax;
                dy = ywi-ymax;

                double sx;
                double sy;
                if ( w )
                    sx = (w+dx/2)/w;
                else
                    sx = 0;
                if ( h )
                    sy = (h+dy/2)/h;
                else
                    sy = 0;

                origworld.TransformPoint( xmin, ymin, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale(sx,sy);
                Transform( origworld );
                m_lworld.TransformPoint( xmin, ymin, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("handle4") )
            {
                //modify object
                double dx,dy;
                dx = xwi-xmax;
                dy = ywi-ymin;

                double sx;
                double sy;
                if ( w )
                    sx = (w+dx/2)/w;
                else
                    sx = 0;
                if ( h )
                    sy = (h-dy/2)/h;
                else
                    sy = 0;

                origworld.TransformPoint( xmin, ymax, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale(sx,sy);
                Transform( origworld );
                m_lworld.TransformPoint( xmin, ymax, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("rotate") )
            {
                double xr, yr;
                m_lworld.TransformPoint( xmin + w/2, ymin + h/2, xr, yr );

                //modify object
                double dx,dy;

                dx = xw - xr;
                dy = yw - yr;
                double angn;
                if (!dx && !dy)
                    angn=0;
                else
                    angn= wxRadToDeg(atan2(dy,dx));

                m_lworld = m_lworld.Rotate(angn-m_lworld.GetRotation(), xr, yr );

                //rotate.Translate( xr, yr);
                //rotate.Rotate(wxRadToDeg(-ang));
                //rotate.Translate( xr, yr);
                //Transform(rotate);
            }
            else if ( draghandle->GetName() == wxT("skewx") )
            {
                //modify object
                double dx,dy;

                dx = xwi-(xmin + w*3/4);
                dy = ywi-(ymin + h/2);

                origworld.TransformPoint( xmin + w/2, ymin + h/2, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                SkewX( wxRadToDeg(atan2(dx,dy)) );
                Transform( origworld );
                m_lworld.TransformPoint( xmin + w/2, ymin + h/2, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("skewy") )
            {
                //modify object
                double dx,dy;

                dx = xwi-(xmin + w/2);
                dy = ywi-(ymin + h*3/4);

                origworld.TransformPoint( xmin + w/2, ymin + h/2, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                SkewY( wxRadToDeg(atan2(dy,dx)) );
                Transform( origworld );
                m_lworld.TransformPoint( xmin + w/2, ymin + h/2, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("handle12") )
            {
                //modify object
                double dx;

                dx = xwi-xmin;

                double sx;
                if ( w )
                    sx = (w-dx/2)/w;
                else
                    sx = 0;

                origworld.TransformPoint( xmax, ymax, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale( sx, 1 );
                Transform( origworld );
                m_lworld.TransformPoint( xmax, ymax, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("handle23") )
            {
                //modify object
                double dy;

                dy = ywi-ymax;

                double sy;
                if ( h )
                    sy = (h+dy/2)/h;
                else
                    sy = 0;

                origworld.TransformPoint( xmax, ymin, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale( 1, sy );
                Transform( origworld );
                m_lworld.TransformPoint( xmax, ymin, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("handle34") )
            {
                //modify object
                double dx;

                dx = xwi-xmax;

                double sx;
                if ( w )
                    sx = (w+dx/2)/w;
                else
                    sx = 0;

                origworld.TransformPoint( xmin, ymin, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale( sx, 1 );
                Transform( origworld );
                m_lworld.TransformPoint( xmin, ymin, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else if ( draghandle->GetName() == wxT("handle41") )
            {
                //modify object
                double dy;

                dy = ywi - ymin;

                double sy;
                if ( h )
                    sy = (h-dy/2)/h;
                else
                    sy = 0;

                origworld.TransformPoint( xmin, ymax, x2, y2 );

                //reset matrix to identity
                SetTransformMatrix();
                Scale( 1, sy );
                Transform( origworld );
                m_lworld.TransformPoint( xmin, ymax, x1, y1 );
                Translate(x2-x1, y2-y1);
            }
            else
                event.Skip();
            SetPending( true );
        }
    }
}

void a2dMultiSelectGroup::OnCanvasObjectMouseEvent( a2dCanvasObjectMouseEvent& event )
{
    a2dIterC* ic = event.GetIterC();
    ic->SetPerLayerMode( false );

    if ( event.GetMouseEvent().RightDown() )
    {
        //wxWindow* win = ic->GetCanvasView()->GetDisplayWindow();
        //win->PopupMenu(mousemenu,event.GetX(), event.GetY()); 
        //wxLogDebug( wxT(" reached vertex curve with left down ") );
        a2dCanvasObjectMouseEvent popup( ic, this, wxEVT_CANVASOBJECT_POPUPMENU_EVENT, event.GetX(), event.GetY(), event.m_mouseevent );
        popup.SetEventObject( this );

        if ( !this->ProcessEvent( popup ) )
            event.Skip();
    }
    // editing of an object is based on the editcopy flag, which is only set at the top object of an editclone.
    // So the children of the object being edited does not have the flag set.
    else if ( m_flags.m_editingCopy && m_flags.m_editable  )
    {
        a2dRestrictionEngine *restrictEngine = a2dCanvasGlobals->GetRestrictionEngine();
        a2dCanvasObject* original = PROPID_Original->GetPropertyValue( this );
        a2dCanvasObject* parent = PROPID_Parent->GetPropertyValue( this );

        static double xshift;
        static double yshift;

        double xw,yw;
        xw = event.GetX();
        yw = event.GetY();

        double xh,yh;
        ic->GetInverseTransform().TransformPoint(xw, yw, xh, yh);

        if ( event.GetMouseEvent().Moving() )///&& m_flags.m_subEditAsChild )
        {
            ic->GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_HAND ) );
        }
        else if ( event.GetMouseEvent().LeftDClick()  )
        {
            // double click while the object is in edit mode (m_flags.m_editingCopy)
            // will result in stopping the oneshot edit tool.
            EndEdit();
        }
        else if (event.GetMouseEvent().LeftDown() )
        {
            // if the object is hit, we can test for sub editing of child objects.
            // The special case is the object called LABEL, which has priority.
            // Next candidate is the child hit.
            a2dHitEvent hitevent = a2dHitEvent( xw, yw, false );
            if ( IsHitWorld( *ic, hitevent ) )
            {
                if (restrictEngine )
                    restrictEngine->SetRestrictPoint( xw, yw );

                if ( 1 )
                {
                    a2dCanvasObject* hit = NULL;
                    if ( hit && hit->GetEditable()) //subediting of child or labels, is we have a hit.
                    {
                        a2dIterCU cu( *ic, original );
                        a2dToolContr* controller = wxStaticCast( PROPID_Controller->GetPropertyValue( this ).Get(), a2dToolContr );               

                        //editing is always a oneshot, since editing of children here is under control of the
                        //a2dCanvasObject (can be different for derived classes). So editing tool should not take over 
                        //the decision to edit one after another child.
                        ic->SetCorridorPath( true, NULL );
                        controller->StartEditingObject( hit, *ic );
                    }
                    //subediting was not wanted or hit, therefore now start dragging the object itself
                    //at mouse LeftDown
                    else if ( IsDraggable() )
                    {
                        // Corridor is already in place, since edit tool is active.
                        // Set corridor captured on this object, in order to drag.
                        ic->SetCorridorPathCaptureObject( this );
                        xshift = GetPosX()-xh;
                        yshift = GetPosY()-yh;
                    }
                }
            }
            // left down and no hit on this object, while the object is in edit mode (m_flags.m_editingCopy)
            // will result in stopping the oneshot edit tool.
            else
            {
                EndEdit();
            }
        }
        else if (event.GetMouseEvent().LeftUp() && ic->GetCanvasView()->GetCaptured() )
        {
            // the corridor was captured at Left Down.
            ic->SetCorridorPathCaptureObject( NULL );
            ic->GetCanvasView()->GetCanvas()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_HAND ) );
        
            if ( original->GetTransformMatrix() != m_lworld )
            {
                for( a2dCanvasObjectList::iterator iter = original->GetChildObjectList()->begin(); iter != original->GetChildObjectList()->end(); iter++ )
                {
                    a2dCanvasObject* obj = *iter;
                    a2dAffineMatrix newtrans = m_lworld;
                    newtrans *= obj->GetTransformMatrix();
                    m_root->GetCommandProcessor()->Submit( new a2dCommand_SetCanvasProperty( obj, a2dCanvasObject::PROPID_TransformMatrix, newtrans ) );
                }
                for( a2dCanvasObjectList::iterator iter2 = GetChildObjectList()->begin(); iter2 != GetChildObjectList()->end(); iter2++ )
                {
                    a2dCanvasObject* obj = *iter2;
                    if ( obj->GetBin2() )
                    {
                        a2dAffineMatrix newtrans = m_lworld;
                        newtrans *= obj->GetTransformMatrix();
                        obj->SetTransformMatrix( newtrans ); 
                    }
                }
                // matrix is set to children, now reset group matrix of editcopy (original is always identity matrix )
                SetTransformMatrix();
            }
        }
        else if ( IsDraggable() && event.GetMouseEvent().Dragging() && ic->GetCanvasView()->GetCaptured() )
        {
            double x,y;
            x = xh + xshift;
            y = yh + yshift;

            if(restrictEngine)
            {    
                //temporarily restore position according to the mouse position, which is the unrestricted position.
                SetPosXY( x, y );

                a2dPoint2D point;
                double dx, dy; //detect restriction distance of any point.
                if ( restrictEngine->RestrictCanvasObjectAtVertexes( this, point, dx, dy ) )
                {
                    //restrict the object drawing to that point
                    x += dx;
                    y += dy;
                }
            }
            SetPosXY( x, y );
        }
        else
            event.Skip();
    }
    else
        event.Skip();
    
}
void a2dMultiSelectGroup::RenderChildObjects( a2dIterC& ic, RenderChild& whichchilds, a2dAffineMatrix* WXUNUSED(tworld), OVERLAP clipparent )
{
    //ic.GetDrawer2D()->SetDrawStyle( a2dWIREFRAME_INVERT_ZERO_WIDTH );
    ic.GetDrawer2D()->SetDrawStyle( a2dWIREFRAME_ZERO_WIDTH );
    a2dCanvasObject::RenderChildObjects( ic, whichchilds, clipparent );
    //ic.GetDrawer2D()->SetDrawStyle( a2dFILLED );
}

a2dCanvasObject* a2dMultiSelectGroup::StartEdit( a2dBaseTool* tool, wxUint16 editmode, wxEditStyle editstyle )
{
    if ( m_flags.m_editable )
    {
        a2dCanvasObjectPtr editcopy;

        if( editstyle & wxEDITSTYLE_CONNECTED )
            editcopy = TClone( clone_flat | clone_seteditcopy | clone_setoriginal | clone_reconnectable );
        else
            editcopy = TClone( clone_flat | clone_seteditcopy | clone_setoriginal );

        editcopy->DoConnect( false );
        SetSnapTo( false );
        editcopy->SetSnapTo( false );
        SetSelected( false );
        editcopy->SetSelected( false ); 

        if ( ! PROPID_Allowrotation->GetPropertyValue( this ) )
            PROPID_Allowrotation->SetPropertyToObject( editcopy, true );
        if ( ! PROPID_Allowsizing->GetPropertyValue( this ) )
            PROPID_Allowsizing->SetPropertyToObject( editcopy, true );
        if ( ! PROPID_Allowskew->GetPropertyValue( this ) )
            PROPID_Allowskew->SetPropertyToObject( editcopy, true );
        PROPID_Parent->SetPropertyToObject( editcopy, tool->GetParentObject() );
        editcopy->SetEditingRender( true );

        editcopy->Update( updatemask_force );

        m_flags.m_editing = true;

        PROPID_Editmode->SetPropertyToObject( editcopy, editmode );
        PROPID_Editstyle->SetPropertyToObject( editcopy, (wxUint16) editstyle );
         
        //the next maybe overruled in derived class
        PROPID_IncludeChildren->SetPropertyToObject( editcopy, true );
        PROPID_Controller->SetPropertyToObject( editcopy, tool->GetToolController() );
        PROPID_ViewSpecific->SetPropertyToObject( editcopy, tool->GetCanvasView() );
        //new start edit, so no event yet
        PROPID_FirstEventInObject->SetPropertyToObject( editcopy, true );

        if ( !editcopy->DoStartEdit( editmode, editstyle ) )
        {
            EndEdit();
            return NULL;
        }

        // Add the editcopy to the parent and set some flags
        tool->AddEditobject( editcopy );

        return editcopy;
    }

    return NULL;
}

IMPLEMENT_CLASS(a2dMultiEditTool, a2dObjectEditTool)

A2D_BEGIN_EVENT_TABLE(a2dMultiEditTool,a2dObjectEditTool)
    A2D_EVT_COM_EVENT( a2dMultiEditTool::OnComEvent )
    A2D_EVT_MOUSE_EVENTS(a2dMultiEditTool::OnMouseEvent)
    A2D_EVT_IDLE( a2dMultiEditTool::OnIdle )
    A2D_EVT_CHAR( a2dMultiEditTool::OnChar )
    A2D_EVT_UNDO( a2dMultiEditTool::OnUndoEvent )
    A2D_EVT_REDO( a2dMultiEditTool::OnRedoEvent )
A2D_END_EVENT_TABLE()

a2dMultiEditTool::a2dMultiEditTool(a2dStToolContr* controller ):a2dObjectEditTool(controller)
{
    a2dDocviewGlobals->GetEventDistributer()->Register( this );
    GetCanvasView()->SetMouseEvents(false);
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_PENCIL );
    m_oneshot = false;
}

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

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

void a2dMultiEditTool::DoStopTool( bool abort ) 
{ 
    a2dCanvasObjectPtr keepit = m_canvasobject;

//  m_controller->SetEvtHandlerEnabled( false );
//  SetEvtHandlerEnabled( false );

    a2dBaseTool::DoStopTool( abort );

    if ( GetCanvasView() )
        GetCanvasView()->GetCanvasDocument()->AddPendingUpdatesOldNew();

    m_parentobject->SetSpecificFlags( false, a2dCanvasOFlags::HighLight );

//  SetEvtHandlerEnabled( true );
//  m_controller->SetEvtHandlerEnabled( true );
}

bool a2dMultiEditTool::AddToGroup( a2dCanvasObject* canvasobject )
{
    a2dAffineMatrix inverse = m_canvasobject->GetTransformMatrix();
    inverse.Invert();
    canvasobject->Transform( inverse );
    m_original->Append( canvasobject );
    m_canvasobject->Append( canvasobject );
    m_canvasobject->Update( a2dCanvasObject::updatemask_force );
    m_canvasobject->ReStartEdit( 0 );
    return true;
}

bool a2dMultiEditTool::RemoveFromGroup( a2dCanvasObject* canvasobject, int index )
{
    m_canvasobject->ReleaseChild( canvasobject, false, false, true );
    m_original->ReleaseChild( canvasobject, false, false, true );
    m_canvasobject->Update( a2dCanvasObject::updatemask_force );
    m_original->Update( a2dCanvasObject::updatemask_force );
    m_canvasobject->ReStartEdit( 0 );
    return true;
}

void a2dMultiEditTool::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 = GetDrawer2D()->DeviceToWorldX( m_x );
    double yw = GetDrawer2D()->DeviceToWorldY( m_y );
    m_xwprev = xw;
    m_ywprev = yw;

    if ( event.Moving() && !GetBusy() )
    {
        if ( GetCanvasView()->IsHitWorld( xw, yw ) )
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_HAND ) );
        else
                GetCanvasView()->SetCursor( a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  ) );

    }

    if (event.LeftDown() && !GetBusy() )
    {
        a2dCanvasObject* hitobject = GetCanvasView()->IsHitWorld( xw,yw );

        if ( !hitobject )
            return;

        a2dAffineMatrix inverse = hitobject->GetTransformMatrix();
        m_original = new a2dMultiSelectGroup();
        m_original->Append( hitobject );
        m_original->SetVisible( false );

        if ( !EditStart() )
            return;

        RedirectToEditObject( event );

    }
    else if (event.LeftDown() && GetBusy() ) 
    {
        a2dCanvasObject* hitobject = NULL;
        hitobject = GetCanvasView()->IsHitWorld( xw,yw );

        if ( hitobject == m_canvasobject || hitobject == m_original )
        {
            //test the edit copy object, to test on handles
            a2dAffineMatrix selectworld = m_original->GetTransformMatrix();
            a2dIterC ic( GetCanvasView() );
            a2dIterCU cu( ic, selectworld );
            a2dHitEvent hitevent = a2dHitEvent( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
            hitobject = m_canvasobject->ChildIsHitWorld( ic, hitevent );
            if ( hitobject )
            {
                if ( !event.m_shiftDown )
                {
                    RedirectToEditObject( event );
                }
                else 
                {   //remove object hit from selection by setting its bin flag off 
                    if ( m_original->Find( hitobject ) )
                    {
                        a2dCanvasDocument *doc = GetCanvasView()->GetCanvasDocument();
                        doc->GetCommandProcessor()->Submit( new a2dCommand_ReleaseObjectFromGroup( this, hitobject ) );
                    }
                }
                return;
            }
        }

        {   
            //no hit in selection
            if ( !m_oneshot )
            {
                hitobject = GetCanvasView()->IsHitWorld( xw,yw );

                if ( !hitobject )
                {   //nothing new so continue with current editobject
                    RedirectToEditObject( event );
                    return;
                }

                if (!hitobject->GetEditable() || hitobject == m_canvasobject )
                {
                    return;
                }
           
                if ( event.m_shiftDown ) //user wants to add object to the  multigroup
                {
                    a2dCanvasDocument *doc = GetCanvasView()->GetCanvasDocument();
                    doc->GetCommandProcessor()->Submit( new a2dCommand_AddObjectToGroup( this, hitobject ) );
                }
                else
                {   
                }
            }
            else
            {
                FinishBusyMode();
                //RedirectToEditObject( event );
            }
        }
    }
    else if ( event.LeftDClick() && GetBusy() )
    {
        if ( GetBusy() )
            FinishBusyMode();
        else 
            StopTool();
    }
    else if ( GetBusy() )
    {
        if ( event.RightDown() )
            event.Skip();
        else
            RedirectToEditObject( event );
    }
    else
    {
        event.Skip();
    }
}

bool a2dMultiEditTool::RedirectToEditObject( wxMouseEvent& event )
{
    if ( !m_original->GetFlag( a2dCanvasOFlags::Editing ) )
        return false;
    
    bool isHit;
    bool processed = false;

    int margin = a2dCanvasGlobals->GetHitMarginDevice();

    a2dAffineMatrix cWorld;

    processed = GetCanvasView()->ProcessCanvasObjectEvent( event, isHit, m_xwprev, m_ywprev, margin );

    wxPoint pos = m_stcontroller->GetMousePosition();
    GetCanvasView()->UpdateCrossHair( pos.x, pos.y );

    //the event did stop the editing of the object 
    if ( m_original && !m_original->GetFlag( a2dCanvasOFlags::Editing ) )
    {
        if ( m_halted )
            CleanupToolObjects();
        else
            FinishBusyMode();
    }

    return processed;
}

bool a2dMultiEditTool::StartEditing( a2dCanvasObject* startobject )
{
    m_original = new a2dMultiSelectGroup();
    m_original->Append( startobject );
    m_original->SetVisible( false );
    EditStart();
    return true;
}

bool a2dMultiEditTool::StartEditingSelected()
{
    a2dCanvasObjectList* objects = m_parentobject->GetChildObjectList();
    a2dCanvasObjectList* objs = objects->Clone( a2dCanvasOFlags::SELECTED, a2dObject::clone_flat );

    m_original = new a2dMultiSelectGroup();
    m_original->SetVisible( false );
    forEachIn( a2dCanvasObjectList, objs )
    {
        a2dCanvasObject *obj = *iter;
        m_original->Append( obj );
    }
    delete objs;
    EditStart();
    return true;
}

bool a2dMultiEditTool::EditStart()
{
    //temporary add the a2dMultiSelectGroup object for editing the group.
    m_parentobject->Append( m_original );  
    
    //to be able to do mouse hits already bbox's need to be up to date.
    m_original->Update( a2dCanvasObject::updatemask_force );

    //m_original->SetFill( a2dTRANSPARENT_FILL );
    //m_original->SetStroke( a2dCanvasGlobals->GetHandle()->GetStroke() );

    EnterBusyMode();

    return true;
}

void a2dMultiEditTool::CleanupToolObjects()
{
    SetEditObject( NULL );

    if ( GetBusy() )
    {
        if ( m_original->GetFlag( a2dCanvasOFlags::Editing ) )
            m_canvasobject->EndEdit();

        if ( GetCanvasView() ) //in case of destruction this is set to NULL
            GetCanvasView()->SetCursor(*wxSTANDARD_CURSOR);

        m_original->SetSelected( m_preserve_select );
        a2dCanvasObjectList* objects = m_original->GetChildObjectList();
        
        a2dCanvasDocument *doc = GetCanvasView()->GetCanvasDocument();
        doc->GetCommandProcessor()->GetCurrentGroup()->ClearCommandsById( a2dCommand_AddObjectToGroup::Id );
        doc->GetCommandProcessor()->GetCurrentGroup()->ClearCommandsById( a2dCommand_ReleaseObjectFromGroup::Id );

        m_parentobject->ReleaseChild( m_original, false, false, true );

        m_original->AdjustPinLocation();
        m_connectedwirecopies.UpdateImmediate( true, this );
        
        if ( !m_halted )
            CloseCommandGroup();

        if (m_disableOtherViews && GetCanvasView() ) 
        {
            GetCanvasView()->GetCanvasDocument()->EnableAllViews( true, GetCanvasView() );
        }
    }
    a2dStTool::CleanupToolObjects();

    m_connectedwirecopies.clear();
    m_original = 0;
    m_canvasobject = 0;
}

void a2dMultiEditTool::OnIdle( wxIdleEvent &event )
{
    if ( m_original )
    {
        if ( m_pending )
        {  
            //m_editobject->SetPending( true );    
            //m_pending = false;
        }
    }
    else
        a2dStTool::OnIdle( event );
}

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

void a2dMultiEditTool::OnComEvent( a2dComEvent& event )
{
    event.Skip();
}


void a2dMultiEditTool::SetActive(bool active)
{
    if ( active )
    {
        if ( m_halted )
        {
            m_halted = false;  
            //RESTART editing so the edit copy becomes updated from the original.
            //original may have changed because of sub-editing of child objects.
            CreateToolObjects();
            m_active = true;
        }
        m_pending = true;
        a2dBaseTool::SetActive( active );
    }
    else
    {
        //the subedit or other subtools should not influence style of the object.
        //When this tool is activated again, the CurrentCanvasObject is set right again.
        //SetEditObject( NULL );

        m_pending = true;
        a2dBaseTool::SetActive( active );
    }
}

void a2dMultiEditTool::OnUndoEvent( a2dCommandProcessorEvent& WXUNUSED(event) )
{
    if (GetBusy() && !m_halted )
    {
        // recreate edit copies so the edit copy becomes updated from the original.
        wxUint16 editmode = a2dCanvasObject::PROPID_Editmode->GetPropertyValue( m_canvasobject );
        ReStartEdit( editmode );
    }
}

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




//----------------------------------------------------------------------------
// a2dObjectEditTool
//----------------------------------------------------------------------------



DEFINE_EVENT_TYPE( a2dObjectEditTool::sm_toolStartEditObject )

IMPLEMENT_CLASS(a2dObjectEditTool, a2dStTool)

const a2dCommandId a2dObjectEditTool::COMID_PushTool_ObjectEdit( wxT("PushTool_ObjectEdit") );

A2D_BEGIN_EVENT_TABLE(a2dObjectEditTool,a2dStTool)
    A2D_EVT_COM_EVENT( a2dObjectEditTool::OnComEvent )
    A2D_EVT_MOUSE_EVENTS(a2dObjectEditTool::OnMouseEvent)
    A2D_EVT_IDLE( a2dObjectEditTool::OnIdle )
    A2D_EVT_CHAR( a2dObjectEditTool::OnChar )
    A2D_EVT_UNDO( a2dObjectEditTool::OnUndoEvent )
    A2D_EVT_REDO( a2dObjectEditTool::OnRedoEvent )
    A2D_EVT_DO( a2dRecursiveEditTool::OnDoEvent )
    A2D_EVT_KEY_UP( a2dObjectEditTool::OnKeyUp)
    A2D_EVT_KEY_DOWN( a2dObjectEditTool::OnKeyDown)
A2D_END_EVENT_TABLE()

a2dObjectEditTool::a2dObjectEditTool(a2dStToolContr* controller, a2dIterC& ic, int editmode, bool SingleClickToEnd )
    :a2dStTool(controller)
{
    m_mode = editmode;

    GetCanvasView()->SetMouseEvents(false);
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_PENCIL );
    m_canvasobject = 0;
    m_halted = false;
    m_oneshot = true;
    m_triggerRestart = false;

    m_SingleClickToEnd = SingleClickToEnd;

    m_disableOtherViews = false;//true;

    // overrule corridor of base class setting, which is based on the view is less flexible, 
    // matrixes calculated might not contain all in case of complex object in corridor.
    SetContext( ic, NULL );
}

a2dObjectEditTool::a2dObjectEditTool(a2dStToolContr* controller, int editmode, bool SingleClickToEnd )
    :a2dStTool(controller)
{
    m_corridor = a2dCorridor( *GetCanvasView() );   
    m_parentobject = m_corridor.back();

    m_original = NULL;
    m_mode = editmode;

    GetCanvasView()->SetMouseEvents(false);
    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_PENCIL );
    m_canvasobject = 0;
    m_halted = false;
    m_oneshot = true;
    m_triggerRestart = false;

    m_SingleClickToEnd = SingleClickToEnd;

    m_disableOtherViews = false;//true;

    if ( m_parentobject != GetCanvasView()->GetShowObject() )
        m_parentobject->SetSpecificFlags( true, a2dCanvasOFlags::HighLight );
}

bool a2dObjectEditTool::SetContext( a2dIterC& ic, a2dCanvasObject* objectToEdit )
{
    m_corridor = a2dCorridor( ic );   
    m_parentobject = m_corridor.back();

    StartToEdit( objectToEdit );

    // add captured editclone too
    m_corridor = a2dCorridor( ic );   

    return true;
}

void a2dObjectEditTool::StartToEdit( a2dCanvasObject* objectToEdit )
{
    m_original = objectToEdit;

    if ( m_parentobject != GetCanvasView()->GetShowObject() )
        m_parentobject->SetSpecificFlags( true, a2dCanvasOFlags::HighLight );

    bool ret = true;
    if ( m_original )
        ret = EnterBusyMode();

    wxASSERT_MSG( !objectToEdit || (objectToEdit && m_canvasobject), _("wanted object can not be edited") );

    // todo ic.SetCorridorPathCaptureObject( m_canvasobject );
}

a2dObjectEditTool::~a2dObjectEditTool()
{
    if ( GetCanvasView() )
        GetCanvasView()->SetMouseEvents(true);
}

void a2dObjectEditTool::SetEditObject( a2dCanvasObject* objectToEdit )
{
    a2dCanvasDocument *doc = GetCanvasView()->GetCanvasDocument();
    // Set the style of the documents command-processor to the style of this tool
    if ( doc ) 
    {
        a2dComEvent event( this, objectToEdit, &sm_toolComEventSetEditObject );
        ProcessEvent( event );
    }   
}

void a2dObjectEditTool::SetMode( int mode )
{
    m_canvasobject->EndEdit();
    GetCanvasView()->Update( a2dCANVIEW_UPDATE_OLDNEW );

    m_mode = mode;
    if (m_mode > 2) m_mode = 0;

    CreateToolObjects();
}

void a2dObjectEditTool::DoStopTool( bool abort ) 
{
    a2dCanvasObjectPtr keepit = m_canvasobject;

//  m_controller->SetEvtHandlerEnabled( false );
//  SetEvtHandlerEnabled( false );

    a2dBaseTool::DoStopTool( abort );

    if ( GetCanvasView() )
        GetCanvasView()->GetCanvasDocument()->AddPendingUpdatesOldNew();

    m_parentobject->SetSpecificFlags( false, a2dCanvasOFlags::HighLight );

//  SetEvtHandlerEnabled( true );
//  m_controller->SetEvtHandlerEnabled( true );
}

void a2dObjectEditTool::AdjustRenderOptions()
{
    switch( m_stcontroller->GetDragMode() )
    {
    case wxDRAW_RECTANGLE:
        m_renderOriginal = true;
        m_renderEditcopy = false;
        m_renderEditcopyOnTop = false;
        m_renderEditcopyEdit = true;
        m_renderEditcopyRectangle = false;
        break;

    case wxDRAW_ONTOP:
        m_renderOriginal = false;
        m_renderEditcopy = false;
        m_renderEditcopyOnTop = true;
        m_renderEditcopyEdit = false;
        m_renderEditcopyRectangle = false;
        break;

    case wxDRAW_REDRAW:
        wxASSERT_MSG( 0, _("m_renderEditcopy is not yet implemented, m_renderEditcopyOnTop used instead") );
        m_renderOriginal = false;
        m_renderEditcopy = false;
        m_renderEditcopyOnTop = true;
        m_renderEditcopyEdit = false;
        m_renderEditcopyRectangle = false;
        break;
    default:
    ;
    }
}

bool a2dObjectEditTool::EnterBusyMode()
{
    return a2dStTool::EnterBusyMode();
}

void a2dObjectEditTool::FinishBusyMode()
{
    if (m_oneshot && !m_halted )
    {
        m_parentobject->SetSpecificFlags( false, a2dCanvasOFlags::HighLight );
    }
    a2dStTool::FinishBusyMode();
}

void a2dObjectEditTool::AbortBusyMode()
{
    a2dStTool::AbortBusyMode();
}

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

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

    //to world coordinates to do hit test in world coordinates
    double xw,yw;
    MouseToToolWorld( m_x, m_y, xw, yw );
    m_xwprev = xw;
    m_ywprev = yw;

    if ( event.Dragging() )
    {

    }

    if ( event.LeftDClick() )
    {
        if ( GetBusy() )
            FinishBusyMode();
        else 
            StopTool();
    }
    else if (event.LeftDown() && GetBusy() ) 
    {
        //goto the edit object itself, maybe for sub-editing.
        //Halted if sub-editing ( another tool is pushed on the tool stack )
        if ( RedirectToEditObject( event ) || m_stop || m_halted )
            return;

        // if left down was not handle inside object that is being edited,
        // that should lead to an end edit of the object, if the hit is outside the object.
        a2dCanvasObject* neweditobject = NULL;
        a2dIterC ic( GetCanvasView() );
        a2dIterCU cu( ic, m_corridor.GetInverseTransform() );
        a2dHitEvent hitevent = a2dHitEvent( xw, yw, false, a2dCANOBJHITOPTION_LAYERS );
        neweditobject = m_parentobject->ChildIsHitWorld( ic, hitevent );

        if ( !neweditobject && !m_SingleClickToEnd || neweditobject == m_original || neweditobject == m_canvasobject)
            //nothing new so continue with current editobject
            return;

        StopTool();      
    }
    else if (event.LeftUp() && GetBusy() ) 
    {
        if ( !RedirectToEditObject( event ) )
            event.Skip();
    }
    else if ( GetBusy() )
    {
        if ( !RedirectToEditObject( event ) )
            event.Skip();
    }
    else
    {
        event.Skip();
    }
}

bool a2dObjectEditTool::RedirectToEditObject( wxMouseEvent& event )
{
    if ( !m_original->GetFlag( a2dCanvasOFlags::Editing ) )
        return false;
    
    bool isHit;
    bool processed = false;

    int margin = a2dCanvasGlobals->GetHitMarginDevice();

    // the next NOT to tool world but to view world coordinates, since the event is going 
    // from ShowObject all the way down.
    double xw = GetDrawer2D()->DeviceToWorldX(m_x);
    double yw = GetDrawer2D()->DeviceToWorldY(m_y);
    processed = GetCanvasView()->ProcessCanvasObjectEvent( event, isHit, xw, yw, margin );

    if ( m_canvasobject )
    {
        m_canvasobject->AdjustPinLocation();
        m_connectedwirecopies.UpdateImmediate( false, this, m_canvasobject );
    }

    wxPoint pos = m_stcontroller->GetMousePosition();
    GetCanvasView()->UpdateCrossHair( pos.x, pos.y );

    //the event did stop the editing of the object 
    // This may be because the object inside decided to stop editing,
    // OR it started pushing another subediting tool, and this tool should 
    // continue later.
    if ( m_original && !m_original->GetFlag( a2dCanvasOFlags::Editing ) )
    {
        if ( m_halted )
            CleanupToolObjects();
        else
            FinishBusyMode();
    }
    return processed;
}

bool a2dObjectEditTool::ReStartEdit( wxUint16 editmode )
{
    m_canvasobject->Update( a2dCanvasObject::updatemask_force );
    m_original->Update( a2dCanvasObject::updatemask_force );
    SetEditObject( NULL );

    if ( GetBusy() )
    {
        if ( m_original->GetFlag( a2dCanvasOFlags::Editing ) )
            m_canvasobject->EndEdit();

        m_original->AdjustPinLocation();
        m_connectedwirecopies.UpdateImmediate( true, this );       
    }
    a2dStTool::CleanupToolObjects();

    m_connectedwirecopies.clear();
    m_canvasobject = 0;

    m_mode = editmode;

    return CreateToolObjects();
}

bool a2dObjectEditTool::CreateToolObjects()
{
    AdjustRenderOptions();
    m_original->SetVisible( m_renderOriginal );

    m_preserve_select = m_original->GetSelected();
    
    m_canvasobject = m_original->StartEdit( this, m_mode, wxEDITSTYLE_COPY | wxEDITSTYLE_CONNECTED );

    if ( !m_canvasobject )
        return false; //not editable object

#ifdef EDITBUF
    m_original->SetVisible( false );
    GetCanvasView()->Update( a2dCANVIEW_UPDATE_PENDING | a2dCANVIEW_UPDATE_AREAS | a2dCANVIEW_UPDATE_BLIT );
    GetCanvasDocument()->SetUpdatesPending( false );
    GetCanvasView()->SetDocumentDrawStyle(  RenderTOOL_OBJECTS );
    GetCanvasDocument()->SetIgnorePendingObjects( true );
#endif
    //! event to make it possible to set style in for instance modeless style dialog 
    a2dComEvent event( this, m_original, &sm_toolStartEditObject );
    ProcessEvent( event );

    // Collect and clone the connected wires
    a2dCanvasObjectList connectedwires;
    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.
    // When object itself sets the original invisible, that has priority. This is used in ediitng text,
    // where original visible is not wanted.
    if ( m_original->GetVisible() ) 
        m_original->SetVisible( m_renderOriginal );
    connectedwires.SetSpecificFlags( m_renderOriginal, a2dCanvasOFlags::VISIBLE );

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

    //we have a hit on an object to be edited
    GetCanvasView()->SetCursor(m_toolcursor);

    a2dCanvasDocument *doc = GetCanvasView()->GetCanvasDocument();

    SetEditObject( m_original );

    if (m_disableOtherViews)
        GetCanvasView()->GetCanvasDocument()->EnableAllViews( false, GetCanvasView() );

    return true;
}

void a2dObjectEditTool::CleanupToolObjects()
{
    SetEditObject( NULL );

    if ( GetBusy() )
    {
        if ( m_original->GetFlag( a2dCanvasOFlags::Editing ) )
            m_canvasobject->EndEdit();

        if ( GetCanvasView() ) //in case of destruction this is set to NULL
            GetCanvasView()->SetCursor(*wxSTANDARD_CURSOR);

        m_original->SetSelected( m_preserve_select );

        m_original->AdjustPinLocation();
        m_connectedwirecopies.UpdateImmediate( true, this );
        
        if ( !m_halted )
            CloseCommandGroup();

#ifdef EDITBUF
        GetCanvasView()->SetDocumentDrawStyle( RenderLAYERED | a2dCanvasGlobals->GetSelectDrawStyle()  );
        GetCanvasDocument()->SetIgnorePendingObjects( false );
#endif

        if (m_disableOtherViews && GetCanvasView() ) 
        {
            GetCanvasView()->GetCanvasDocument()->EnableAllViews( true, GetCanvasView() );
        }
    }
    a2dStTool::CleanupToolObjects();

    m_connectedwirecopies.clear();
    m_canvasobject = 0;
}

void a2dObjectEditTool::Render()
{
    if ( m_original && GetBusy())
    {
        // Render edit objects in Edit mode
        //if( m_renderEditcopyEdit )
        {
            if ( m_useEditOpaque == a2dOpaqueMode_Tool )
            {
                GetCanvasView()->GetDrawer2D()->SetOpacityFactor( m_editOpacityFactor );
                GetCanvasView()->RenderTopObject( RenderTOOL_OBJECTS_STYLED, 0 );                     
                GetCanvasView()->GetDrawer2D()->SetOpacityFactor( 255 );
            }
            else if ( m_useEditOpaque == a2dOpaqueMode_Tool_FixedStyle )
            {
                a2dFill fill = *a2dTRANSPARENT_FILL;
                a2dStroke stroke = a2dCanvasGlobals->GetHandle()->GetStroke();
                GetCanvasView()->GetDrawer2D()->SetOpacityFactor( m_editOpacityFactor );
                GetCanvasView()->SetFixedStyleFill( fill );
                GetCanvasView()->SetFixedStyleStroke( stroke );
                GetCanvasView()->RenderTopObject( RenderTOOL_OBJECTS, 0 );                    
                GetCanvasView()->GetDrawer2D()->SetOpacityFactor( 255 );
            }
            else if (  m_useEditOpaque == a2dOpaqueMode_Controller && m_stcontroller->GetUseOpaqueEditcopy() )
            {
                GetCanvasView()->GetDrawer2D()->SetOpacityFactor( m_stcontroller->GetOpacityFactorEditcopy() );
                GetCanvasView()->RenderTopObject( RenderTOOL_OBJECTS_STYLED, 0 );                     
                GetCanvasView()->GetDrawer2D()->SetOpacityFactor( 255 );
            }
            else //if ( m_useEditOpaque == a2dOpaqueMode_Off )
            {
                a2dFill fill = *a2dTRANSPARENT_FILL;
                a2dStroke stroke = a2dCanvasGlobals->GetHandle()->GetStroke();
                GetCanvasView()->GetDrawer2D()->SetOpacityFactor( 255 );
                GetCanvasView()->SetFixedStyleFill( fill );
                GetCanvasView()->SetFixedStyleStroke( stroke );
                GetCanvasView()->RenderTopObject( RenderTOOL_OBJECTS, 0 );                    
            }
        }       
    }
}

void a2dObjectEditTool::TriggerReStartEdit( wxUint16 editmode )
{
    m_triggerRestart = true;
}

void a2dObjectEditTool::OnIdle( wxIdleEvent &event )
{
    if ( m_triggerRestart && GetBusy() && !m_halted )
    {
        // recreate edit copies so the edit copy becomes updated from the original.
        wxUint16 editmode = a2dCanvasObject::PROPID_Editmode->GetPropertyValue( m_canvasobject );
        ReStartEdit( editmode );
        m_triggerRestart = false;
    }

#ifdef EDITBUF
    if ( m_canvasobject )
        if ( m_canvasobject->GetPending() )
            GetCanvasView()->AddPendingObject( m_canvasobject );
#endif

    if ( m_original )
    {
        if ( m_pending )
        {  
            //m_canvasobject->SetPending( true );    
            //m_pending = false;
        }
    }
    else
        a2dStTool::OnIdle( event );
}

void a2dObjectEditTool::OnKeyDown(wxKeyEvent& event)
{
    //all text like keys should arrive in a text object when its edited.
    event.Skip();
}

void a2dObjectEditTool::OnKeyUp(wxKeyEvent& event)
{
    if (GetBusy() && m_pending )
    {
        switch(event.GetKeyCode())
        {
            case WXK_UP:
            case WXK_DOWN:
            case WXK_LEFT:
            case WXK_RIGHT:
            {
                a2dCanvasDocument *doc = GetCanvasView()->GetCanvasDocument();
                doc->GetCommandProcessor()->Submit( 
                    new a2dCommand_SetCanvasProperty( m_original, a2dCanvasObject::PROPID_TransformMatrix, 
                    m_canvasobject->GetTransformMatrix() ) );

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

void a2dObjectEditTool::OnChar(wxKeyEvent& event)
{
    if (GetBusy())
    {
        switch(event.GetKeyCode())
        {
            case WXK_ESCAPE:
            {
                StopTool();
            }
            break;
            case WXK_TAB:
            {
                if ( event.m_shiftDown )
                {
                    int mode = m_mode;
                    SetMode( ++mode );
                }
                else if (!m_canvasobject || !m_canvasobject->ProcessEvent(event) ) //handover event to object.
                    event.Skip();
            }
            break;
            default:
            {
                bool processed = false;
                if(m_canvasobject)
                    processed = m_canvasobject->ProcessEvent(event); //handover event to object.

                if ( !processed && m_canvasobject)
                {
                    if ( m_canvasobject->IsDraggable() )
                    {
                        double shiftx;
                        double shifty;
                        GetKeyIncrement(&shiftx, &shifty, event.AltDown());

                        //now shift with snap distances in X or Y

                        switch(event.GetKeyCode())
                        {
                            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();
                            }
                        }

                        m_canvasobject->Translate( shiftx, shifty );
                        event.Skip( false );
                        m_pending = true;
                    }
                    else
                        event.Skip( false );
                }              
                if(!m_canvasobject)
                    event.Skip();
            }
        }

        if(m_canvasobject)
        {
            m_canvasobject->AdjustPinLocation();
            m_connectedwirecopies.UpdateImmediate( false, this, m_canvasobject );
        }
    }
    else
        event.Skip();
}

void a2dObjectEditTool::OnComEvent( a2dComEvent& event )
{
    if ( GetBusy() )
    {
        if ( event.GetEventComId() == &a2dStTool::sm_toolBeforePush )
        {
            // If tool is busy, it will enter halted state    
            if ( GetBusy() && !m_halted )
            {
                m_halted = true;     
                CleanupToolObjects();
            }
            m_pending = true;
        }
        else if ( GetCanvasView() && event.GetEventComId() == &a2dCanvasView::sm_changedShowObject )
        {
            if ( event.GetEventObject() == GetCanvasView() )
            {
                StopTool();
            }
        }
        else
            event.Skip();
    }

    event.Skip();
}

void a2dObjectEditTool::SetActive(bool active)
{
    if ( active )
    {
        if ( m_halted )
        {
            m_halted = false;  
            //RESTART editing so the edit copy becomes updated from the original.
            //original may have changed because of sub-editing of child objects.
            CreateToolObjects();
            m_active = true;
        }
        m_pending = true;
        a2dBaseTool::SetActive( active );
    }
    else
    {
        //the subedit or other subtools should not influence style of the object.
        //When this tool is activated again, the CurrentCanvasObject is set right again.
        SetEditObject( NULL );

        m_pending = true;
        a2dBaseTool::SetActive( active );
    }
}

void a2dObjectEditTool::OnUndoEvent( a2dCommandProcessorEvent& WXUNUSED(event) )
{
    if (GetBusy() && !m_halted )
    {
        // recreate edit copies so the edit copy becomes updated from the original.
        wxUint16 editmode = a2dCanvasObject::PROPID_Editmode->GetPropertyValue( m_canvasobject );
        TriggerReStartEdit( editmode );
    }
}

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

void a2dObjectEditTool::OnDoEvent( a2dCommandProcessorEvent& event )
{
    if (GetBusy())
    {
    }
}

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