KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pl_edit_tool.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2019 CERN
5 * Copyright (C) 2019-2023 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <wx/log.h>
26#include <wx/msgdlg.h>
27#include <fmt/format.h>
28
29#include <tool/tool_manager.h>
30#include <tool/picker_tool.h>
34#include <bitmaps.h>
35#include <confirm.h>
36#include <eda_item.h>
37#include <macros.h>
38#include <string_utils.h>
39#include <view/view.h>
40#include <view/view_controls.h>
41#include <math/util.h> // for KiROUND
42
44#include "tools/pl_actions.h"
45#include "tools/pl_edit_tool.h"
46#include "pl_draw_panel_gal.h"
47#include "pl_editor_frame.h"
48#include "pl_editor_id.h"
49
51 TOOL_INTERACTIVE( "plEditor.InteractiveEdit" ),
52 m_frame( nullptr ),
53 m_selectionTool( nullptr ),
54 m_moveInProgress( false ),
55 m_moveOffset( 0, 0 ),
56 m_cursor( 0, 0 ),
57 m_pickerItem( nullptr )
58{
59}
60
61
63{
64 m_frame = getEditFrame<PL_EDITOR_FRAME>();
66
67 wxASSERT_MSG( m_selectionTool, "plEditor.InteractiveSelection tool is not available" );
68
69 CONDITIONAL_MENU& ctxMenu = m_menu.GetMenu();
70
71 // cancel current tool goes in main context menu at the top if present
73
74 ctxMenu.AddSeparator( 200 );
76
77 // Finally, add the standard zoom/grid items
79
80 //
81 // Add editing actions to the selection tool menu
82 //
84
86
87 selToolMenu.AddSeparator( 250 );
92
93 return true;
94}
95
96
98{
99 if( aReason == MODEL_RELOAD )
100 m_frame = getEditFrame<PL_EDITOR_FRAME>();
101}
102
103
104int PL_EDIT_TOOL::Main( const TOOL_EVENT& aEvent )
105{
107
108 VECTOR2I originalCursorPos = controls->GetCursorPosition();
109
110 // Be sure that there is at least one item that we can move. If there's no selection try
111 // looking for the stuff under mouse cursor (i.e. Kicad old-style hover selection).
113 bool unselect = selection.IsHover();
114
115 if( selection.Empty() || m_moveInProgress )
116 return 0;
117
118 std::set<DS_DATA_ITEM*> unique_peers;
119
120 for( EDA_ITEM* item : selection )
121 {
122 DS_DRAW_ITEM_BASE* drawItem = static_cast<DS_DRAW_ITEM_BASE*>( item );
123 unique_peers.insert( drawItem->GetPeer() );
124 }
125
126 m_frame->PushTool( aEvent );
127
128 Activate();
129 // Must be done after Activate() so that it gets set into the correct context
130 controls->ShowCursor( true );
131 controls->SetAutoPan( true );
132
133 bool restore_state = false;
134 bool chain_commands = false;
135 TOOL_EVENT copy = aEvent;
136 TOOL_EVENT* evt = &copy;
137 VECTOR2I prevPos;
138
139 if( !selection.Front()->IsNew() )
140 {
141 try
142 {
144 }
145 catch( const fmt::v10::format_error& exc )
146 {
147 wxLogWarning( wxS( "Exception \"%s\" serializing string ocurred." ),
148 exc.what() );
149 return 1;
150 }
151 }
152
153 // Main loop: keep receiving events
154 do
155 {
156 m_frame->GetCanvas()->SetCurrentCursor( KICURSOR::MOVING );
157
158 if( evt->IsAction( &PL_ACTIONS::move ) || evt->IsMotion() || evt->IsDrag( BUT_LEFT )
160 {
161 //------------------------------------------------------------------------
162 // Start a move operation
163 //
164 if( !m_moveInProgress )
165 {
166 // Apply any initial offset in case we're coming from a previous command.
167 //
168 for( DS_DATA_ITEM* item : unique_peers )
169 moveItem( item, m_moveOffset );
170
171 // Set up the starting position and move/drag offset
172 //
173 m_cursor = controls->GetCursorPosition();
174
175 if( selection.HasReferencePoint() )
176 {
178
179 // Drag items to the current cursor position
180 for( DS_DATA_ITEM* item : unique_peers )
181 moveItem( item, delta );
182
183 selection.SetReferencePoint( m_cursor );
184 }
185 else if( selection.Size() == 1 )
186 {
187 // Set the current cursor position to the first dragged item origin,
188 // so the movement vector can be computed later
189 updateModificationPoint( selection );
190 m_cursor = originalCursorPos;
191 }
192 else
193 {
194 updateModificationPoint( selection );
195 }
196
197 controls->SetCursorPosition( m_cursor, false );
198
199 prevPos = m_cursor;
200 controls->SetAutoPan( true );
201 m_moveInProgress = true;
202 }
203
204 //------------------------------------------------------------------------
205 // Follow the mouse
206 //
207 m_cursor = controls->GetCursorPosition();
208 VECTOR2I delta( m_cursor - prevPos );
209 selection.SetReferencePoint( m_cursor );
210
212 prevPos = m_cursor;
213
214 for( DS_DATA_ITEM* item : unique_peers )
215 moveItem( item, delta );
216
218 }
219 //------------------------------------------------------------------------
220 // Handle cancel
221 //
222 else if( evt->IsCancelInteractive() || evt->IsActivate() )
223 {
224 if( evt->IsCancelInteractive() )
226
227 if( m_moveInProgress )
228 {
229 if( evt->IsActivate() )
230 {
231 // Allowing other tools to activate during a move runs the risk of race
232 // conditions in which we try to spool up both event loops at once.
233
234 m_frame->ShowInfoBarMsg( _( "Press <ESC> to cancel move." ) );
235
236 evt->SetPassEvent( false );
237 continue;
238 }
239
240 evt->SetPassEvent( false );
241 restore_state = true;
242 }
243
244 break;
245 }
246 //------------------------------------------------------------------------
247 // Handle TOOL_ACTION special cases
248 //
249 else if( evt->Action() == TA_UNDO_REDO_PRE )
250 {
251 unselect = true;
252 break;
253 }
254 else if( evt->IsAction( &ACTIONS::doDelete ) )
255 {
256 evt->SetPassEvent();
257 // Exit on a delete; there will no longer be anything to drag.
258 break;
259 }
260 else if( evt->IsAction( &ACTIONS::duplicate ) )
261 {
262 if( selection.Front()->IsNew() )
263 {
264 // This doesn't really make sense; we'll just end up dragging a stack of
265 // objects so we ignore the duplicate and just carry on.
266 continue;
267 }
268
269 // Move original back and exit. The duplicate will run in its own loop.
270 restore_state = true;
271 unselect = false;
272 chain_commands = true;
273 break;
274 }
275 //------------------------------------------------------------------------
276 // Handle context menu
277 //
278 else if( evt->IsClick( BUT_RIGHT ) )
279 {
281 }
282 //------------------------------------------------------------------------
283 // Handle drop
284 //
285 else if( evt->IsMouseUp( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) )
286 {
287 break; // Finish
288 }
289 else
290 {
291 evt->SetPassEvent();
292 }
293
294 controls->SetAutoPan( m_moveInProgress );
295
296 } while( ( evt = Wait() ) ); //Should be assignment not equality test
297
298 controls->ForceCursorPosition( false );
299 controls->ShowCursor( false );
300 controls->SetAutoPan( false );
301
302 if( !chain_commands )
303 m_moveOffset = { 0, 0 };
304
305 selection.ClearReferencePoint();
306
307 for( EDA_ITEM* item : selection )
308 item->ClearEditFlags();
309
310 if( restore_state )
312 else
313 m_frame->OnModify();
314
315 if( unselect )
317 else
319
320 m_moveInProgress = false;
321 m_frame->PopTool( aEvent );
322 return 0;
323}
324
325
326void PL_EDIT_TOOL::moveItem( DS_DATA_ITEM* aItem, const VECTOR2I& aDelta )
327{
328 aItem->MoveToIU( aItem->GetStartPosIU() + aDelta );
329
330 for( DS_DRAW_ITEM_BASE* item : aItem->GetDrawItems() )
331 {
332 getView()->Update( item );
333 item->SetFlags( IS_MOVING );
334 }
335}
336
337
339{
340 if( m_moveInProgress && aSelection.HasReferencePoint() )
341 return false;
342
343 // When there is only one item selected, the reference point is its position...
344 if( aSelection.Size() == 1 )
345 {
346 aSelection.SetReferencePoint( aSelection.Front()->GetPosition() );
347 }
348 // ...otherwise modify items with regard to the grid-snapped cursor position
349 else
350 {
352 aSelection.SetReferencePoint( m_cursor );
353 }
354
355 return true;
356}
357
358
360{
362
363 wxCommandEvent evt( wxEVT_NULL, ID_APPEND_DESCR_FILE );
364 m_frame->Files_io( evt );
365
366 return 0;
367}
368
369
371{
373
374 if( selection.Size() == 0 )
375 return 0;
376
377
378 // Do not delete an item if it is currently a new item being created to avoid a crash
379 // In this case the selection contains only one item.
380 DS_DRAW_ITEM_BASE* currItem = static_cast<DS_DRAW_ITEM_BASE*>( selection.Front() );
381
382 if( currItem->GetFlags() & ( IS_NEW ) )
383 return 0;
384
386
387 while( selection.Front() )
388 {
389 DS_DRAW_ITEM_BASE* drawItem = static_cast<DS_DRAW_ITEM_BASE*>( selection.Front() );
390 DS_DATA_ITEM* dataItem = drawItem->GetPeer();
392
393 for( DS_DRAW_ITEM_BASE* item : dataItem->GetDrawItems() )
394 {
395 // Note: repeat items won't be selected but must be removed & deleted
396
397 if( item->IsSelected() )
399
400 getView()->Remove( item );
401 }
402
403 delete dataItem;
404 }
405
406 m_frame->OnModify();
407
408 return 0;
409}
410
411
412#define HITTEST_THRESHOLD_PIXELS 5
413
414
416{
418
419 // Deactivate other tools; particularly important if another PICKER is currently running
420 Activate();
421
422 picker->SetCursor( KICURSOR::REMOVE );
423 m_pickerItem = nullptr;
424
425 picker->SetClickHandler(
426 [this] ( const VECTOR2D& aPosition ) -> bool
427 {
428 if( m_pickerItem )
429 {
431 selectionTool->UnbrightenItem( m_pickerItem );
432 selectionTool->AddItemToSel( m_pickerItem, true /*quiet mode*/ );
434 m_pickerItem = nullptr;
435 }
436
437 return true;
438 } );
439
440 picker->SetMotionHandler(
441 [this] ( const VECTOR2D& aPos )
442 {
443 int threshold = KiROUND( getView()->ToWorld( HITTEST_THRESHOLD_PIXELS ) );
444 EDA_ITEM* item = nullptr;
445
446 for( DS_DATA_ITEM* dataItem : DS_DATA_MODEL::GetTheInstance().GetItems() )
447 {
448 for( DS_DRAW_ITEM_BASE* drawItem : dataItem->GetDrawItems() )
449 {
450 if( drawItem->HitTest( aPos, threshold ) )
451 {
452 item = drawItem;
453 break;
454 }
455 }
456 }
457
458 if( m_pickerItem != item )
459 {
461
462 if( m_pickerItem )
463 selectionTool->UnbrightenItem( m_pickerItem );
464
465 m_pickerItem = item;
466
467 if( m_pickerItem )
468 selectionTool->BrightenItem( m_pickerItem );
469 }
470 } );
471
472 picker->SetFinalizeHandler(
473 [this] ( const int& aFinalState )
474 {
475 if( m_pickerItem )
476 m_toolMgr->GetTool<PL_SELECTION_TOOL>()->UnbrightenItem( m_pickerItem );
477
478 // Wake the selection tool after exiting to ensure the cursor gets updated
480 } );
481
483
484 return 0;
485}
486
487
488int PL_EDIT_TOOL::Undo( const TOOL_EVENT& aEvent )
489{
491 return 0;
492}
493
494
495int PL_EDIT_TOOL::Redo( const TOOL_EVENT& aEvent )
496{
498 return 0;
499}
500
501
502int PL_EDIT_TOOL::Cut( const TOOL_EVENT& aEvent )
503{
504 int retVal = Copy( aEvent );
505
506 if( retVal == 0 )
507 retVal = DoDelete( aEvent );
508
509 return retVal;
510}
511
512
513int PL_EDIT_TOOL::Copy( const TOOL_EVENT& aEvent )
514{
516 std::vector<DS_DATA_ITEM*> items;
518 wxString sexpr;
519
520 if( selection.GetSize() == 0 )
521 return 0;
522
523 for( EDA_ITEM* item : selection.GetItems() )
524 items.push_back( static_cast<DS_DRAW_ITEM_BASE*>( item )->GetPeer() );
525
526 try
527 {
528 model.SaveInString( items, &sexpr );
529 }
530 catch( const IO_ERROR& ioe )
531 {
532 wxMessageBox( ioe.What(), _( "Error writing objects to clipboard" ) );
533 }
534
535 if( m_toolMgr->SaveClipboard( TO_UTF8( sexpr ) ) )
536 return 0;
537 else
538 return -1;
539}
540
541
542int PL_EDIT_TOOL::Paste( const TOOL_EVENT& aEvent )
543{
546 std::string sexpr = m_toolMgr->GetClipboardUTF8();
547
549
550 model.SetPageLayout( sexpr.c_str(), true, wxT( "clipboard" ) );
551
552 // Build out draw items and select the first of each data item
553 for( DS_DATA_ITEM* dataItem : model.GetItems() )
554 {
555 if( dataItem->GetDrawItems().empty() )
556 {
557 dataItem->SyncDrawItems( nullptr, getView() );
558 dataItem->GetDrawItems().front()->SetSelected();
559 }
560 }
561
563
564 if( !selection.Empty() )
565 {
566 selection.SetReferencePoint( selection.GetTopLeftItem()->GetPosition() );
568 }
569
570 return 0;
571}
572
573
575{
576 Go( &PL_EDIT_TOOL::Main, PL_ACTIONS::move.MakeEvent() );
577
579
580 Go( &PL_EDIT_TOOL::Undo, ACTIONS::undo.MakeEvent() );
581 Go( &PL_EDIT_TOOL::Redo, ACTIONS::redo.MakeEvent() );
582
583 Go( &PL_EDIT_TOOL::Cut, ACTIONS::cut.MakeEvent() );
584 Go( &PL_EDIT_TOOL::Copy, ACTIONS::copy.MakeEvent() );
585 Go( &PL_EDIT_TOOL::Paste, ACTIONS::paste.MakeEvent() );
587
589}
static TOOL_ACTION paste
Definition: actions.h:71
static TOOL_ACTION cancelInteractive
Definition: actions.h:64
static TOOL_ACTION copy
Definition: actions.h:70
static TOOL_ACTION pickerTool
Definition: actions.h:193
static TOOL_ACTION undo
Definition: actions.h:67
static TOOL_ACTION duplicate
Definition: actions.h:75
static TOOL_ACTION doDelete
Definition: actions.h:76
static TOOL_ACTION redo
Definition: actions.h:68
static TOOL_ACTION deleteTool
Definition: actions.h:77
static TOOL_ACTION cut
Definition: actions.h:69
static TOOL_ACTION refreshPreview
Definition: actions.h:138
void AddItem(const TOOL_ACTION &aAction, const SELECTION_CONDITION &aCondition, int aOrder=ANY_ORDER)
Add a menu entry to run a TOOL_ACTION on selected items.
void AddSeparator(int aOrder=ANY_ORDER)
Add a separator to the menu.
Drawing sheet structure type definitions.
Definition: ds_data_item.h:96
void MoveToIU(const VECTOR2I &aPosition)
Move item to a new position.
const VECTOR2I GetStartPosIU(int ii=0) const
const std::vector< DS_DRAW_ITEM_BASE * > & GetDrawItems() const
Definition: ds_data_item.h:110
Handle the graphic items list to draw/plot the frame and title block.
Definition: ds_data_model.h:39
static DS_DATA_MODEL & GetTheInstance()
static function: returns the instance of DS_DATA_MODEL used in the application
void SaveInString(wxString *aOutputString)
Save the description in a buffer.
void Remove(DS_DATA_ITEM *aItem)
std::vector< DS_DATA_ITEM * > & GetItems()
void SetPageLayout(const char *aPageLayout, bool aAppend=false, const wxString &aSource=wxT("Sexpr_string"))
Populate the list from a S expr description stored in a string.
Base class to handle basic graphic items.
Definition: ds_draw_item.h:59
DS_DATA_ITEM * GetPeer() const
Definition: ds_draw_item.h:63
void ShowInfoBarMsg(const wxString &aMsg, bool aShowCloseButton=false)
Show the WX_INFOBAR displayed on the top of the canvas with a message and an info icon on the left of...
WX_INFOBAR * GetInfoBar()
void AddStandardSubMenus(TOOL_MENU &aMenu)
Construct a "basic" menu for a tool, containing only items that apply to all tools (e....
void SetCurrentCursor(KICURSOR aCursor)
Set the current cursor shape for this panel.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:88
virtual VECTOR2I GetPosition() const
Definition: eda_item.h:242
EDA_ITEM_FLAGS GetFlags() const
Definition: eda_item.h:129
bool IsNew() const
Definition: eda_item.h:106
static const TOOL_EVENT SelectedEvent
Definition: actions.h:264
static const TOOL_EVENT SelectedItemsMoved
Used to inform tools that the selection should temporarily be non-editable.
Definition: actions.h:274
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:77
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
An interface for classes handling user events controlling the view behavior such as zooming,...
virtual void ForceCursorPosition(bool aEnabled, const VECTOR2D &aPosition=VECTOR2D(0, 0))
Place the cursor immediately at a given point.
virtual void ShowCursor(bool aEnabled)
Enable or disables display of cursor.
VECTOR2D GetCursorPosition() const
Return the current cursor position in world coordinates.
virtual void SetCursorPosition(const VECTOR2D &aPosition, bool aWarpView=true, bool aTriggeredByArrows=false, long aArrowCommand=0)=0
Move cursor to the requested position expressed in world coordinates.
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
Definition: view.cpp:354
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
Definition: view.cpp:1631
void SetMotionHandler(MOTION_HANDLER aHandler)
Set a handler for mouse motion.
Definition: picker_tool.h:83
void SetClickHandler(CLICK_HANDLER aHandler)
Set a handler for mouse click event.
Definition: picker_tool.h:72
void SetCursor(KICURSOR aCursor)
Definition: picker_tool.h:63
void SetFinalizeHandler(FINALIZE_HANDLER aHandler)
Set a handler for the finalize event.
Definition: picker_tool.h:103
static TOOL_ACTION clearSelection
Clear the current selection.
Definition: pl_actions.h:43
static TOOL_ACTION selectionActivate
Activation of the selection tool.
Definition: pl_actions.h:40
static TOOL_ACTION appendImportedDrawingSheet
Definition: pl_actions.h:62
static TOOL_ACTION move
Definition: pl_actions.h:65
void OnModify() override
Must be called after a change in order to set the "modify" flag.
void Files_io(wxCommandEvent &event)
void GetLayoutFromRedoList()
Redo the last edit:
void GetLayoutFromUndoList()
Undo the last edit:
void RollbackFromUndo()
Apply the last command in Undo List without stacking a Redo.
void SaveCopyInUndoList()
Save a copy of the description (in a S expr string) for Undo/redo commands.
PL_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
bool Init() override
Init() is called once upon a registration of the tool.
int Redo(const TOOL_EVENT &aEvent)
int DoDelete(const TOOL_EVENT &aEvent)
Delete the selected items, or the item under the cursor.
int ImportDrawingSheetContent(const TOOL_EVENT &aEvent)
bool m_moveInProgress
Used for chaining commands.
Definition: pl_edit_tool.h:83
int Main(const TOOL_EVENT &aEvent)
The "move" event loop.
int Cut(const TOOL_EVENT &aEvent)
bool updateModificationPoint(PL_SELECTION &aSelection)
Set up handlers for various events.
PL_SELECTION_TOOL * m_selectionTool
Flag determining if anything is being dragged right now.
Definition: pl_edit_tool.h:80
void moveItem(DS_DATA_ITEM *aItem, const VECTOR2I &aDelta)
Return the right modification point (e.g.
int InteractiveDelete(const TOOL_EVENT &aEvent)
VECTOR2I m_moveOffset
Last cursor position (needed for getModificationPoint() to avoid changes of edit reference point).
Definition: pl_edit_tool.h:86
VECTOR2I m_cursor
Definition: pl_edit_tool.h:90
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
int Paste(const TOOL_EVENT &aEvent)
void setTransitions() override
This method is meant to be overridden in order to specify handlers for events.
EDA_ITEM * m_pickerItem
Definition: pl_edit_tool.h:92
int Undo(const TOOL_EVENT &aEvent)
PL_EDITOR_FRAME * m_frame
Definition: pl_edit_tool.h:79
int Copy(const TOOL_EVENT &aEvent)
int ClearSelection(const TOOL_EVENT &aEvent)
PL_SELECTION & GetSelection()
Return the set of currently selected items.
PL_SELECTION & RequestSelection()
Return either an existing selection (filtered), or the selection at the current cursor if the existin...
void RebuildSelection()
Rebuild the selection from the flags in the view items.
EDA_ITEM * GetTopLeftItem(bool onlyModules=false) const override
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
static bool ShowAlways(const SELECTION &aSelection)
The default condition function (always returns true).
int RemoveItemFromSel(const TOOL_EVENT &aEvent)
void BrightenItem(EDA_ITEM *aItem)
int AddItemToSel(const TOOL_EVENT &aEvent)
void UnbrightenItem(EDA_ITEM *aItem)
const std::deque< EDA_ITEM * > GetItems() const
Definition: selection.h:121
VECTOR2I GetReferencePoint() const
Definition: selection.cpp:170
bool IsHover() const
Definition: selection.h:84
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:100
EDA_ITEM * Front() const
Definition: selection.h:172
int Size() const
Returns the number of selected parts.
Definition: selection.h:116
void ClearReferencePoint()
Definition: selection.cpp:185
void SetReferencePoint(const VECTOR2I &aP)
Definition: selection.cpp:179
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:110
bool HasReferencePoint() const
Definition: selection.h:211
virtual void PopTool(const TOOL_EVENT &aEvent)
Pops a tool from the stack.
virtual void PushTool(const TOOL_EVENT &aEvent)
NB: the definition of "tool" is different at the user level.
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:42
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:217
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:36
RESET_REASON
Determine the reason of reset for a tool.
Definition: tool_base.h:78
@ MODEL_RELOAD
Model changes (the sheet for a schematic)
Definition: tool_base.h:80
Generic, UI-independent tool event.
Definition: tool_event.h:167
bool IsCancelInteractive() const
Indicate the event should restart/end an ongoing interactive tool's event loop (eg esc key,...
Definition: tool_event.cpp:221
TOOL_ACTIONS Action() const
These give a tool a method of informing the TOOL_MANAGER that a particular event should be passed on ...
Definition: tool_event.h:246
bool IsActivate() const
Definition: tool_event.h:337
bool IsClick(int aButtonMask=BUT_ANY) const
Definition: tool_event.cpp:209
bool IsDrag(int aButtonMask=BUT_ANY) const
Definition: tool_event.h:307
bool IsAction(const TOOL_ACTION *aAction) const
Test if the event contains an action issued upon activation of the given TOOL_ACTION.
Definition: tool_event.cpp:82
void SetPassEvent(bool aPass=true)
Returns if it this event has a valid position (true for mouse events and context-menu or hotkey-based...
Definition: tool_event.h:252
bool IsMouseUp(int aButtonMask=BUT_ANY) const
Definition: tool_event.h:317
bool IsMotion() const
Definition: tool_event.h:322
void Go(int(T::*aStateFunc)(const TOOL_EVENT &), const TOOL_EVENT_LIST &aConditions=TOOL_EVENT(TC_ANY, TA_ANY))
Define which state (aStateFunc) to go when a certain event arrives (aConditions).
TOOL_MENU & GetToolMenu()
TOOL_MENU m_menu
The functions below are not yet implemented - their interface may change.
TOOL_EVENT * Wait(const TOOL_EVENT_LIST &aEventList=TOOL_EVENT(TC_ANY, TA_ANY))
Suspend execution of the tool until an event specified in aEventList arrives.
void Activate()
Run the tool.
void PostEvent(const TOOL_EVENT &aEvent)
Put an event to the event queue to be processed at the end of event processing cycle.
bool RunAction(const std::string &aActionName, T aParam)
Run the specified action immediately, pausing the current action to run the new one.
Definition: tool_manager.h:150
std::string GetClipboardUTF8() const
Return the information currently stored in the system clipboard.
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
Definition: tool_manager.h:235
bool SaveClipboard(const std::string &aTextUTF8)
Store information to the system clipboard.
CONDITIONAL_MENU & GetMenu()
Definition: tool_menu.cpp:44
void ShowContextMenu(SELECTION &aSelection)
Helper function to set and immediately show a CONDITIONAL_MENU in concert with the given SELECTION.
Definition: tool_menu.cpp:57
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
Definition: wx_infobar.cpp:187
This file is part of the common library.
#define _(s)
#define IS_NEW
New item, just created.
#define IS_MOVING
Item being moved.
#define HITTEST_THRESHOLD_PIXELS
This file contains miscellaneous commonly used macros and functions.
@ ID_APPEND_DESCR_FILE
Definition: pl_editor_id.h:41
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: string_utils.h:391
constexpr int delta
@ TA_UNDO_REDO_PRE
Definition: tool_event.h:105
@ BUT_LEFT
Definition: tool_event.h:131
@ BUT_RIGHT
Definition: tool_event.h:132
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:118