tools.cpp

Go to the documentation of this file.

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

    Copyright: 2001-2004 (c) Klaas Holwerda                                     

    Licence: wxWidgets Licence

    RCS-ID: $Id: tools.cpp,v 1.133 2009/06/03 17:38:13 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/tools.h"
 
IMPLEMENT_CLASS( a2dBaseTool, a2dEvtHandler)
IMPLEMENT_CLASS( a2dToolContr, a2dEvtHandler)

//----------------------------------------------------------------------------
// a2dToolList
//----------------------------------------------------------------------------

a2dToolList::a2dToolList()
{
}

a2dToolList::~a2dToolList()
{
}

a2dToolList* a2dToolList::Clone( a2dObject::CloneOptions options ) const
{    
    a2dToolList* a = new a2dToolList();

    for( a2dToolList::const_iterator iter = begin(); iter != end(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;

        if ( options & a2dObject::clone_childs )
        {
            a2dBaseTool *objnew = wxStaticCast( toolobj->Clone( options ), a2dBaseTool );
            a->push_back(objnew);
        }
        else
            a->push_back( toolobj );
    }

    return a;
}

//----------------------------------------------------------------------------
// a2dToolContr
//----------------------------------------------------------------------------

A2D_BEGIN_EVENT_TABLE(a2dToolContr, a2dEvtHandler)
    A2D_EVT_CLOSE_VIEW( a2dToolContr::OnCloseView ) /* to be informed about view and attached canvas being closed */
    A2D_EVT_PAINT( a2dToolContr::OnPaint )
    A2D_EVT_IDLE( a2dToolContr::OnIdle )
    A2D_EVT_ENTER_WINDOW( a2dToolContr::OnEnter )
    A2D_EVT_SET_DOCUMENT( a2dToolContr::OnSetDocument )
A2D_END_EVENT_TABLE()

a2dToolContr::a2dToolContr(a2dCanvasView* drawer)
{
    SetSnap( false );
    m_bussyPoping = false;
        
    // the defa2lt event handler is just this object
    m_view = drawer;
    
    if ( m_view )
    {
        //always add the commandprocessor
        //this is needed for tools, so not strictly needed.
        if ( m_view->GetCanvasDocument() && !m_view->GetCanvasDocument()->GetCommandProcessor() )
            m_view->GetCanvasDocument()->CreateCommandProcessor();

        m_view->SetCanvasToolContr( this );
        SetEvtHandlerEnabled( true );
    }
    else
        SetEvtHandlerEnabled( false );
}

a2dToolContr::~a2dToolContr()
{
}

a2dBaseTool* a2dToolContr::GetFirstTool() const
{ 
    return m_tools.size()? m_tools.front(): NULL; 
}

void a2dToolContr::SetCanvasView(a2dCanvasView* view)
{
    //prevent deletion by drawer 
    a2dREFOBJECTPTR_KEEPALIVE;

    if ( m_view )
    {   //disable the controller for the current drawer
        m_view->SetCanvasToolContr( NULL );
        SetEvtHandlerEnabled( false );
    }

    m_view = view;

    if ( m_view )
    {
        m_view->SetCanvasToolContr( this );
        SetEvtHandlerEnabled(true);
    }
    else
        SetEvtHandlerEnabled(false);
}

void a2dToolContr::ReStart()
{
}

void a2dToolContr::StopAllTools()
{
    a2dSmrtPtr< a2dBaseTool > tool; 
    a2dToolContr::PopTool( tool );
    while ( tool )
    {
        tool = NULL;
        a2dToolContr::PopTool( tool );
    }
}

void a2dToolContr::Disable()
{
    SetEvtHandlerEnabled( false );
    StopAllTools();
    m_view = 0;
}

void a2dToolContr::ActivateTop( bool active )
{
    // first all other tools, and last the first tool, so its m_corridor will be set in the end.
    for( a2dToolList::reverse_iterator iter = m_tools.rbegin(); iter != m_tools.rend(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;
        if ( *iter == m_tools.front() )
            toolobj->SetActive( active );
        else
            toolobj->SetActive(false);
    }
}

bool a2dToolContr::Activate(const wxString& tool, bool disableothers)
{
    bool found=false;

    for( a2dToolList::iterator iter = m_tools.begin(); iter != m_tools.end(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;
        if (!tool.CmpNoCase( toolobj->GetClassInfo()->GetClassName()))
        {
            toolobj->SetActive(true);
            found=true;
        }
        else if (disableothers)
            toolobj->SetActive(false);
    }
    return found;
}

bool a2dToolContr::EnableTool(const wxString& tool, bool disableothers)
{
    bool found=false;

    for( a2dToolList::iterator iter = m_tools.begin(); iter != m_tools.end(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;

        if (!tool.CmpNoCase( toolobj->GetClassInfo()->GetClassName()))
        {
            toolobj->SetEvtHandlerEnabled(true);
            found=true;
        }
        else if (disableothers)
            toolobj->SetEvtHandlerEnabled(false);
    }
    return found;
}

bool a2dToolContr::EnableTool(a2dBaseTool* tool, bool disableothers)
{
    bool found=false;
    for( a2dToolList::iterator iter = m_tools.begin(); iter != m_tools.end(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;
        if ( tool == toolobj )
        {
            toolobj->SetEvtHandlerEnabled(true);
            found=true;
        }
        else if (disableothers)
            toolobj->SetEvtHandlerEnabled(false);
    }
    return found;
}

bool a2dToolContr::DisableTool(const wxString& tool )
{
    bool found=false;
    for( a2dToolList::iterator iter = m_tools.begin(); iter != m_tools.end(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;
        if (!tool.CmpNoCase(toolobj->GetClassInfo()->GetClassName()))
        {
            toolobj->SetEvtHandlerEnabled(false);
            found=true;
        }
    }
    return found;
}

bool a2dToolContr::DisableTool(a2dBaseTool* tooldis )
{
    bool found=false;
    for( a2dToolList::iterator iter = m_tools.begin(); iter != m_tools.end(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;
        if ( toolobj == tooldis )
        {
            tooldis->SetEvtHandlerEnabled(false);
            found=true;
        }
    }
    return found;
}

a2dBaseTool* a2dToolContr::SearchTool(const wxString& toolsearch )
{
    for( a2dToolList::iterator iter = m_tools.begin(); iter != m_tools.end(); ++iter )
    {
        a2dToolList::value_type toolobj = *iter;
        if (!toolsearch.CmpNoCase(toolobj->GetClassInfo()->GetClassName()))
            return toolobj;
    }   
    return (a2dBaseTool*) 0;
}

bool a2dToolContr::ProcessEvent(wxEvent& event)
{
    if ( !m_view || !m_view->GetEnabled())
    {
            return false;
    }

    a2dEvtHandler* active = GetEventHandler();

    //the next is almost a copy of a2dEvtHandler::ProcessEvent
    //The base class could not be used since in case of an event skip
    //in a derived a2dToolContr class, the event would go directly to the a2dCanvas,
    //without passing it to the tools first.

    //So the order here is:
    //first test for static event tables in a derived controller class if event is skipped or !handled in there,
    //Process the events down the chain of tools (each tool that skips the event means the next one is called)
    //If still not processed, the event is redirected to the rest of the wxEvtHandler in the a2dCanvas window.
    //This is in general the a2dCanvas window itself.
    //In case a tool has stopped itself, the tool is poped of the stack, and if the event was not handled yet
    //it is sent to the tool that is now first on the stack.

    // An event handler can be enabled or disabled
    if ( active->GetEvtHandlerEnabled() )
    {
        if ( !m_bussyPoping && GetFirstTool() && GetFirstTool()->GetStopTool() )
        {
            a2dSmrtPtr<a2dBaseTool> poped;
            PopTool( poped );
        }

        if ( a2dEvtHandler::ProcessEvent(event) )
            return true;

        return ToolsProcessEvent(event);
    }

    return false;
}

bool a2dToolContr::ToolsProcessEvent(wxEvent& event)
{
    bool handled = false;

    if ( GetFirstTool() )
    {
        //process event return false if event was skipped or not handled.
        //the firstool redirects to the next tool on the stack etc.
        //if not handled in any tool the next return false
        
        size_t nrTools = m_tools.size(); 

        // If a new tool was pushed, give the new tool a chance to process the event.
        // This is a typical situation when the tool pushed a new tool while handling the event.
        // The same event directly goes to that tool.  
        // This pushed tool can do the same itself, so repeat until no more pushed tools.

        a2dToolList::iterator iter = m_tools.begin();
        while( !handled && iter != m_tools.end() ) 
        {
            a2dBaseTool *first = (*iter).Get();
            iter++; // go to the next in case of a pop, we will be save.
            handled = first->ProcessEvent(event);
            if ( nrTools < m_tools.size() ) //there was a push
            {     
                iter = m_tools.begin();   //start all over
                nrTools = m_tools.size();
            }
            //was there a pop request?
            if ( GetFirstTool()->GetStopTool())
            {
                if ( !m_bussyPoping )
                {    
                    a2dSmrtPtr<a2dBaseTool> poped;
                    PopTool(poped);
                }
                iter = m_tools.begin();   
            }
            //ready to go to the next tool where the iterator is on. 
        }

        return handled;
    }
    return false;
}

bool a2dToolContr::PushTool(a2dBaseTool* handler)
{
    a2dBaseToolPtr handlerres = handler;
    //first allow the current first tool to react on a the pushing of the new tool.
    if ( GetFirstTool() )
    {   
        a2dComEvent event( GetFirstTool(), handler,  &a2dBaseTool::sm_toolBeforePush );
        if ( GetFirstTool()->ProcessEvent( event ) && event.GetEventComIdReturn() == &a2dBaseTool::sm_toolDoPopBeforePush )
        {
            // if a push attempt must result in the current first tool to be stopped, 
            // we pop it directly.
            a2dSmrtPtr<a2dBaseTool> poped;
            if ( GetFirstTool()->GetStopTool() )
                PopTool(poped);
        }
    }

    if ( handler->StartTool( GetFirstTool() ) )
    {
        ActivateTop( false );
        m_tools.push_front( handler );
        a2dCanvasDocument *doc;
        if ( GetCanvasView() )
             doc = GetCanvasView()->GetCanvasDocument();
        if ( doc ) 
        {
            a2dComEvent event( GetFirstTool(), &a2dBaseTool::sm_toolPushed );
            GetFirstTool()->ProcessEvent( event );
        }   
        ActivateTop( true );
        return true;
    }
    return false;
}

bool a2dToolContr::PopTool( a2dSmrtPtr<a2dBaseTool>& poped, bool force )
{
    m_bussyPoping = true;

    if ( GetFirstTool() && ( GetFirstTool()->AllowPop() || force ) )
    {
        GetFirstTool()->StopTool( force );
        poped = GetFirstTool();
        if ( poped )
        {
            //release the object from the tool list, but argument 
            //poped will keep a reference, so no delete, this is good, since we want to sent an event to the new
            // first tool, with as parameter the the poped tool.
            m_tools.ReleaseObject( poped );

            // inform new first tool, e.g. to take style of the poped tool.
            if ( GetFirstTool() )
            {                
                a2dCanvasDocument *doc;
                if ( GetCanvasView() )
                     doc = GetCanvasView()->GetCanvasDocument();

                if ( doc ) 
                {
                    a2dComEvent event( GetFirstTool(), poped,  &a2dBaseTool::sm_toolPoped );
                    GetFirstTool()->ProcessEvent( event );
                }   
            }
            poped->SetActive( false );
        }

        m_bussyPoping = false;
        return true;
    }
    m_bussyPoping = false;
    poped  = NULL;
    return false;
}

void a2dToolContr::AppendTool(a2dBaseTool *handler)
{
    m_tools.push_back( handler );
}

void a2dToolContr::OnCloseView( a2dCloseViewEvent& event )
{
    a2dView* theView = (a2dView*) event.GetEventObject();
    if ( theView == m_view )
    {
        StopAllTools();
        event.Skip( true ); //also usefull for the canvas itself
    }
}

void a2dToolContr::OnSetDocument( a2dViewEvent& event )
{
    a2dCanvasDocument* doc = (a2dCanvasDocument*) ((a2dView*)event.GetEventObject())->GetDocument();
    StopAllTools();
    event.Skip( true ); //also usefull for the canvas itself
}

void a2dToolContr::OnEnter( wxMouseEvent &event )
{
    event.Skip(true);
}

void a2dToolContr::OnPaint( wxPaintEvent &event )
{
    if (GetFirstTool())
    {
        GetFirstTool()->ProcessEvent(event);
    }

    //no skipping here (onPaint event is/should be handled)
    event.Skip(false);
}

void a2dToolContr::OnIdle( wxIdleEvent &event )
{
    if (GetFirstTool())
    {
        GetFirstTool()->ProcessEvent(event);
    }
}

bool a2dToolContr::StartEditingObject( a2dCanvasObject* objectToEdit )
{
    return false;
}

bool a2dToolContr::StartEditingObject( a2dCanvasObject* objectToEdit, a2dIterC& ic )
{
    return false;
}

bool a2dToolContr::TriggerReStartEdit( wxUint16 editmode )
{
    return false;
}

void a2dToolContr::Render()
{
    for( a2dToolList::reverse_iterator iter = m_tools.rbegin(); iter != m_tools.rend(); ++iter )
        (*iter)->Render();
}

bool a2dToolContr::SetCorridor( const a2dCorridor& corridor )
{
    wxASSERT_MSG( GetFirstTool(), wxT("No tool set in controller") );
    GetFirstTool()->SetCorridor( corridor );
    return true;
}

void a2dToolContr::SetSnap(bool snap)
{
    m_snap = snap;
    a2dRestrictionEngine *restrict = a2dCanvasGlobals->GetRestrictionEngine();
    if(restrict)
        restrict->SetSnap( m_snap );
}


/********************************************************************************
a2dBaseTool
********************************************************************************/

a2dPropertyIdBool* a2dBaseTool::PROPID_Oneshot = NULL;
a2dPropertyIdBool* a2dBaseTool::PROPID_Stop = NULL;
a2dPropertyIdFill* a2dBaseTool::PROPID_Fill = NULL;
a2dPropertyIdStroke* a2dBaseTool::PROPID_Stroke = NULL;
a2dPropertyIdUint16* a2dBaseTool::PROPID_Layer = NULL;

INITIALIZE_PROPERTIES( a2dBaseTool, a2dEvtHandler )
{
    A2D_PROPID_M( a2dPropertyIdBool, a2dBaseTool, Oneshot, false, m_oneshot );
    A2D_PROPID_M( a2dPropertyIdBool, a2dBaseTool, Stop, false, m_stop );
    A2D_PROPID_M( a2dPropertyIdUint16, a2dBaseTool, Layer, 0, m_layer );

    PROPID_Fill = new a2dPropertyIdFill( wxT("Fill"), 
        a2dPropertyId::flag_transfer|a2dPropertyId::flag_clonedeep, 
        *a2dNullFILL, 
        static_cast < a2dPropertyIdFill::ConstGet >(&a2dBaseTool::GetFill), 
        static_cast < a2dPropertyIdFill::ConstSet >(&a2dBaseTool::SetFill) );
    AddPropertyId( PROPID_Fill );

    PROPID_Stroke = new a2dPropertyIdStroke( wxT("Stroke"), 
        a2dPropertyId::flag_transfer|a2dPropertyId::flag_clonedeep, 
        *a2dNullSTROKE, 
        static_cast < a2dPropertyIdStroke::ConstGet >(&a2dBaseTool::GetStroke), 
        static_cast < a2dPropertyIdStroke::ConstSet >(&a2dBaseTool::SetStroke) );
    AddPropertyId( PROPID_Stroke );
    return true;
}

DEFINE_EVENT_TYPE( a2dBaseTool::sm_toolPushed )
DEFINE_EVENT_TYPE( a2dBaseTool::sm_toolPoped )
DEFINE_EVENT_TYPE( a2dBaseTool::sm_toolBeforePush )
DEFINE_EVENT_TYPE( a2dBaseTool::sm_toolDoPopBeforePush )
DEFINE_EVENT_TYPE( a2dBaseTool::sm_toolComEvent )

A2D_BEGIN_EVENT_TABLE(a2dBaseTool, a2dEvtHandler)
    A2D_EVT_MOUSE_EVENTS(a2dBaseTool::OnMouseEvent)
    A2D_EVT_CHAR(a2dBaseTool::OnChar)
    A2D_EVT_KEY_DOWN(a2dBaseTool::OnKeyDown)
    A2D_EVT_KEY_UP(a2dBaseTool::OnKeyUp)
    A2D_EVT_COM_EVENT( a2dBaseTool::OnComEvent )
    A2D_EVT_DO( a2dBaseTool::OnDoEvent )
    A2D_EVT_UNDO( a2dBaseTool::OnUndoEvent )
    A2D_EVT_REDO( a2dBaseTool::OnRedoEvent )
    A2D_EVT_REMOVE_VIEW( a2dBaseTool::OnRemoveView )
A2D_END_EVENT_TABLE()


a2dBaseTool::a2dBaseTool(a2dToolContr* controller)
{
    //a2dDocviewGlobals->GetEventDistributer()->Register( this );

    m_mode = 0;
    
    m_anotate = true;

    m_toolcursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  );
    m_toolBusyCursor = a2dCanvasGlobals->GetCursor( a2dCURSOR_ARROW  );

    m_annotateFont = wxFont( 10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL); 

    // drawing wifth this stroke and fill is based on layers style in document 
    m_fill = *a2dNullFILL;
    m_stroke = *a2dNullSTROKE;
    m_contourwidth = 0;

    m_layer = wxLAYER_DEFAULT;
    m_controller = controller;
    m_busy = false;
    m_halted = false;
    m_oneshot = false;
    m_active = true;
    m_stop = false;
    m_bussyStopping = 0;
    m_pending = false;

    m_canvas_mouseevents_restore = GetCanvasView()->GetMouseEvents();

    m_mousemenu = NULL;

    m_corridor = a2dCorridor( *GetCanvasView() );   
    if ( !m_corridor.empty() )
    {
        m_parentobject = m_corridor.back();
        wxASSERT_MSG( m_parentobject->GetCanvasDocument() != 0 , wxT("parentobject of tools has no document root set") );
    }

    // the default event handler is just this object
    m_eventHandler = NULL;

    m_ignorePendingObjects = false;
}

a2dBaseTool::a2dBaseTool( const a2dBaseTool& other, CloneOptions options  )
    :a2dEvtHandler( other, options ) 
{
    //a2dDocviewGlobals->GetEventDistributer()->Register( this );

    m_mode = other.m_mode;
    
    m_anotate = other.m_anotate;

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

    m_annotateFont = other.m_annotateFont;

    // drawing wifth this stroke and fill is based on layers style in document 
    m_fill = other.m_fill;
    m_stroke = other.m_stroke;
    m_contourwidth = 0;

    m_layer = other.m_layer;
    m_controller = other.m_controller;
    m_busy = false;
    m_halted = false;
    m_oneshot = other.m_oneshot;
    m_active = true;
    m_stop = false;
    m_bussyStopping = 0;
    m_pending = false;

    m_canvas_mouseevents_restore = GetCanvasView()->GetMouseEvents();

    m_mousemenu = NULL; //other.m_mousemenu;

    m_corridor = other.m_corridor;
    if ( !m_corridor.empty() )
        m_parentobject = m_corridor.back();

    // the default event handler is just this object
    m_eventHandler = other.m_eventHandler;

    m_ignorePendingObjects = other.m_ignorePendingObjects;

}

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

    if ( GetCanvasView() )
        GetCanvasView()->SetMouseEvents(m_canvas_mouseevents_restore);    
    
    if(m_mousemenu)  
        delete m_mousemenu;
}

void a2dBaseTool::ResetContext()
{
    m_corridor = a2dCorridor( *GetCanvasView() );   
    if ( !m_corridor.empty() )
        m_parentobject = m_corridor.back();
    else 
        m_parentobject = NULL;
}

void a2dBaseTool::SetIgnorePendingObjects( bool onoff )
{
    m_ignorePendingObjects = onoff;
    GetCanvasView()->GetCanvasDocument()->SetIgnorePendingObjects( onoff );
}

void a2dBaseTool::SetMousePopupMenu( wxMenu* mousemenu )
{ 
    if ( m_mousemenu )
        delete m_mousemenu;
    m_mousemenu = mousemenu; 
}

bool a2dBaseTool::StartTool( a2dBaseTool* WXUNUSED(currenttool) )
{
    m_stop = false;
    GetCanvasView()->SetCursor( m_toolcursor );
    return true;
}

void a2dBaseTool::SetActive(bool active) 
{ 
    m_active = active; 
    //reactivate this state for document.
    if ( GetCanvasView()->GetCanvasDocument() )
        GetCanvasView()->GetCanvasDocument()->SetIgnorePendingObjects( m_ignorePendingObjects );

    if ( active )
    {
        GetCanvasView()->SetCorridorPath( m_corridor );
    }
    else
    {
        GetCanvasView()->ClearCorridorPath( true );
    }
}

bool a2dBaseTool::ProcessEvent( wxEvent& event )
{
    if ( m_eventHandler )
    {
        bool processed = m_eventHandler->ProcessEvent( event );
        if ( processed )
            return processed;           
    }
    return a2dEvtHandler::ProcessEvent( event );
}

void a2dBaseTool::OnComEvent( a2dComEvent& event )
{
    if ( GetCanvasView() && event.GetEventComId() == &a2dCanvasView::sm_changedShowObject )
    {
        if ( event.GetEventObject() == GetCanvasView() )
        {
            // an existing corridor on a view will become invalid when the ShowObject changes.
            // Most tools can handle a change in corridor, for those there is no need to remove them after a change
            // in ShowObject.
            a2dCanvasObject* newtop = wxStaticCast( event.GetProperty()->GetRefObject(), a2dCanvasObject );
            if ( newtop )
            {
                a2dCorridor corridor;
                corridor.Push( newtop );
                SetCorridor( corridor );
            }
            else
                StopTool();
        }
        event.Skip();
    }
    else if ( m_active && GetEvtHandlerEnabled() && GetCanvasView())
    {
        event.Skip();
    }
    else
        event.Skip();
}

void a2dBaseTool::OnRemoveView( a2dDocumentEvent& event )
{
    a2dView* viewtoremove = (a2dView*) event.GetView();
    if ( GetCanvasView() == viewtoremove )
    {
        StopTool();
    }
}

void a2dBaseTool::OnDoEvent( a2dCommandProcessorEvent& event )
{

}

void a2dBaseTool::OnUndoEvent( a2dCommandProcessorEvent& event )
{
 
}

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


bool a2dBaseTool::EnterBusyMode()
{
    wxASSERT( !m_busy );
    m_busy = true;
    m_pending = true;
    OpenCommandGroup( false );
    GetCanvasView()->SetCursor( m_toolBusyCursor );
    return true;
}

void a2dBaseTool::FinishBusyMode( bool closeCommandGroup )
{
    wxASSERT( m_busy );
    m_busy = false;
    m_pending = true;
    if ( closeCommandGroup )
        CloseCommandGroup();
    if( GetCanvasView() )
    {
        GetCanvasView()->SetCursor( m_toolcursor );
    }
    if( m_oneshot && !m_halted )
        StopTool();
}

void a2dBaseTool::AbortBusyMode()
{
    wxASSERT( m_busy );
    m_busy = false;
    m_pending = true;
    CloseCommandGroup();
    if( GetCanvasView() )
    {
        GetCanvasView()->SetCursor( m_toolcursor );
        GetCanvasCommandProcessor()->Undo();
    }
    if (m_oneshot)
        StopTool();
}

void a2dBaseTool::StopTool( bool abort )
{ 
    m_bussyStopping++;
    if ( !m_stop  )
    {
        DoStopTool( abort );
        m_stop = true;
    }
    m_bussyStopping--;
}

void a2dBaseTool::DoStopTool( bool abort )
{ 
    if (m_busy )
    {   
        if ( abort )
            AbortBusyMode();
        else
            FinishBusyMode();
    }
}

bool a2dBaseTool::GetStopTool() 
{ 
    return m_stop && m_bussyStopping == 0; 
}

void a2dBaseTool::SetFill( const a2dFill& fill)
{
    m_fill = fill;
};

void a2dBaseTool::SetStroke( const a2dStroke& stroke)
{
    m_stroke = stroke;
};

void a2dBaseTool::SetContourWidth(double width) 
{ 
    m_contourwidth = width;
}

void a2dBaseTool::SetLayer( wxUint16 layer)
{
    m_layer = layer;
}

void a2dBaseTool::OnMouseEvent(wxMouseEvent& event)
{
    event.Skip();
}

void a2dBaseTool::OnKeyDown(wxKeyEvent& event)
{
    event.Skip();
}

void a2dBaseTool::OnKeyUp(wxKeyEvent& event)
{
    event.Skip();
}

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

void a2dBaseTool::OpenCommandGroup( bool restart )
{
    if ( restart )
    {
        if ( !m_commandgroup )
        {
            wxString name = GetCommandGroupName();
    
            if( restart )
                name += _(" (continued)");

            OpenCommandGroupNamed( name );
        }       
    }
    else 
    {
        if ( !m_commandgroup )
        {
            wxString name = GetCommandGroupName();
            OpenCommandGroupNamed( name );
        }
    }
}

void a2dBaseTool::OpenCommandGroupNamed( const wxString &name )
{
    wxASSERT_MSG( !m_commandgroup,  wxT("Unclosed command group") );
    
    m_commandgroup = GetCanvasCommandProcessor()->CommandGroupBegin( name );
}

void a2dBaseTool::CloseCommandGroup()
{
    if ( m_commandgroup && this == m_controller->GetFirstTool() )
    {
        if( GetCanvasView() )
        {
            GetCanvasCommandProcessor()->CommandGroupEnd( m_commandgroup );
        }
        m_commandgroup = 0;
    }
}

wxString a2dBaseTool::GetCommandGroupName()
{
    return GetClassInfo()->GetClassName();
}

void a2dBaseTool::SetCorridor( const a2dCorridor& corridor )
{
    m_corridor = corridor;
    if ( m_corridor.empty() )
    {
        m_corridor.Push( GetCanvasView()->GetShowObject() );
        m_parentobject = GetCanvasView()->GetShowObject();
    }
    else
    {        
        m_parentobject = m_corridor.back();
    }
    wxASSERT_MSG( m_parentobject->GetCanvasDocument() != 0 , wxT("parentobject of tools has no document root set") );
    GetCanvasView()->SetCorridorPath( corridor );
}  

void a2dBaseTool::AddEditobject( a2dCanvasObject *object )
{
    a2dCanvasObject::PROPID_ToolObject->SetPropertyToObject( object, this );
    a2dCanvasObject::PROPID_ViewSpecific->SetPropertyToObject( object, GetCanvasView() );
    wxASSERT_MSG( m_parentobject->GetCanvasDocument() != 0 , wxT("parentobject of tools has no document root set") );
    m_parentobject->Append( object );
    object->SetSnapTo( false );
}

void a2dBaseTool::RemoveEditobject( a2dCanvasObject *object )
{
    // Usually shortly added, so scanning backwards is usually faster
    m_parentobject->GetChildObjectList()->Release( object, true, false, true, a2dCanvasObject::PROPID_ToolObject ); 
}

void a2dBaseTool::AddDecorationObject( a2dCanvasObject *object )
{
    a2dCanvasObject::PROPID_ToolDecoration->SetPropertyToObject( object, true );
    a2dCanvasObject::PROPID_ViewSpecific->SetPropertyToObject( object, GetCanvasView() );

    object->SetHitFlags( a2dCANOBJ_EVENT_NON );
    wxASSERT_MSG( m_parentobject->GetCanvasDocument() != 0 , wxT("parentobject of tools has no document root set") );
    m_parentobject->Append( object );
    object->SetSnapTo( false );
}

void a2dBaseTool::RemoveAllDecorations()
{
    a2dCanvasObjectList::iterator iter = m_parentobject->GetChildObjectList()->begin();
    while( iter !=  m_parentobject->GetChildObjectList()->end() )
    {    
        a2dCanvasObject* obj = *iter;
        iter++;
        if( a2dCanvasObject::PROPID_ToolDecoration->GetPropertyValue( obj ) )
            m_parentobject->ReleaseChild( obj );
    }

    //first update the document, in order to get the right boundingboxes again ( also of the tool object )
    GetCanvasView()->GetCanvasDocument()->AddPendingUpdatesOldNew();
}

a2dDrawer2D* a2dBaseTool::GetDrawer2D()
{ 
    return m_controller->GetCanvasView()->GetDrawer2D();
}

wxWindow* a2dBaseTool::GetDisplayWindow()
{ 
    return m_controller->GetCanvasView()->GetDisplayWindow();
}

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

a2dCanvasCommandProcessor* a2dBaseTool::GetCanvasCommandProcessor() 
{
    if ( !GetCanvasDocument() )
        return NULL;
    return GetCanvasDocument()->GetCanvasCommandProcessor();
}


//-----------------------------------------------------------
// a2dToolEvtHandler
//-----------------------------------------------------------

A2D_BEGIN_EVENT_TABLE(a2dToolEvtHandler, a2dEvtHandler )
    A2D_EVT_COM_EVENT( a2dToolEvtHandler::OnComEvent )
A2D_END_EVENT_TABLE()

a2dToolEvtHandler::a2dToolEvtHandler()      
{
}

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

bool a2dToolEvtHandler::ProcessEvent( wxEvent& event )
{
    if ( a2dEvtHandler::ProcessEvent( event ) )
        return true;
    return false;
}

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