2013-08-06 08:30:09 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013 CERN
|
|
|
|
* @author Tomasz Wlostowski <tomasz.wlostowski@cern.ch>
|
2013-09-27 16:51:21 +00:00
|
|
|
* @author Maciej Suminski <maciej.suminski@cern.ch>
|
2013-08-06 08:30:09 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, you may find one here:
|
|
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
*/
|
|
|
|
|
2013-08-02 14:46:53 +00:00
|
|
|
#include <map>
|
|
|
|
#include <deque>
|
2014-07-09 11:50:27 +00:00
|
|
|
#include <stack>
|
|
|
|
#include <algorithm>
|
2013-08-02 14:46:53 +00:00
|
|
|
|
|
|
|
#include <boost/foreach.hpp>
|
2013-09-26 12:09:18 +00:00
|
|
|
#include <boost/scoped_ptr.hpp>
|
2013-08-02 14:46:53 +00:00
|
|
|
#include <boost/optional.hpp>
|
|
|
|
#include <boost/range/adaptor/map.hpp>
|
|
|
|
|
|
|
|
#include <wx/event.h>
|
2014-07-09 12:01:07 +00:00
|
|
|
#include <wx/clipbrd.h>
|
2013-08-02 14:46:53 +00:00
|
|
|
|
|
|
|
#include <view/view.h>
|
2014-07-09 14:50:31 +00:00
|
|
|
#include <view/view_controls.h>
|
2013-08-02 14:46:53 +00:00
|
|
|
|
|
|
|
#include <tool/tool_base.h>
|
|
|
|
#include <tool/tool_interactive.h>
|
|
|
|
#include <tool/tool_manager.h>
|
|
|
|
#include <tool/context_menu.h>
|
|
|
|
#include <tool/coroutine.h>
|
2013-09-27 16:51:21 +00:00
|
|
|
#include <tool/action_manager.h>
|
2013-08-02 14:46:53 +00:00
|
|
|
|
|
|
|
#include <wxPcbStruct.h>
|
2013-11-11 09:48:49 +00:00
|
|
|
#include <confirm.h>
|
2014-04-04 09:56:04 +00:00
|
|
|
#include <class_draw_panel_gal.h>
|
2013-08-02 14:46:53 +00:00
|
|
|
|
|
|
|
using boost::optional;
|
|
|
|
|
2013-09-27 16:51:21 +00:00
|
|
|
/// Struct describing the current execution state of a TOOL
|
2013-09-02 12:21:12 +00:00
|
|
|
struct TOOL_MANAGER::TOOL_STATE
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
TOOL_STATE( TOOL_BASE* aTool ) :
|
|
|
|
theTool( aTool )
|
|
|
|
{
|
|
|
|
clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
TOOL_STATE( const TOOL_STATE& aState )
|
|
|
|
{
|
|
|
|
theTool = aState.theTool;
|
|
|
|
idle = aState.idle;
|
|
|
|
pendingWait = aState.pendingWait;
|
|
|
|
pendingContextMenu = aState.pendingContextMenu;
|
|
|
|
contextMenu = aState.contextMenu;
|
|
|
|
contextMenuTrigger = aState.contextMenuTrigger;
|
|
|
|
cofunc = aState.cofunc;
|
|
|
|
wakeupEvent = aState.wakeupEvent;
|
|
|
|
waitEvents = aState.waitEvents;
|
|
|
|
transitions = aState.transitions;
|
|
|
|
// do not copy stateStack
|
|
|
|
}
|
|
|
|
|
|
|
|
~TOOL_STATE()
|
|
|
|
{
|
|
|
|
assert( stateStack.empty() );
|
|
|
|
}
|
|
|
|
|
2013-09-02 12:21:12 +00:00
|
|
|
/// The tool itself
|
2013-10-14 11:43:57 +00:00
|
|
|
TOOL_BASE* theTool;
|
2013-09-02 12:21:12 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// Is the tool active (pending execution) or disabled at the moment
|
|
|
|
bool idle;
|
2013-09-02 12:21:12 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// Flag defining if the tool is waiting for any event (i.e. if it
|
|
|
|
/// issued a Wait() call).
|
|
|
|
bool pendingWait;
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// Is there a context menu being displayed
|
|
|
|
bool pendingContextMenu;
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// Context menu currently used by the tool
|
|
|
|
CONTEXT_MENU* contextMenu;
|
2013-09-02 12:21:12 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// Defines when the context menu is opened
|
|
|
|
CONTEXT_MENU_TRIGGER contextMenuTrigger;
|
2013-09-02 12:21:12 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// Tool execution context
|
2015-02-14 20:28:47 +00:00
|
|
|
COROUTINE<int, const TOOL_EVENT&>* cofunc;
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// The event that triggered the execution/wakeup of the tool after Wait() call
|
|
|
|
TOOL_EVENT wakeupEvent;
|
2013-09-24 13:47:07 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
/// List of events the tool is currently waiting for
|
|
|
|
TOOL_EVENT_LIST waitEvents;
|
|
|
|
|
|
|
|
/// List of possible transitions (ie. association of events and state handlers that are executed
|
|
|
|
/// upon the event reception
|
|
|
|
std::vector<TRANSITION> transitions;
|
|
|
|
|
2014-07-09 11:50:27 +00:00
|
|
|
void operator=( const TOOL_STATE& aState )
|
|
|
|
{
|
|
|
|
theTool = aState.theTool;
|
|
|
|
idle = aState.idle;
|
|
|
|
pendingWait = aState.pendingWait;
|
|
|
|
pendingContextMenu = aState.pendingContextMenu;
|
|
|
|
contextMenu = aState.contextMenu;
|
|
|
|
contextMenuTrigger = aState.contextMenuTrigger;
|
|
|
|
cofunc = aState.cofunc;
|
|
|
|
wakeupEvent = aState.wakeupEvent;
|
|
|
|
waitEvents = aState.waitEvents;
|
|
|
|
transitions = aState.transitions;
|
|
|
|
// do not copy stateStack
|
|
|
|
}
|
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
bool operator==( const TOOL_MANAGER::TOOL_STATE& aRhs ) const
|
2013-09-24 13:47:07 +00:00
|
|
|
{
|
2013-10-14 14:13:35 +00:00
|
|
|
return aRhs.theTool == this->theTool;
|
2013-09-24 13:47:07 +00:00
|
|
|
}
|
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
bool operator!=( const TOOL_MANAGER::TOOL_STATE& aRhs ) const
|
2013-09-24 13:47:07 +00:00
|
|
|
{
|
2013-10-14 14:13:35 +00:00
|
|
|
return aRhs.theTool != this->theTool;
|
2013-09-24 13:47:07 +00:00
|
|
|
}
|
2014-07-09 11:50:27 +00:00
|
|
|
|
2014-07-09 12:23:13 +00:00
|
|
|
/**
|
|
|
|
* Function Push()
|
|
|
|
* Stores the current state of the tool on stack. Stacks are stored internally and are not
|
|
|
|
* shared between different TOOL_STATE objects.
|
|
|
|
*/
|
2014-07-09 11:50:27 +00:00
|
|
|
void Push()
|
|
|
|
{
|
2014-07-20 18:58:33 +00:00
|
|
|
stateStack.push( new TOOL_STATE( *this ) );
|
2014-07-09 11:50:27 +00:00
|
|
|
|
|
|
|
clear();
|
|
|
|
}
|
|
|
|
|
2014-07-09 12:23:13 +00:00
|
|
|
/**
|
|
|
|
* Function Pop()
|
|
|
|
* Restores state of the tool from stack. Stacks are stored internally and are not
|
|
|
|
* shared between different TOOL_STATE objects.
|
|
|
|
* @return True if state was restored, false if the stack was empty.
|
|
|
|
*/
|
2014-07-09 11:50:27 +00:00
|
|
|
bool Pop()
|
|
|
|
{
|
|
|
|
delete cofunc;
|
|
|
|
|
|
|
|
if( !stateStack.empty() )
|
|
|
|
{
|
2014-07-20 18:58:33 +00:00
|
|
|
*this = *stateStack.top();
|
|
|
|
delete stateStack.top();
|
2014-07-09 11:50:27 +00:00
|
|
|
stateStack.pop();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
cofunc = NULL;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
///> Stack preserving previous states of a TOOL.
|
2014-07-20 18:58:33 +00:00
|
|
|
std::stack<TOOL_STATE*> stateStack;
|
2014-07-09 11:50:27 +00:00
|
|
|
|
|
|
|
///> Restores the initial state.
|
|
|
|
void clear()
|
|
|
|
{
|
|
|
|
idle = true;
|
|
|
|
pendingWait = false;
|
|
|
|
pendingContextMenu = false;
|
|
|
|
cofunc = NULL;
|
|
|
|
contextMenu = NULL;
|
|
|
|
contextMenuTrigger = CMENU_OFF;
|
|
|
|
transitions.clear();
|
|
|
|
}
|
2013-08-02 14:46:53 +00:00
|
|
|
};
|
|
|
|
|
2013-08-08 12:59:59 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
TOOL_MANAGER::TOOL_MANAGER() :
|
2015-02-19 13:53:31 +00:00
|
|
|
m_model( NULL ), m_view( NULL ), m_viewControls( NULL ), m_editFrame( NULL )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-09-27 16:51:21 +00:00
|
|
|
m_actionMgr = new ACTION_MANAGER( this );
|
2014-07-09 09:22:42 +00:00
|
|
|
|
|
|
|
// Register known actions
|
|
|
|
std::list<TOOL_ACTION*>& actionList = GetActionList();
|
|
|
|
BOOST_FOREACH( TOOL_ACTION* action, actionList )
|
|
|
|
RegisterAction( action );
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-08 12:59:59 +00:00
|
|
|
|
2013-09-11 17:37:52 +00:00
|
|
|
TOOL_MANAGER::~TOOL_MANAGER()
|
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
std::map<TOOL_BASE*, TOOL_STATE*>::iterator it, it_end;
|
2013-09-11 17:37:52 +00:00
|
|
|
|
|
|
|
for( it = m_toolState.begin(), it_end = m_toolState.end(); it != it_end; ++it )
|
|
|
|
{
|
|
|
|
delete it->second->cofunc; // delete cofunction
|
|
|
|
delete it->second; // delete TOOL_STATE
|
|
|
|
delete it->first; // delete the tool itself
|
|
|
|
}
|
2013-09-27 16:51:21 +00:00
|
|
|
|
2014-05-14 14:29:53 +00:00
|
|
|
delete m_actionMgr;
|
2013-09-11 17:37:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-08 12:50:32 +00:00
|
|
|
void TOOL_MANAGER::RegisterTool( TOOL_BASE* aTool )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-12-03 14:17:43 +00:00
|
|
|
wxASSERT_MSG( m_toolNameIndex.find( aTool->GetName() ) == m_toolNameIndex.end(),
|
|
|
|
wxT( "Adding two tools with the same name may result in unexpected behaviour.") );
|
|
|
|
wxASSERT_MSG( m_toolIdIndex.find( aTool->GetId() ) == m_toolIdIndex.end(),
|
|
|
|
wxT( "Adding two tools with the same ID may result in unexpected behaviour.") );
|
2014-07-09 09:59:24 +00:00
|
|
|
wxASSERT_MSG( m_toolTypes.find( typeid( *aTool ).name() ) == m_toolTypes.end(),
|
|
|
|
wxT( "Adding two tools of the same type may result in unexpected behaviour.") );
|
2013-12-03 14:17:43 +00:00
|
|
|
|
2014-07-09 11:50:27 +00:00
|
|
|
TOOL_STATE* st = new TOOL_STATE( aTool );
|
2013-10-14 11:43:57 +00:00
|
|
|
|
|
|
|
m_toolState[aTool] = st;
|
|
|
|
m_toolNameIndex[aTool->GetName()] = st;
|
|
|
|
m_toolIdIndex[aTool->GetId()] = st;
|
2014-07-09 09:59:24 +00:00
|
|
|
m_toolTypes[typeid( *aTool ).name()] = st->theTool;
|
2013-10-14 11:43:57 +00:00
|
|
|
|
|
|
|
aTool->m_toolMgr = this;
|
|
|
|
|
2013-12-09 09:42:38 +00:00
|
|
|
if( !aTool->Init() )
|
2013-10-14 11:43:57 +00:00
|
|
|
{
|
2013-12-09 09:42:38 +00:00
|
|
|
std::string msg = StrPrintf( "Initialization of the %s tool failed",
|
|
|
|
aTool->GetName().c_str() );
|
2013-11-13 19:59:47 +00:00
|
|
|
|
2013-12-09 09:42:38 +00:00
|
|
|
DisplayError( NULL, wxString::FromUTF8( msg.c_str() ) );
|
2013-10-14 11:43:57 +00:00
|
|
|
|
2013-12-09 09:42:38 +00:00
|
|
|
// Unregister the tool
|
|
|
|
m_toolState.erase( aTool );
|
|
|
|
m_toolNameIndex.erase( aTool->GetName() );
|
|
|
|
m_toolIdIndex.erase( aTool->GetId() );
|
2014-07-09 09:59:24 +00:00
|
|
|
m_toolTypes.erase( typeid( *aTool ).name() );
|
2013-10-14 11:43:57 +00:00
|
|
|
|
2013-12-09 09:42:38 +00:00
|
|
|
delete st;
|
|
|
|
delete aTool;
|
2013-10-14 11:43:57 +00:00
|
|
|
}
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:30:09 +00:00
|
|
|
|
2013-08-30 08:37:26 +00:00
|
|
|
bool TOOL_MANAGER::InvokeTool( TOOL_ID aToolId )
|
2013-08-20 12:49:08 +00:00
|
|
|
{
|
|
|
|
TOOL_BASE* tool = FindTool( aToolId );
|
|
|
|
|
2013-10-14 18:40:36 +00:00
|
|
|
if( tool && tool->GetType() == INTERACTIVE )
|
2013-09-19 15:02:57 +00:00
|
|
|
return invokeTool( tool );
|
2013-08-30 08:37:26 +00:00
|
|
|
|
2013-09-27 16:51:21 +00:00
|
|
|
return false; // there is no tool with the given id
|
2013-09-19 15:02:57 +00:00
|
|
|
}
|
2013-08-22 13:07:34 +00:00
|
|
|
|
2013-08-30 08:37:26 +00:00
|
|
|
|
2013-09-19 15:02:57 +00:00
|
|
|
bool TOOL_MANAGER::InvokeTool( const std::string& aToolName )
|
|
|
|
{
|
|
|
|
TOOL_BASE* tool = FindTool( aToolName );
|
2013-08-30 08:37:26 +00:00
|
|
|
|
2013-10-14 18:40:36 +00:00
|
|
|
if( tool && tool->GetType() == INTERACTIVE )
|
2013-09-19 15:02:57 +00:00
|
|
|
return invokeTool( tool );
|
2013-08-30 08:37:26 +00:00
|
|
|
|
2013-09-27 16:51:21 +00:00
|
|
|
return false; // there is no tool with the given name
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void TOOL_MANAGER::RegisterAction( TOOL_ACTION* aAction )
|
|
|
|
{
|
|
|
|
m_actionMgr->RegisterAction( aAction );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void TOOL_MANAGER::UnregisterAction( TOOL_ACTION* aAction )
|
|
|
|
{
|
|
|
|
m_actionMgr->UnregisterAction( aAction );
|
2013-08-20 12:49:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-21 10:28:34 +00:00
|
|
|
bool TOOL_MANAGER::RunAction( const std::string& aActionName, bool aNow, void* aParam )
|
2013-12-03 14:41:41 +00:00
|
|
|
{
|
2014-07-09 14:25:50 +00:00
|
|
|
TOOL_ACTION* action = m_actionMgr->FindAction( aActionName );
|
|
|
|
|
|
|
|
if( action )
|
|
|
|
{
|
2014-11-21 10:28:34 +00:00
|
|
|
TOOL_EVENT event = action->MakeEvent();
|
|
|
|
event.SetParameter( aParam );
|
|
|
|
|
2014-07-09 14:25:50 +00:00
|
|
|
if( aNow )
|
|
|
|
ProcessEvent( event );
|
|
|
|
else
|
2014-11-21 10:28:34 +00:00
|
|
|
PostEvent( event );
|
2014-07-09 14:25:50 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2013-12-03 14:41:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-21 10:28:34 +00:00
|
|
|
void TOOL_MANAGER::RunAction( const TOOL_ACTION& aAction, bool aNow, void* aParam )
|
2014-02-28 14:46:05 +00:00
|
|
|
{
|
2014-11-21 10:28:34 +00:00
|
|
|
TOOL_EVENT event = aAction.MakeEvent();
|
|
|
|
event.SetParameter( aParam );
|
|
|
|
|
2014-07-09 14:25:50 +00:00
|
|
|
if( aNow )
|
|
|
|
ProcessEvent( event );
|
|
|
|
else
|
2014-11-21 10:28:34 +00:00
|
|
|
PostEvent( event );
|
2014-02-28 14:46:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-19 15:02:57 +00:00
|
|
|
bool TOOL_MANAGER::invokeTool( TOOL_BASE* aTool )
|
2013-08-20 12:49:08 +00:00
|
|
|
{
|
2013-09-19 15:02:57 +00:00
|
|
|
wxASSERT( aTool != NULL );
|
2013-08-20 12:49:08 +00:00
|
|
|
|
2014-07-09 11:50:27 +00:00
|
|
|
TOOL_EVENT evt( TC_COMMAND, TA_ACTIVATE, aTool->GetName() );
|
2013-09-19 15:02:57 +00:00
|
|
|
ProcessEvent( evt );
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool TOOL_MANAGER::runTool( TOOL_ID aToolId )
|
|
|
|
{
|
|
|
|
TOOL_BASE* tool = FindTool( aToolId );
|
|
|
|
|
2013-10-14 18:40:36 +00:00
|
|
|
if( tool && tool->GetType() == INTERACTIVE )
|
2013-09-19 15:02:57 +00:00
|
|
|
return runTool( tool );
|
2013-08-30 08:37:26 +00:00
|
|
|
|
2013-09-27 16:51:21 +00:00
|
|
|
return false; // there is no tool with the given id
|
2013-08-20 12:49:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-19 15:02:57 +00:00
|
|
|
bool TOOL_MANAGER::runTool( const std::string& aToolName )
|
|
|
|
{
|
|
|
|
TOOL_BASE* tool = FindTool( aToolName );
|
|
|
|
|
2013-10-14 18:40:36 +00:00
|
|
|
if( tool && tool->GetType() == INTERACTIVE )
|
2013-09-19 15:02:57 +00:00
|
|
|
return runTool( tool );
|
|
|
|
|
2013-09-27 16:51:21 +00:00
|
|
|
return false; // there is no tool with the given name
|
2013-09-19 15:02:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool TOOL_MANAGER::runTool( TOOL_BASE* aTool )
|
|
|
|
{
|
|
|
|
wxASSERT( aTool != NULL );
|
|
|
|
|
|
|
|
if( !isRegistered( aTool ) )
|
2013-12-03 14:17:43 +00:00
|
|
|
{
|
|
|
|
wxASSERT_MSG( false, wxT( "You cannot run unregistered tools" ) );
|
2013-09-19 15:02:57 +00:00
|
|
|
return false;
|
2013-12-03 14:17:43 +00:00
|
|
|
}
|
2013-09-19 15:02:57 +00:00
|
|
|
|
2014-04-01 12:35:09 +00:00
|
|
|
// If the tool is already active, bring it to the top of the active tools stack
|
2014-01-07 13:11:53 +00:00
|
|
|
if( isActive( aTool ) )
|
2014-04-01 12:35:09 +00:00
|
|
|
{
|
|
|
|
m_activeTools.erase( std::find( m_activeTools.begin(), m_activeTools.end(),
|
|
|
|
aTool->GetId() ) );
|
|
|
|
m_activeTools.push_front( aTool->GetId() );
|
|
|
|
|
2013-09-19 15:02:57 +00:00
|
|
|
return false;
|
2014-04-01 12:35:09 +00:00
|
|
|
}
|
2013-10-14 14:13:35 +00:00
|
|
|
|
2013-12-09 09:42:38 +00:00
|
|
|
aTool->Reset( TOOL_INTERACTIVE::RUN );
|
2013-09-19 15:02:57 +00:00
|
|
|
|
|
|
|
// Add the tool on the front of the processing queue (it gets events first)
|
|
|
|
m_activeTools.push_front( aTool->GetId() );
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-20 12:49:08 +00:00
|
|
|
TOOL_BASE* TOOL_MANAGER::FindTool( int aId ) const
|
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
std::map<TOOL_ID, TOOL_STATE*>::const_iterator it = m_toolIdIndex.find( aId );
|
2013-08-20 12:49:08 +00:00
|
|
|
|
|
|
|
if( it != m_toolIdIndex.end() )
|
|
|
|
return it->second->theTool;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TOOL_BASE* TOOL_MANAGER::FindTool( const std::string& aName ) const
|
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
std::map<std::string, TOOL_STATE*>::const_iterator it = m_toolNameIndex.find( aName );
|
2013-08-20 12:49:08 +00:00
|
|
|
|
|
|
|
if( it != m_toolNameIndex.end() )
|
|
|
|
return it->second->theTool;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-09 09:42:38 +00:00
|
|
|
void TOOL_MANAGER::ResetTools( TOOL_BASE::RESET_REASON aReason )
|
|
|
|
{
|
2014-12-09 23:50:31 +00:00
|
|
|
TOOL_EVENT evt( TC_COMMAND, TA_ACTIVATE, "" ); // deactivate the active tool
|
|
|
|
ProcessEvent( evt );
|
|
|
|
|
2013-12-09 09:42:38 +00:00
|
|
|
BOOST_FOREACH( TOOL_BASE* tool, m_toolState | boost::adaptors::map_keys )
|
|
|
|
tool->Reset( aReason );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-04-09 15:05:05 +00:00
|
|
|
int TOOL_MANAGER::GetPriority( int aToolId ) const
|
|
|
|
{
|
|
|
|
int priority = 0;
|
|
|
|
|
|
|
|
for( std::deque<int>::const_iterator it = m_activeTools.begin(),
|
|
|
|
itEnd = m_activeTools.end(); it != itEnd; ++it )
|
|
|
|
{
|
|
|
|
if( *it == aToolId )
|
|
|
|
return priority;
|
|
|
|
|
|
|
|
++priority;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-20 12:49:08 +00:00
|
|
|
void TOOL_MANAGER::ScheduleNextState( TOOL_BASE* aTool, TOOL_STATE_FUNC& aHandler,
|
2013-08-06 08:30:09 +00:00
|
|
|
const TOOL_EVENT_LIST& aConditions )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-10-14 11:43:57 +00:00
|
|
|
TOOL_STATE* st = m_toolState[aTool];
|
2013-10-14 14:13:35 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
st->transitions.push_back( TRANSITION( aConditions, aHandler ) );
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:30:09 +00:00
|
|
|
|
2013-08-19 07:47:36 +00:00
|
|
|
optional<TOOL_EVENT> TOOL_MANAGER::ScheduleWait( TOOL_BASE* aTool,
|
2013-08-06 08:30:09 +00:00
|
|
|
const TOOL_EVENT_LIST& aConditions )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-10-14 11:43:57 +00:00
|
|
|
TOOL_STATE* st = m_toolState[aTool];
|
2013-09-27 16:51:21 +00:00
|
|
|
|
2014-07-09 14:25:50 +00:00
|
|
|
assert( !st->pendingWait ); // everything collapses on two Yield() in a row
|
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
// indicate to the manager that we are going to sleep and we shall be
|
|
|
|
// woken up when an event matching aConditions arrive
|
|
|
|
st->pendingWait = true;
|
|
|
|
st->waitEvents = aConditions;
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
// switch context back to event dispatcher loop
|
|
|
|
st->cofunc->Yield();
|
|
|
|
|
|
|
|
return st->wakeupEvent;
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:30:09 +00:00
|
|
|
|
2015-02-14 20:28:47 +00:00
|
|
|
void TOOL_MANAGER::dispatchInternal( const TOOL_EVENT& aEvent )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-10-14 11:43:57 +00:00
|
|
|
// iterate over all registered tools
|
2013-08-30 08:37:26 +00:00
|
|
|
BOOST_FOREACH( TOOL_ID toolId, m_activeTools )
|
|
|
|
{
|
2013-09-02 12:21:12 +00:00
|
|
|
TOOL_STATE* st = m_toolIdIndex[toolId];
|
2013-08-30 08:37:26 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
// the tool state handler is waiting for events (i.e. called Wait() method)
|
|
|
|
if( st->pendingWait )
|
|
|
|
{
|
|
|
|
if( st->waitEvents.Matches( aEvent ) )
|
|
|
|
{
|
2014-07-09 13:10:32 +00:00
|
|
|
// By default, only messages are passed further
|
|
|
|
m_passEvent = ( aEvent.m_category == TC_MESSAGE );
|
2013-10-14 11:43:57 +00:00
|
|
|
|
|
|
|
// got matching event? clear wait list and wake up the coroutine
|
|
|
|
st->wakeupEvent = aEvent;
|
|
|
|
st->pendingWait = false;
|
|
|
|
st->waitEvents.clear();
|
2013-10-14 14:13:35 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
if( st->cofunc && !st->cofunc->Resume() )
|
2013-10-14 14:13:35 +00:00
|
|
|
finishTool( st ); // The couroutine has finished
|
2013-10-14 11:43:57 +00:00
|
|
|
|
|
|
|
// If the tool did not request to propagate
|
|
|
|
// the event to other tools, we should stop it now
|
|
|
|
if( !m_passEvent )
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-08-30 08:37:26 +00:00
|
|
|
}
|
|
|
|
|
2013-09-02 12:21:12 +00:00
|
|
|
BOOST_FOREACH( TOOL_STATE* st, m_toolState | boost::adaptors::map_values )
|
2013-08-30 08:37:26 +00:00
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
// no state handler in progress - check if there are any transitions (defined by
|
|
|
|
// Go() method that match the event.
|
|
|
|
if( !st->pendingWait && !st->transitions.empty() )
|
2013-10-14 11:43:57 +00:00
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
BOOST_FOREACH( TRANSITION& tr, st->transitions )
|
2013-10-14 11:43:57 +00:00
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
if( tr.first.Matches( aEvent ) )
|
2013-10-14 11:43:57 +00:00
|
|
|
{
|
2014-07-09 14:25:50 +00:00
|
|
|
// if there is already a context, then store it
|
2014-07-09 11:50:27 +00:00
|
|
|
if( st->cofunc )
|
|
|
|
st->Push();
|
|
|
|
|
|
|
|
// as the state changes, the transition table has to be set up again
|
|
|
|
st->transitions.clear();
|
|
|
|
|
2015-02-14 20:28:47 +00:00
|
|
|
st->cofunc = new COROUTINE<int, const TOOL_EVENT&>( tr.second );
|
2014-07-09 11:50:27 +00:00
|
|
|
|
|
|
|
// got match? Run the handler.
|
|
|
|
st->cofunc->Call( aEvent );
|
|
|
|
|
|
|
|
if( !st->cofunc->Running() )
|
|
|
|
finishTool( st ); // The couroutine has finished immediately?
|
|
|
|
|
|
|
|
// there is no point in further checking, as transitions got cleared
|
|
|
|
break;
|
2013-10-14 11:43:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:30:09 +00:00
|
|
|
|
2015-02-14 20:28:47 +00:00
|
|
|
bool TOOL_MANAGER::dispatchStandardEvents( const TOOL_EVENT& aEvent )
|
2013-09-27 16:51:21 +00:00
|
|
|
{
|
2014-04-09 15:33:22 +00:00
|
|
|
if( aEvent.Action() == TA_KEY_PRESSED )
|
2013-09-27 16:51:21 +00:00
|
|
|
{
|
|
|
|
// Check if there is a hotkey associated
|
|
|
|
if( m_actionMgr->RunHotKey( aEvent.Modifier() | aEvent.KeyCode() ) )
|
2014-07-09 11:50:27 +00:00
|
|
|
return false; // hotkey event was handled so it does not go any further
|
2013-09-27 16:51:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-14 20:28:47 +00:00
|
|
|
bool TOOL_MANAGER::dispatchActivation( const TOOL_EVENT& aEvent )
|
2013-09-19 15:02:57 +00:00
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
if( aEvent.IsActivate() )
|
2013-09-19 15:02:57 +00:00
|
|
|
{
|
2014-07-09 11:50:27 +00:00
|
|
|
std::map<std::string, TOOL_STATE*>::iterator tool = m_toolNameIndex.find( *aEvent.m_commandStr );
|
|
|
|
|
|
|
|
if( tool != m_toolNameIndex.end() )
|
|
|
|
{
|
|
|
|
runTool( tool->second->theTool );
|
|
|
|
return true;
|
|
|
|
}
|
2013-09-19 15:02:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-14 20:28:47 +00:00
|
|
|
void TOOL_MANAGER::dispatchContextMenu( const TOOL_EVENT& aEvent )
|
2013-08-30 08:37:26 +00:00
|
|
|
{
|
|
|
|
BOOST_FOREACH( TOOL_ID toolId, m_activeTools )
|
|
|
|
{
|
2013-09-02 12:21:12 +00:00
|
|
|
TOOL_STATE* st = m_toolIdIndex[toolId];
|
2013-08-30 08:37:26 +00:00
|
|
|
|
2013-09-27 16:51:21 +00:00
|
|
|
// the tool requested a context menu. The menu is activated on RMB click (CMENU_BUTTON mode)
|
|
|
|
// or immediately (CMENU_NOW) mode. The latter is used for clarification lists.
|
2013-10-14 11:43:57 +00:00
|
|
|
if( st->contextMenuTrigger != CMENU_OFF )
|
|
|
|
{
|
2013-10-15 08:41:00 +00:00
|
|
|
if( st->contextMenuTrigger == CMENU_BUTTON && !aEvent.IsClick( BUT_RIGHT ) )
|
2013-10-14 11:43:57 +00:00
|
|
|
break;
|
2013-09-26 12:09:18 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
st->pendingWait = true;
|
2013-10-14 18:40:36 +00:00
|
|
|
st->waitEvents = TOOL_EVENT( TC_ANY, TA_ANY );
|
2013-09-26 12:09:18 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
if( st->contextMenuTrigger == CMENU_NOW )
|
|
|
|
st->contextMenuTrigger = CMENU_OFF;
|
2013-09-26 12:09:18 +00:00
|
|
|
|
2014-07-09 14:50:31 +00:00
|
|
|
// Temporarily store the cursor position, so the tools could execute actions
|
|
|
|
// using the point where the user has invoked a context menu
|
|
|
|
m_viewControls->ForceCursorPosition( true, m_viewControls->GetCursorPosition() );
|
|
|
|
|
2013-09-26 12:09:18 +00:00
|
|
|
boost::scoped_ptr<CONTEXT_MENU> menu( new CONTEXT_MENU( *st->contextMenu ) );
|
2014-05-13 09:22:51 +00:00
|
|
|
GetEditFrame()->PopupMenu( menu.get() );
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2013-11-29 15:45:39 +00:00
|
|
|
// If nothing was chosen from the context menu, we must notify the tool as well
|
|
|
|
if( menu->GetSelected() < 0 )
|
|
|
|
{
|
2014-05-22 15:59:36 +00:00
|
|
|
TOOL_EVENT evt( TC_COMMAND, TA_CONTEXT_MENU_CHOICE, -1 );
|
2013-11-29 15:45:39 +00:00
|
|
|
dispatchInternal( evt );
|
|
|
|
}
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2014-07-09 14:50:31 +00:00
|
|
|
m_viewControls->ForceCursorPosition( false );
|
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-07-09 11:50:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void TOOL_MANAGER::finishTool( TOOL_STATE* aState )
|
|
|
|
{
|
|
|
|
if( !aState->Pop() ) // if there are no other contexts saved on the stack
|
|
|
|
{
|
|
|
|
// find the tool and deactivate it
|
|
|
|
std::deque<TOOL_ID>::iterator tool = std::find( m_activeTools.begin(), m_activeTools.end(),
|
|
|
|
aState->theTool->GetId() );
|
|
|
|
|
|
|
|
if( tool != m_activeTools.end() )
|
|
|
|
m_activeTools.erase( tool );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-14 20:28:47 +00:00
|
|
|
bool TOOL_MANAGER::ProcessEvent( const TOOL_EVENT& aEvent )
|
2014-07-09 11:50:27 +00:00
|
|
|
{
|
|
|
|
// Early dispatch of events destined for the TOOL_MANAGER
|
|
|
|
if( !dispatchStandardEvents( aEvent ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
dispatchInternal( aEvent );
|
|
|
|
dispatchActivation( aEvent );
|
|
|
|
dispatchContextMenu( aEvent );
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2014-07-09 14:25:50 +00:00
|
|
|
// Dispatch queue
|
|
|
|
while( !m_eventQueue.empty() )
|
|
|
|
{
|
|
|
|
TOOL_EVENT event = m_eventQueue.front();
|
|
|
|
m_eventQueue.pop_front();
|
|
|
|
ProcessEvent( event );
|
|
|
|
}
|
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
if( m_view->IsDirty() )
|
|
|
|
{
|
2015-02-19 13:53:31 +00:00
|
|
|
EDA_DRAW_FRAME* f = static_cast<EDA_DRAW_FRAME*>( GetEditFrame() );
|
2014-05-13 09:22:51 +00:00
|
|
|
f->GetGalCanvas()->Refresh(); // fixme: ugly hack, provide a method in TOOL_DISPATCHER.
|
2013-10-14 11:43:57 +00:00
|
|
|
}
|
2013-08-02 14:46:53 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
return false;
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:30:09 +00:00
|
|
|
|
|
|
|
void TOOL_MANAGER::ScheduleContextMenu( TOOL_BASE* aTool, CONTEXT_MENU* aMenu,
|
2013-09-02 12:21:12 +00:00
|
|
|
CONTEXT_MENU_TRIGGER aTrigger )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-10-14 11:43:57 +00:00
|
|
|
TOOL_STATE* st = m_toolState[aTool];
|
|
|
|
|
|
|
|
st->contextMenu = aMenu;
|
|
|
|
st->contextMenuTrigger = aTrigger;
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 08:30:09 +00:00
|
|
|
|
2014-07-09 12:01:07 +00:00
|
|
|
bool TOOL_MANAGER::SaveClipboard( const std::string& aText )
|
|
|
|
{
|
|
|
|
if( wxTheClipboard->Open() )
|
|
|
|
{
|
2014-07-09 12:23:13 +00:00
|
|
|
wxTheClipboard->SetData( new wxTextDataObject( wxString( aText.c_str(), wxConvUTF8 ) ) );
|
2014-07-09 12:01:07 +00:00
|
|
|
wxTheClipboard->Close();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
std::string TOOL_MANAGER::GetClipboard() const
|
|
|
|
{
|
|
|
|
std::string result;
|
|
|
|
|
|
|
|
if( wxTheClipboard->Open() )
|
|
|
|
{
|
|
|
|
if( wxTheClipboard->IsSupported( wxDF_TEXT ) )
|
|
|
|
{
|
|
|
|
wxTextDataObject data;
|
|
|
|
wxTheClipboard->GetData( data );
|
|
|
|
|
|
|
|
result = data.GetText().mb_str();
|
|
|
|
}
|
|
|
|
|
|
|
|
wxTheClipboard->Close();
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-06 08:30:09 +00:00
|
|
|
TOOL_ID TOOL_MANAGER::MakeToolId( const std::string& aToolName )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-10-14 11:43:57 +00:00
|
|
|
static int currentId;
|
2013-10-14 14:13:35 +00:00
|
|
|
|
2013-10-14 11:43:57 +00:00
|
|
|
return currentId++;
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
|
|
|
|
2013-08-07 08:52:50 +00:00
|
|
|
|
2013-10-14 14:13:35 +00:00
|
|
|
void TOOL_MANAGER::SetEnvironment( EDA_ITEM* aModel, KIGFX::VIEW* aView,
|
|
|
|
KIGFX::VIEW_CONTROLS* aViewControls, wxWindow* aFrame )
|
2013-08-02 14:46:53 +00:00
|
|
|
{
|
2013-10-14 11:43:57 +00:00
|
|
|
m_model = aModel;
|
|
|
|
m_view = aView;
|
|
|
|
m_viewControls = aViewControls;
|
|
|
|
m_editFrame = aFrame;
|
2013-08-02 14:46:53 +00:00
|
|
|
}
|
2013-09-19 15:02:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
bool TOOL_MANAGER::isActive( TOOL_BASE* aTool )
|
|
|
|
{
|
|
|
|
if( !isRegistered( aTool ) )
|
|
|
|
return false;
|
|
|
|
|
2014-01-07 13:11:53 +00:00
|
|
|
// Just check if the tool is on the active tools stack
|
|
|
|
return std::find( m_activeTools.begin(), m_activeTools.end(), aTool->GetId() ) != m_activeTools.end();
|
2013-09-19 15:02:57 +00:00
|
|
|
}
|