KiCad PCB EDA Suite
Loading...
Searching...
No Matches
common_tools.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) 2014-2016 CERN
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 * @author Maciej Suminski <[email protected]>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, you may find one here:
20 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
21 * or you may search the http://www.gnu.org website for the version 2 license,
22 * or you may write to the Free Software Foundation, Inc.,
23 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26#include <base_screen.h>
27#include <base_units.h>
28#include <gal/painter.h>
29#include <bitmaps.h>
33#include <eda_draw_frame.h>
35#include <id.h>
36#include <math/vector2wx.h>
37#include <core/kicad_algo.h>
38#include <kiface_base.h>
40#include <tool/actions.h>
41#include <tool/common_tools.h>
42#include <tool/tool_manager.h>
43#include <tool/selection_tool.h>
44#include <tool/grid_helper.h>
45#include <view/view.h>
46#include <view/view_controls.h>
47#include "macros.h"
48
49
51 TOOL_INTERACTIVE( "common.Control" ),
52 m_frame( nullptr ),
53 m_imperialUnit( EDA_UNITS::INCH ),
54 m_metricUnit( EDA_UNITS::MM )
55{
56}
57
58
60{
61 m_frame = getEditFrame<EDA_DRAW_FRAME>();
62 m_grids.clear();
63
64 if( aReason == RESET_REASON::SHUTDOWN )
65 return;
66
69
70 for( GRID& gridDef : settings.grids )
71 {
72 double gridSizeX = EDA_UNIT_UTILS::UI::DoubleValueFromString( scale, EDA_UNITS::MM, gridDef.x );
73 double gridSizeY = EDA_UNIT_UTILS::UI::DoubleValueFromString( scale, EDA_UNITS::MM, gridDef.y );
74
75 m_grids.emplace_back( KiROUND<double, int>( gridSizeX ), KiROUND<double, int>( gridSizeY ) );
76 }
77
78 OnGridChanged( false );
79}
80
81
83{
85 m_imperialUnit = aUnit;
86 else if( EDA_UNIT_UTILS::IsMetricUnit( aUnit ) )
87 m_metricUnit = aUnit;
88 else
89 wxASSERT_MSG( false, wxS( "Invalid unit" ) );
90}
91
92
94{
95 // Since selection tools are run permanently underneath the toolStack, this is really
96 // just a cancel of whatever other tools might be running.
97
99 return 0;
100}
101
102
104{
106 std::unique_ptr<GRID_HELPER> grid = m_frame->MakeGridHelper();
107 VECTOR2D gridSize;
108
109 if( grid )
110 gridSize = grid->GetGridSize( grid->GetSelectionGrid( m_frame->GetCurrentSelection() ) );
111 else
112 gridSize = getView()->GetGAL()->GetGridSize();
113
114 bool mirroredX = getView()->IsMirroredX();
116
117 switch( type )
118 {
120 gridSize *= 10;
123 cursor -= VECTOR2D( 0, gridSize.y );
124 break;
125
127 gridSize *= 10;
130 cursor += VECTOR2D( 0, gridSize.y );
131 break;
132
134 gridSize *= 10;
137 cursor -= VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
138 break;
139
141 gridSize *= 10;
144 cursor += VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
145 break;
146
147 case ACTIONS::CURSOR_CLICK: // fall through
150 {
153 int modifiers = 0;
154
155 modifiers |= wxGetKeyState( WXK_SHIFT ) ? MD_SHIFT : 0;
156 modifiers |= wxGetKeyState( WXK_CONTROL ) ? MD_CTRL : 0;
157 modifiers |= wxGetKeyState( WXK_ALT ) ? MD_ALT : 0;
158
159 if( type == ACTIONS::CURSOR_DBL_CLICK )
160 action = TA_MOUSE_DBLCLICK;
161 else if( type == ACTIONS::CURSOR_RIGHT_CLICK )
162 button = BUT_RIGHT;
163
164 TOOL_EVENT evt( TC_MOUSE, action, static_cast<int>( button | modifiers ) );
165 evt.SetParameter( type );
166 evt.SetMousePosition( getViewControls()->GetMousePosition() );
167 m_toolMgr->ProcessEvent( evt );
168
169 return 0;
170 }
171 default:
172 wxFAIL_MSG( wxS( "CursorControl(): unexpected request" ) );
173 }
174
175 getViewControls()->SetCursorPosition( cursor, true, true, type );
177
178 return 0;
179}
180
181
183{
185 KIGFX::VIEW* view = getView();
186 VECTOR2D center = view->GetCenter();
187 VECTOR2D gridSize = getView()->GetGAL()->GetGridSize() * 10;
188 bool mirroredX = view->IsMirroredX();
189
190 switch( type )
191 {
193 center -= VECTOR2D( 0, gridSize.y );
194 break;
195
197 center += VECTOR2D( 0, gridSize.y );
198 break;
199
201 center -= VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
202 break;
203
205 center += VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
206 break;
207
208 default:
209 wxFAIL;
210 break;
211 }
212
213 view->SetCenter( center );
214
215 return 0;
216}
217
218
220{
222 return 0;
223}
224
225
227{
228 bool direction = aEvent.IsAction( &ACTIONS::zoomIn );
229 return doZoomInOut( direction, true );
230}
231
232
234{
235 bool direction = aEvent.IsAction( &ACTIONS::zoomInCenter );
236 return doZoomInOut( direction, false );
237}
238
239
240int COMMON_TOOLS::doZoomInOut( bool aDirection, bool aCenterOnCursor )
241{
242 double zoom = getView()->GetGAL()->GetZoomFactor();
243
244 // Step must be AT LEAST 1.3
245 if( aDirection )
246 zoom *= 1.3;
247 else
248 zoom /= 1.3;
249
250 // Now look for the next closest menu step
251 std::vector<double>& zoomList = m_frame->GetWindowSettings( m_toolMgr->GetSettings() )->zoom_factors;
252 int idx;
253
254 if( aDirection )
255 {
256 for( idx = 0; idx < int( zoomList.size() ); ++idx )
257 {
258 if( zoomList[idx] >= zoom )
259 break;
260 }
261
262 if( idx >= int( zoomList.size() ) )
263 idx = (int) zoomList.size() - 1; // if we ran off the end then peg to the end
264 }
265 else
266 {
267 for( idx = int( zoomList.size() ) - 1; idx >= 0; --idx )
268 {
269 if( zoomList[idx] <= zoom )
270 break;
271 }
272
273 if( idx < 0 )
274 idx = 0; // if we ran off the end then peg to the end
275 }
276
277 // Note: idx == 0 is Auto; idx == 1 is first entry in zoomList
278 return doZoomToPreset( idx + 1, aCenterOnCursor );
279}
280
281
283{
285
286 ctls->CenterOnCursor();
287
288 return 0;
289}
290
291
293{
294 return doZoomFit( ZOOM_FIT_ALL );
295}
296
297
299{
300 return doZoomFit( ZOOM_FIT_OBJECTS );
301}
302
303
305{
307}
308
309
311{
312 KIGFX::VIEW* view = getView();
314 EDA_DRAW_FRAME* frame = getEditFrame<EDA_DRAW_FRAME>();
315
316 BOX2I bBox = frame->GetDocumentExtents();
317 BOX2I defaultBox = canvas->GetDefaultViewBBox();
318
319 view->SetScale( 1.0 ); // The best scale will be determined later, but this initial
320 // value ensures all view parameters are up to date (especially
321 // at init time)
322 VECTOR2D screenSize = view->ToWorld( ToVECTOR2I( canvas->GetClientSize() ), false );
323
324 // Currently "Zoom to Objects" is only supported in Eeschema & Pcbnew. Support for other
325 // programs in the suite can be added as needed.
326
327 if( aFitType == ZOOM_FIT_ALL )
328 {
329 if( frame->IsType( FRAME_PCB_EDITOR ) )
330 bBox = m_frame->GetDocumentExtents( false );
331 }
332
333 if( aFitType == ZOOM_FIT_OBJECTS )
334 {
335 if( frame->IsType( FRAME_SCH ) )
336 bBox = m_frame->GetDocumentExtents( false );
337 else
338 aFitType = ZOOM_FIT_ALL; // Just do a "Zoom to Fit" for unsupported editors
339 }
340
341 if( aFitType == ZOOM_FIT_SELECTION )
342 {
343 SELECTION& selection = m_frame->GetCurrentSelection();
344
345 if( selection.Empty() )
346 return 0;
347
348 bBox = selection.GetBoundingBox();
349 }
350
351 // If the screen is empty then use the default view bbox
352
353 if( bBox.GetWidth() == 0 || bBox.GetHeight() == 0 )
354 bBox = defaultBox;
355
356 VECTOR2D vsize = bBox.GetSize();
357 double scale = view->GetScale() / std::max( fabs( vsize.x / screenSize.x ),
358 fabs( vsize.y / screenSize.y ) );
359
360 // if the scale isn't finite (most likely due to an empty canvas)
361 // simply just make sure we are centered and quit out of trying to zoom to fit
362 if( !std::isfinite( scale ) )
363 {
364 view->SetCenter( VECTOR2D( 0, 0 ) );
365 canvas->Refresh();
366 return 0;
367 }
368
369 // Reserve enough margin to limit the amount of the view that might be obscured behind the
370 // infobar.
371 double margin_scale_factor = 1.04;
372
373 if( canvas->GetClientSize().y < 768 )
374 margin_scale_factor = 1.10;
375
376 if( aFitType == ZOOM_FIT_ALL )
377 {
378 // Leave a bigger margin for library editors & viewers
379
380 if( frame->IsType( FRAME_FOOTPRINT_VIEWER )
381 || frame->IsType( FRAME_SCH_VIEWER ) )
382 {
383 margin_scale_factor = 1.30;
384 }
385 else if( frame->IsType( FRAME_SCH_SYMBOL_EDITOR )
386 || frame->IsType( FRAME_FOOTPRINT_EDITOR ) )
387 {
388 margin_scale_factor = 1.48;
389 }
390 }
391
392 view->SetScale( scale / margin_scale_factor );
393 view->SetCenter( bBox.Centre() );
394 canvas->Refresh();
395
396 return 0;
397}
398
399
401{
403}
404
405
407{
409}
410
411
413{
415
416 BOX2I bBox;
417
418 if( aCenterType == CENTER_TYPE::CENTER_SELECTION )
419 {
420 SELECTION& selection = m_frame->GetCurrentSelection();
421
422 // No selection: do nothing
423 if( selection.Empty() )
424 return 0;
425
426 bBox = selection.GetBoundingBox().Centre();
427 }
428 else
429 {
430 bBox = getModel<EDA_ITEM>()->ViewBBox();
431
432 if( bBox.GetWidth() == 0 || bBox.GetHeight() == 0 )
433 bBox = canvas->GetDefaultViewBBox();
434 }
435
436 getView()->SetCenter( bBox.Centre() );
437
438 // Take scrollbars into account
439 VECTOR2D scrollbarSize = VECTOR2D( ToVECTOR2D( canvas->GetSize() - canvas->GetClientSize() ) );
440 VECTOR2D worldScrollbarSize = getView()->ToWorld( scrollbarSize, false );
441 getView()->SetCenter( getView()->GetCenter() + worldScrollbarSize / 2.0 );
442 canvas->Refresh();
443
444 return 0;
445}
446
447
449{
450 int idx = aEvent.Parameter<int>();
451 return doZoomToPreset( idx, false );
452}
453
454
455// Note: idx == 0 is Auto; idx == 1 is first entry in zoomList
456int COMMON_TOOLS::doZoomToPreset( int idx, bool aCenterOnCursor )
457{
458 std::vector<double>& zoomList = m_frame->GetWindowSettings( m_toolMgr->GetSettings() )->zoom_factors;
459
460 if( idx == 0 ) // Zoom Auto
461 {
463 return ZoomFitScreen( dummy );
464 }
465 else
466 {
467 idx--;
468 }
469
470 double scale = zoomList[idx];
471
472 if( aCenterOnCursor )
473 {
474 getView()->SetScale( scale, getViewControls()->GetCursorPosition() );
475
476 if( getViewControls()->IsCursorWarpingEnabled() )
478 }
479 else
480 {
481 getView()->SetScale( scale );
482 }
483
485
486 return 0;
487}
488
489
491{
493
494 currentGrid++;
495
496 if( currentGrid >= int( m_grids.size() ) )
497 currentGrid = 0;
498
499 return OnGridChanged( true );
500}
501
502
504{
506
507 currentGrid--;
508
509 if( currentGrid < 0 )
510 currentGrid = (int) m_grids.size() - 1;
511
512 return OnGridChanged( true );
513}
514
515
517{
518 return GridPreset( aEvent.Parameter<int>(), false );
519}
520
521
522int COMMON_TOOLS::GridPreset( int idx, bool aFromHotkey )
523{
525
526 currentGrid = std::clamp( idx, 0, (int) m_grids.size() - 1 );
527
528 return OnGridChanged( aFromHotkey );
529}
530
531
532int COMMON_TOOLS::OnGridChanged( bool aFromHotkey )
533{
535
536 currentGrid = std::max( 0, std::min( currentGrid, static_cast<int>( m_grids.size() ) - 1 ) );
537
538 // Update the combobox (if any)
539 wxUpdateUIEvent dummy;
541
542 // Update GAL canvas from screen
543 getView()->GetGAL()->SetGridSize( m_grids[ currentGrid ] );
546
547 // Put cursor on new grid
548 VECTOR2D gridCursor = getViewControls()->GetCursorPosition( true );
549 getViewControls()->SetCrossHairCursorPosition( gridCursor, false );
550
551 // Show feedback
552 if( aFromHotkey )
554
555 return 0;
556}
557
558
560{
562}
563
564
566{
568}
569
570
572{
575 {
577 }
578
580}
581
582
584{
586 return 0;
587}
588
589
591{
593 return 0;
594}
595
596
598{
599 auto showGridPrefs =
600 [this]( const wxString& aParentName )
601 {
602 m_frame->CallAfter(
603 [this, aParentName]()
604 {
605 m_frame->ShowPreferences( _( "Grids" ), aParentName );
606 } );
607 };
608
609 switch( m_frame->GetFrameType() )
610 {
611 case FRAME_SCH: showGridPrefs( _( "Schematic Editor" ) ); break;
612 case FRAME_SCH_SYMBOL_EDITOR: showGridPrefs( _( "Symbol Editor" ) ); break;
613 case FRAME_PCB_EDITOR: showGridPrefs( _( "PCB Editor" ) ); break;
614 case FRAME_FOOTPRINT_EDITOR: showGridPrefs( _( "Footprint Editor" ) ); break;
615 case FRAME_PL_EDITOR: showGridPrefs( _( "Drawing Sheet Editor" ) ); break;
616 case FRAME_GERBER: showGridPrefs( _( "Gerber Viewer" ) ); break;
617 default: wxFAIL_MSG( "Unknown frame: " + GetName() ); break;
618 }
619
620 return 0;
621}
622
623
625{
626 VECTOR2I origin = m_frame->GetGridOrigin();
627 WX_PT_ENTRY_DIALOG dlg( m_frame, _( "Grid Origin" ), _( "X:" ), _( "Y:" ), origin, true );
628
629 if( dlg.ShowModal() == wxID_OK )
630 {
632
636 }
637
638 return 0;
639}
640
641
643{
644 EDA_UNITS newUnit = aEvent.Parameter<EDA_UNITS>();
645
646 if( EDA_UNIT_UTILS::IsMetricUnit( newUnit ) )
647 m_metricUnit = newUnit;
648 else if( EDA_UNIT_UTILS::IsImperialUnit( newUnit ) )
649 m_imperialUnit = newUnit;
650 else
651 wxASSERT_MSG( false, wxS( "Invalid unit for the frame" ) );
652
653 m_frame->ChangeUserUnits( newUnit );
654 return 0;
655}
656
657
659{
663 return 0;
664}
665
666
668{
669 m_frame->SetStatusText( wxEmptyString );
672
673 return 0;
674}
675
676
678{
679 if( !m_frame->GetScreen() ) // Can happen in footprint chooser frame
680 return 0;
681
682 const KIGFX::VC_SETTINGS& vcSettings = m_toolMgr->GetCurrentToolVC();
683
684 // Use either the active tool forced cursor position or the general settings
685 if( vcSettings.m_forceCursorPosition )
687 else
689
691
692 return 0;
693}
694
695
697{
698 auto& galOpts = m_frame->GetGalDisplayOptions();
699
700 galOpts.m_forceDisplayCursor = !galOpts.m_forceDisplayCursor;
701 galOpts.WriteConfig( *m_frame->GetWindowSettings( m_toolMgr->GetSettings() ) );
702 galOpts.NotifyChanged();
703
704 return 0;
705}
706
707
709{
711
712 galOpts.m_fullscreenCursor = !galOpts.m_fullscreenCursor;
714 galOpts.NotifyChanged();
715
716 return 0;
717}
718
719
721{
723
724 if( canvas )
725 {
727
729
730 canvas->GetView()->UpdateAllItems( KIGFX::ALL );
731 canvas->ForceRefresh();
732 }
733
734 return 0;
735}
736
737
739{
741
742 // Cursor control
751
755
756 // Pan control
761
762 // Zoom control
775
776 // Grid control
787
788 // Units and coordinates
795
796 // Misc
800}
BASE_SCREEN class implementation.
static TOOL_ACTION gridProperties
Definition: actions.h:197
static TOOL_ACTION gridFastCycle
Definition: actions.h:189
static TOOL_ACTION toggleGrid
Definition: actions.h:195
static TOOL_ACTION zoomRedraw
Definition: actions.h:131
static TOOL_ACTION millimetersUnits
Definition: actions.h:203
static TOOL_ACTION gridFast1
Definition: actions.h:187
static TOOL_ACTION gridPrev
Definition: actions.h:191
static TOOL_ACTION cursorLeft
Definition: actions.h:169
static TOOL_ACTION zoomOutCenter
Definition: actions.h:135
static TOOL_ACTION togglePolarCoords
Definition: actions.h:206
static TOOL_ACTION zoomIn
Definition: actions.h:132
static TOOL_ACTION cursorLeftFast
Definition: actions.h:174
static TOOL_ACTION gridPreset
Definition: actions.h:194
static TOOL_ACTION zoomFitSelection
Definition: actions.h:143
static TOOL_ACTION centerSelection
Definition: actions.h:149
static TOOL_ACTION cursorDown
Definition: actions.h:168
static TOOL_ACTION zoomOut
Definition: actions.h:133
static TOOL_ACTION milsUnits
Definition: actions.h:202
static TOOL_ACTION cursorRightFast
Definition: actions.h:175
static TOOL_ACTION toggleBoundingBoxes
Definition: actions.h:154
static TOOL_ACTION showContextMenu
Definition: actions.h:74
static TOOL_ACTION toggleCursor
Definition: actions.h:150
static TOOL_ACTION centerContents
Definition: actions.h:148
static TOOL_ACTION zoomCenter
Definition: actions.h:140
static TOOL_ACTION panDown
Definition: actions.h:182
static TOOL_ACTION cursorDblClick
Definition: actions.h:178
CURSOR_EVENT_TYPE
Definition: actions.h:300
@ CURSOR_DBL_CLICK
Definition: actions.h:311
@ CURSOR_RIGHT
Definition: actions.h:308
@ CURSOR_LEFT_FAST
Definition: actions.h:307
@ CURSOR_LEFT
Definition: actions.h:306
@ CURSOR_DOWN_FAST
Definition: actions.h:305
@ CURSOR_CLICK
Definition: actions.h:310
@ CURSOR_UP
Definition: actions.h:302
@ CURSOR_RIGHT_FAST
Definition: actions.h:309
@ CURSOR_DOWN
Definition: actions.h:304
@ CURSOR_UP_FAST
Definition: actions.h:303
@ CURSOR_RIGHT_CLICK
Definition: actions.h:312
static TOOL_ACTION cursorDownFast
Definition: actions.h:173
static TOOL_ACTION inchesUnits
Definition: actions.h:201
static TOOL_ACTION cursorUpFast
Definition: actions.h:172
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:151
static TOOL_ACTION gridOrigin
Definition: actions.h:198
static TOOL_ACTION panLeft
Definition: actions.h:183
static TOOL_ACTION selectionTool
Definition: actions.h:248
static TOOL_ACTION cursorClick
Definition: actions.h:177
static TOOL_ACTION zoomFitScreen
Definition: actions.h:141
static TOOL_ACTION zoomPreset
Definition: actions.h:144
static TOOL_ACTION panUp
Definition: actions.h:181
static TOOL_ACTION zoomFitObjects
Definition: actions.h:142
static TOOL_ACTION toggleUnits
Definition: actions.h:205
static TOOL_ACTION zoomInCenter
Definition: actions.h:134
static TOOL_ACTION panRight
Definition: actions.h:184
static TOOL_ACTION gridSetOrigin
Definition: actions.h:192
static TOOL_ACTION gridFast2
Definition: actions.h:188
static TOOL_ACTION cursorUp
Cursor control with keyboard.
Definition: actions.h:167
static TOOL_ACTION refreshPreview
Definition: actions.h:156
static TOOL_ACTION toggleGridOverrides
Definition: actions.h:196
static TOOL_ACTION gridNext
Definition: actions.h:190
static TOOL_ACTION cursorRight
Definition: actions.h:170
static TOOL_ACTION resetLocalCoords
Definition: actions.h:207
VECTOR2D m_LocalOrigin
Relative Screen cursor coordinate (on grid) in user units.
Definition: base_screen.h:90
constexpr size_type GetWidth() const
Definition: box2.h:214
constexpr Vec Centre() const
Definition: box2.h:97
constexpr size_type GetHeight() const
Definition: box2.h:215
constexpr const SizeVec & GetSize() const
Definition: box2.h:206
int ZoomFitSelection(const TOOL_EVENT &aEvent)
int ZoomCenter(const TOOL_EVENT &aEvent)
int doCenter(CENTER_TYPE aCenterType)
int GridProperties(const TOOL_EVENT &aEvent)
int GridFastCycle(const TOOL_EVENT &aEvent)
int ToggleCursorStyle(const TOOL_EVENT &aEvent)
int GridOrigin(const TOOL_EVENT &aEvent)
int doZoomToPreset(int idx, bool aCenterOnCursor)
int PanControl(const TOOL_EVENT &aEvent)
EDA_UNITS m_metricUnit
Definition: common_tools.h:134
EDA_UNITS m_imperialUnit
Definition: common_tools.h:133
int SwitchUnits(const TOOL_EVENT &aEvent)
int ToggleGrid(const TOOL_EVENT &aEvent)
int GridFast1(const TOOL_EVENT &aEvent)
void SetLastUnits(EDA_UNITS aUnit)
int ToggleUnits(const TOOL_EVENT &aEvent)
int GridFast2(const TOOL_EVENT &aEvent)
int GridNext(const TOOL_EVENT &aEvent)
int OnGridChanged(bool aFromHotkey)
void setTransitions() override
Pointer to the currently used edit frame.
int CenterSelection(const TOOL_EVENT &aEvent)
int ZoomPreset(const TOOL_EVENT &aEvent)
int ZoomFitScreen(const TOOL_EVENT &aEvent)
int ToggleBoundingBoxes(const TOOL_EVENT &aEvent)
int ToggleGridOverrides(const TOOL_EVENT &aEvent)
std::vector< VECTOR2I > m_grids
Grids from #APP_SETTINGS converted to internal units and with the user grid appended.
Definition: common_tools.h:129
int ToggleCursor(const TOOL_EVENT &aEvent)
int ZoomFitObjects(const TOOL_EVENT &aEvent)
int CenterContents(const TOOL_EVENT &aEvent)
void Reset(RESET_REASON aReason) override
Bring the tool to a known, initial state.
int TogglePolarCoords(const TOOL_EVENT &aEvent)
int GridPrev(const TOOL_EVENT &aEvent)
int ZoomInOutCenter(const TOOL_EVENT &aEvent)
int ZoomRedraw(const TOOL_EVENT &aEvent)
int ResetLocalCoords(const TOOL_EVENT &aEvent)
EDA_DRAW_FRAME * m_frame
Definition: common_tools.h:118
int doZoomFit(ZOOM_FIT_TYPE_T aFitType)
int CursorControl(const TOOL_EVENT &aEvent)
ZOOM_FIT_TYPE_T
The set of "Zoom to Fit" types that can be performed.
Definition: common_tools.h:102
@ ZOOM_FIT_SELECTION
Zoom to fit selected items in view.
Definition: common_tools.h:105
@ ZOOM_FIT_ALL
Zoom to fall all items in view INCLUDING page and border.
Definition: common_tools.h:103
@ ZOOM_FIT_OBJECTS
Zoom to fit all items in view EXCLUDING page and border.
Definition: common_tools.h:104
int SelectionTool(const TOOL_EVENT &aEvent)
int GridPreset(const TOOL_EVENT &aEvent)
int ZoomInOut(const TOOL_EVENT &aEvent)
int doZoomInOut(bool aDirection, bool aCenterOnCursor)
Note: idx == 0 is Auto; idx == 1 is first entry in zoomList.
int ShowModal() override
FRAME_T GetFrameType() const
virtual WINDOW_SETTINGS * GetWindowSettings(APP_SETTINGS_BASE *aCfg)
Return a pointer to the window settings for this frame.
void ShowPreferences(wxString aStartPage, wxString aStartParentPage)
Display the preferences and settings of all opened editors paged dialog, starting with a particular p...
void ChangeUserUnits(EDA_UNITS aUnits)
bool IsType(FRAME_T aType) const
The base class for create windows for drawing purpose.
virtual const BOX2I GetDocumentExtents(bool aIncludeAllVisible=true) const
Return bounding box of document with option to not include some items.
virtual BASE_SCREEN * GetScreen() const
Return a pointer to a BASE_SCREEN or one of its derivatives.
virtual void HardRedraw()
Rebuild the GAL and redraws the screen.
virtual void SetGridOrigin(const VECTOR2I &aPosition)=0
bool IsGridOverridden() const
GAL_DISPLAY_OPTIONS_IMPL & GetGalDisplayOptions()
Return a reference to the gal rendering options used by GAL for rendering.
virtual const VECTOR2I & GetGridOrigin() const =0
Return the absolute coordinates of the origin of the snap grid.
void SetShowPolarCoords(bool aShow)
virtual void SetGridVisibility(bool aVisible)
void UpdateStatusBar() override
Update the status bar information.
virtual EDA_DRAW_PANEL_GAL * GetCanvas() const
Return a pointer to GAL-based canvas of given EDA draw frame.
bool IsGridVisible() const
virtual std::unique_ptr< GRID_HELPER > MakeGridHelper()
virtual void SetGridOverrides(bool aOverride)
void OnUpdateSelectGrid(wxUpdateUIEvent &aEvent)
Update the checked item in the grid wxchoice.
bool GetShowPolarCoords() const
For those frames that support polar coordinates.
virtual BOX2I GetDefaultViewBBox() const
Return the bounding box of the view that should be used if model is not valid.
virtual KIGFX::VIEW * GetView() const
Return a pointer to the #VIEW instance used in the panel.
void ForceRefresh()
Force a redraw.
virtual void Refresh(bool aEraseBackground=true, const wxRect *aRect=nullptr) override
static const TOOL_EVENT GridChangedByKeyEvent
Definition: actions.h:362
void WriteConfig(WINDOW_SETTINGS &aCfg)
bool m_forceDisplayCursor
The pixel scale factor (>1 for hi-DPI scaled displays)
bool m_fullscreenCursor
Force cursor display.
double GetZoomFactor() const
void SetGridSize(const VECTOR2D &aGridSize)
Set the grid size.
const VECTOR2D & GetGridSize() const
Return the grid size.
void SetGridVisibility(bool aVisibility)
Set the visibility setting of the grid.
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
void SetDrawBoundingBoxes(bool aEnabled)
bool GetDrawBoundingBoxes() const
An interface for classes handling user events controlling the view behavior such as zooming,...
virtual VECTOR2D GetRawCursorPosition(bool aSnappingEnabled=true) const =0
Return the current cursor position in world coordinates ignoring the cursorUp position force mode.
virtual void CenterOnCursor()=0
Set the viewport center to the current cursor position and warps the cursor to the screen center.
virtual void SetCrossHairCursorPosition(const VECTOR2D &aPosition, bool aWarpView=true)=0
Move the graphic crosshair cursor to the requested position expressed in world coordinates.
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.
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:66
double GetScale() const
Definition: view.h:276
virtual void SetScale(double aScale, VECTOR2D aAnchor={ 0, 0 })
Set the scaling factor, zooming around a given anchor point.
Definition: view.cpp:570
GAL * GetGAL() const
Return the #GAL this view is using to draw graphical primitives.
Definition: view.h:202
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Converts a screen space point/vector to a point/vector in world space coordinates.
Definition: view.cpp:467
bool IsMirroredX() const
Return true if view is flipped across the X axis.
Definition: view.h:250
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1561
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:220
void SetCenter(const VECTOR2D &aCenter)
Set the center point of the VIEW (i.e.
Definition: view.cpp:596
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition: view.h:639
bool Empty() const
Checks if there is anything selected.
Definition: selection.h:115
virtual BOX2I GetBoundingBox() const
Definition: selection.cpp:132
virtual SELECTION & GetCurrentSelection()
Get the current selection from the canvas area.
Definition: tools_holder.h:98
const std::string & GetName() const
Return the name of the tool.
Definition: tool_base.h:136
KIGFX::VIEW_CONTROLS * getViewControls() const
Return the instance of VIEW_CONTROLS object used in the application.
Definition: tool_base.cpp:44
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:220
KIGFX::VIEW * getView() const
Returns the instance of #VIEW object used in the application.
Definition: tool_base.cpp:38
RESET_REASON
Determine the reason of reset for a tool.
Definition: tool_base.h:78
@ REDRAW
Full drawing refresh.
Definition: tool_base.h:83
@ SHUTDOWN
Tool is being shut down.
Definition: tool_base.h:84
Generic, UI-independent tool event.
Definition: tool_event.h:168
void SetMousePosition(const VECTOR2D &aP)
Definition: tool_event.h:530
void SetParameter(T aParam)
Set a non-standard parameter assigned to the event.
Definition: tool_event.h:520
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
T Parameter() const
Return a parameter assigned to the event.
Definition: tool_event.h:465
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).
bool ProcessEvent(const TOOL_EVENT &aEvent)
Propagate an event to tools that requested events of matching type(s).
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
const KIGFX::VC_SETTINGS & GetCurrentToolVC() const
Return the view controls settings for the current tool or the general settings if there is no active ...
APP_SETTINGS_BASE * GetSettings() const
Definition: tool_manager.h:404
bool PostAction(const std::string &aActionName, T aParam)
Run the specified action after the current action (coroutine) ends.
Definition: tool_manager.h:235
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Reset all tools (i.e.
const EDA_IU_SCALE & GetIuScale() const
EDA_UNITS GetUserUnits() const
VECTOR2I GetValue()
Return the value in internal units.
#define _(s)
EDA_UNITS
Definition: eda_units.h:48
@ FRAME_PCB_EDITOR
Definition: frame_type.h:42
@ FRAME_SCH_SYMBOL_EDITOR
Definition: frame_type.h:35
@ FRAME_FOOTPRINT_VIEWER
Definition: frame_type.h:45
@ FRAME_SCH_VIEWER
Definition: frame_type.h:36
@ FRAME_SCH
Definition: frame_type.h:34
@ FRAME_PL_EDITOR
Definition: frame_type.h:59
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
@ FRAME_GERBER
Definition: frame_type.h:57
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
KICOMMON_API double DoubleValueFromString(const EDA_IU_SCALE &aIuScale, EDA_UNITS aUnits, const wxString &aTextValue, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE)
Convert aTextValue to a double.
Definition: eda_units.cpp:569
KICOMMON_API bool IsImperialUnit(EDA_UNITS aUnit)
Definition: eda_units.cpp:47
KICOMMON_API bool IsMetricUnit(EDA_UNITS aUnit)
Definition: eda_units.cpp:61
@ ALL
All except INITIAL_ADD.
Definition: view_item.h:59
@ TARGET_NONCACHED
Auxiliary rendering target (noncached)
Definition: definitions.h:38
@ INCH
Definition: rs274x.cpp:62
const int scale
std::vector< FAB_LAYER_COLOR > dummy
std::vector< GRID > grids
Definition: grid_settings.h:66
Common grid settings, available to every frame.
Definition: grid_settings.h:34
wxString y
Definition: grid_settings.h:53
wxString x
Definition: grid_settings.h:52
Structure to keep VIEW_CONTROLS settings for easy store/restore operations.
Definition: view_controls.h:43
VECTOR2D m_forcedPosition
Forced cursor position (world coordinates).
Definition: view_controls.h:56
bool m_forceCursorPosition
Is the forced cursor position enabled.
Definition: view_controls.h:59
GRID_SETTINGS grid
Definition: app_settings.h:97
std::vector< double > zoom_factors
Definition: app_settings.h:94
VECTOR2I center
TOOL_ACTIONS
Definition: tool_event.h:64
@ TA_MOUSE_CLICK
Definition: tool_event.h:67
@ TA_MOUSE_DBLCLICK
Definition: tool_event.h:68
@ TA_CANCEL_TOOL
Tool cancel event.
Definition: tool_event.h:90
@ TC_COMMAND
Definition: tool_event.h:57
@ TC_MOUSE
Definition: tool_event.h:55
@ MD_ALT
Definition: tool_event.h:145
@ MD_CTRL
Definition: tool_event.h:144
@ MD_SHIFT
Definition: tool_event.h:143
TOOL_MOUSE_BUTTONS
Definition: tool_event.h:130
@ BUT_LEFT
Definition: tool_event.h:132
@ BUT_RIGHT
Definition: tool_event.h:133
VECTOR2< double > VECTOR2D
Definition: vector2d.h:694
VECTOR2I ToVECTOR2I(const wxSize &aSize)
Definition: vector2wx.h:30
VECTOR2D ToVECTOR2D(const wxPoint &aPoint)
Definition: vector2wx.h:40