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 (C) 2020-2023 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::INCHES ),
54 m_metricUnit( EDA_UNITS::MILLIMETRES )
55{
56}
57
59{
60 m_frame = getEditFrame<EDA_DRAW_FRAME>();
61 m_grids.clear();
62
63 if( aReason == RESET_REASON::SHUTDOWN )
64 return;
65
68
69 for( GRID& gridDef : settings.grids )
70 {
71 double gridSizeX = EDA_UNIT_UTILS::UI::DoubleValueFromString( scale, EDA_UNITS::MILLIMETRES,
72 gridDef.x );
73 double gridSizeY = EDA_UNIT_UTILS::UI::DoubleValueFromString( scale, EDA_UNITS::MILLIMETRES,
74 gridDef.y );
75
76 m_grids.emplace_back( KiROUND<double, int>( gridSizeX ),
77 KiROUND<double, int>( gridSizeY ) );
78 }
79
80 OnGridChanged( false );
81}
82
83
85{
87 m_imperialUnit = aUnit;
88 else if( EDA_UNIT_UTILS::IsMetricUnit( aUnit ) )
89 m_metricUnit = aUnit;
90 else
91 wxASSERT_MSG( false, wxS( "Invalid unit" ) );
92}
93
94
96{
97 // Since selection tools are run permanently underneath the toolStack, this is really
98 // just a cancel of whatever other tools might be running.
99
101 return 0;
102}
103
104
105// Cursor control
107{
109 std::unique_ptr<GRID_HELPER> grid = m_frame->MakeGridHelper();
110 VECTOR2D gridSize;
111
112 if( grid )
113 gridSize = grid->GetGridSize( grid->GetSelectionGrid( m_frame->GetCurrentSelection() ) );
114 else
115 gridSize = getView()->GetGAL()->GetGridSize();
116
117 bool mirroredX = getView()->IsMirroredX();
119
120 switch( type )
121 {
123 gridSize *= 10;
126 cursor -= VECTOR2D( 0, gridSize.y );
127 break;
128
130 gridSize *= 10;
133 cursor += VECTOR2D( 0, gridSize.y );
134 break;
135
137 gridSize *= 10;
140 cursor -= VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
141 break;
142
144 gridSize *= 10;
147 cursor += VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
148 break;
149
150 case ACTIONS::CURSOR_CLICK: // fall through
153 {
156 int modifiers = 0;
157
158 modifiers |= wxGetKeyState( WXK_SHIFT ) ? MD_SHIFT : 0;
159 modifiers |= wxGetKeyState( WXK_CONTROL ) ? MD_CTRL : 0;
160 modifiers |= wxGetKeyState( WXK_ALT ) ? MD_ALT : 0;
161
162 if( type == ACTIONS::CURSOR_DBL_CLICK )
163 action = TA_MOUSE_DBLCLICK;
164 else if( type == ACTIONS::CURSOR_RIGHT_CLICK )
165 button = BUT_RIGHT;
166
167 TOOL_EVENT evt( TC_MOUSE, action, static_cast<int>( button | modifiers ) );
168 evt.SetParameter( type );
169 evt.SetMousePosition( getViewControls()->GetMousePosition() );
170 m_toolMgr->ProcessEvent( evt );
171
172 return 0;
173 }
174 default:
175 wxFAIL_MSG( wxS( "CursorControl(): unexpected request" ) );
176 }
177
178 getViewControls()->SetCursorPosition( cursor, true, true, type );
180
181 return 0;
182}
183
184
186{
188 KIGFX::VIEW* view = getView();
189 VECTOR2D center = view->GetCenter();
190 VECTOR2D gridSize = getView()->GetGAL()->GetGridSize() * 10;
191 bool mirroredX = view->IsMirroredX();
192
193 switch( type )
194 {
196 center -= VECTOR2D( 0, gridSize.y );
197 break;
198
200 center += VECTOR2D( 0, gridSize.y );
201 break;
202
204 center -= VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
205 break;
206
208 center += VECTOR2D( mirroredX ? -gridSize.x : gridSize.x, 0 );
209 break;
210
211 default:
212 wxFAIL;
213 break;
214 }
215
216 view->SetCenter( center );
217
218 return 0;
219}
220
221
223{
225 return 0;
226}
227
228
230{
231 bool direction = aEvent.IsAction( &ACTIONS::zoomIn );
232 return doZoomInOut( direction, true );
233}
234
235
237{
238 bool direction = aEvent.IsAction( &ACTIONS::zoomInCenter );
239 return doZoomInOut( direction, false );
240}
241
242
243int COMMON_TOOLS::doZoomInOut( bool aDirection, bool aCenterOnCursor )
244{
245 double zoom = getView()->GetGAL()->GetZoomFactor();
246
247 // Step must be AT LEAST 1.3
248 if( aDirection )
249 zoom *= 1.3;
250 else
251 zoom /= 1.3;
252
253 // Now look for the next closest menu step
254 std::vector<double>& zoomList = m_toolMgr->GetSettings()->m_Window.zoom_factors;
255 int idx;
256
257 if( aDirection )
258 {
259 for( idx = 0; idx < int( zoomList.size() ); ++idx )
260 {
261 if( zoomList[idx] >= zoom )
262 break;
263 }
264
265 if( idx >= int( zoomList.size() ) )
266 idx = (int) zoomList.size() - 1; // if we ran off the end then peg to the end
267 }
268 else
269 {
270 for( idx = int( zoomList.size() ) - 1; idx >= 0; --idx )
271 {
272 if( zoomList[idx] <= zoom )
273 break;
274 }
275
276 if( idx < 0 )
277 idx = 0; // if we ran off the end then peg to the end
278 }
279
280 // Note: idx == 0 is Auto; idx == 1 is first entry in zoomList
281 return doZoomToPreset( idx + 1, aCenterOnCursor );
282}
283
284
286{
288
289 ctls->CenterOnCursor();
290
291 return 0;
292}
293
294
296{
297 return doZoomFit( ZOOM_FIT_ALL );
298}
299
300
302{
303 return doZoomFit( ZOOM_FIT_OBJECTS );
304}
305
306
308{
309 KIGFX::VIEW* view = getView();
311 EDA_DRAW_FRAME* frame = getEditFrame<EDA_DRAW_FRAME>();
312
313 BOX2I bBox = frame->GetDocumentExtents();
314 BOX2I defaultBox = canvas->GetDefaultViewBBox();
315
316 view->SetScale( 1.0 ); // The best scale will be determined later, but this initial
317 // value ensures all view parameters are up to date (especially
318 // at init time)
319 VECTOR2D screenSize = view->ToWorld( ToVECTOR2I( canvas->GetClientSize() ), false );
320
321 // Currently "Zoom to Objects" is only supported in Eeschema & Pcbnew. Support for other
322 // programs in the suite can be added as needed.
323
324 if( aFitType == ZOOM_FIT_ALL )
325 {
326 if( frame->IsType( FRAME_PCB_EDITOR ) )
327 bBox = m_frame->GetDocumentExtents( false );
328 }
329
330 if( aFitType == ZOOM_FIT_OBJECTS )
331 {
332 if( frame->IsType( FRAME_SCH ) )
333 bBox = m_frame->GetDocumentExtents( false );
334 else
335 aFitType = ZOOM_FIT_ALL; // Just do a "Zoom to Fit" for unsupported editors
336 }
337
338 // If the screen is empty then use the default view bbox
339
340 if( bBox.GetWidth() == 0 || bBox.GetHeight() == 0 )
341 bBox = defaultBox;
342
343 VECTOR2D vsize = bBox.GetSize();
344 double scale = view->GetScale() / std::max( fabs( vsize.x / screenSize.x ),
345 fabs( vsize.y / screenSize.y ) );
346
347 // if the scale isn't finite (most likely due to an empty canvas)
348 // simply just make sure we are centered and quit out of trying to zoom to fit
349 if( !std::isfinite( scale ) )
350 {
351 view->SetCenter( VECTOR2D( 0, 0 ) );
352 canvas->Refresh();
353 return 0;
354 }
355
356 // Reserve enough margin to limit the amount of the view that might be obscured behind the
357 // infobar.
358 double margin_scale_factor = 1.04;
359
360 if( canvas->GetClientSize().y < 768 )
361 margin_scale_factor = 1.10;
362
363 if( aFitType == ZOOM_FIT_ALL )
364 {
365 // Leave a bigger margin for library editors & viewers
366
367 if( frame->IsType( FRAME_FOOTPRINT_VIEWER )
368 || frame->IsType( FRAME_SCH_VIEWER ) )
369 {
370 margin_scale_factor = 1.30;
371 }
372 else if( frame->IsType( FRAME_SCH_SYMBOL_EDITOR )
373 || frame->IsType( FRAME_FOOTPRINT_EDITOR ) )
374 {
375 margin_scale_factor = 1.48;
376 }
377 }
378
379 view->SetScale( scale / margin_scale_factor );
380 view->SetCenter( bBox.Centre() );
381 canvas->Refresh();
382
383 return 0;
384}
385
386
388{
390 BOX2I bBox = getModel<EDA_ITEM>()->ViewBBox();
391
392 if( bBox.GetWidth() == 0 || bBox.GetHeight() == 0 )
393 bBox = canvas->GetDefaultViewBBox();
394
395 getView()->SetCenter( bBox.Centre() );
396
397 // Take scrollbars into account
398 VECTOR2D scrollbarSize = VECTOR2D( ToVECTOR2D( canvas->GetSize() - canvas->GetClientSize() ) );
399 VECTOR2D worldScrollbarSize = getView()->ToWorld( scrollbarSize, false );
400 getView()->SetCenter( getView()->GetCenter() + worldScrollbarSize / 2.0 );
401 canvas->Refresh();
402
403 return 0;
404}
405
406
408{
409 int idx = aEvent.Parameter<int>();
410 return doZoomToPreset( idx, false );
411}
412
413
414// Note: idx == 0 is Auto; idx == 1 is first entry in zoomList
415int COMMON_TOOLS::doZoomToPreset( int idx, bool aCenterOnCursor )
416{
417 std::vector<double>& zoomList = m_toolMgr->GetSettings()->m_Window.zoom_factors;
418
419 if( idx == 0 ) // Zoom Auto
420 {
422 return ZoomFitScreen( dummy );
423 }
424 else
425 {
426 idx--;
427 }
428
429 double scale = zoomList[idx];
430
431 if( aCenterOnCursor )
432 {
433 getView()->SetScale( scale, getViewControls()->GetCursorPosition() );
434
435 if( getViewControls()->IsCursorWarpingEnabled() )
437 }
438 else
439 {
440 getView()->SetScale( scale );
441 }
442
444
445 return 0;
446}
447
448
449// Grid control
451{
452 int& currentGrid = m_toolMgr->GetSettings()->m_Window.grid.last_size_idx;
453
454 currentGrid++;
455
456 if( currentGrid >= int( m_grids.size() ) )
457 currentGrid = 0;
458
459 return OnGridChanged( true );
460}
461
462
464{
465 int& currentGrid = m_toolMgr->GetSettings()->m_Window.grid.last_size_idx;
466
467 currentGrid--;
468
469 if( currentGrid < 0 )
470 currentGrid = (int) m_grids.size() - 1;
471
472 return OnGridChanged( true );
473}
474
475
477{
478 return GridPreset( aEvent.Parameter<int>(), false );
479}
480
481
482int COMMON_TOOLS::GridPreset( int idx, bool aFromHotkey )
483{
484 int& currentGrid = m_toolMgr->GetSettings()->m_Window.grid.last_size_idx;
485
486 currentGrid = std::clamp( idx, 0, (int) m_grids.size() - 1 );
487
488 return OnGridChanged( aFromHotkey );
489}
490
491
492int COMMON_TOOLS::OnGridChanged( bool aFromHotkey )
493{
494 int& currentGrid = m_toolMgr->GetSettings()->m_Window.grid.last_size_idx;
495
496 currentGrid = std::max( 0, std::min( currentGrid, static_cast<int>( m_grids.size() ) - 1 ) );
497
498 // Update the combobox (if any)
499 wxUpdateUIEvent dummy;
501
502 // Update GAL canvas from screen
503 getView()->GetGAL()->SetGridSize( m_grids[ currentGrid ] );
506
507 // Put cursor on new grid
508 VECTOR2D gridCursor = getViewControls()->GetCursorPosition( true );
509 getViewControls()->SetCrossHairCursorPosition( gridCursor, false );
510
511 // Show feedback
512 if( aFromHotkey )
514
515 return 0;
516}
517
518
520{
521 return GridPreset( m_frame->config()->m_Window.grid.fast_grid_1, true );
522}
523
524
526{
527 return GridPreset( m_frame->config()->m_Window.grid.fast_grid_2, true );
528}
529
530
532{
535 {
536 return GridPreset( m_frame->config()->m_Window.grid.fast_grid_2, true );
537 }
538
539 return GridPreset( m_frame->config()->m_Window.grid.fast_grid_1, true );
540}
541
542
544{
546 return 0;
547}
548
549
551{
553 return 0;
554}
555
556
558{
559 auto showGridPrefs =
560 [this]( const wxString& aParentName )
561 {
562 m_frame->CallAfter(
563 [this, aParentName]()
564 {
565 m_frame->ShowPreferences( _( "Grids" ), aParentName );
566 } );
567 };
568
569 switch( m_frame->GetFrameType() )
570 {
571 case FRAME_SCH: showGridPrefs( _( "Schematic Editor" ) ); break;
572 case FRAME_SCH_SYMBOL_EDITOR: showGridPrefs( _( "Symbol Editor" ) ); break;
573 case FRAME_PCB_EDITOR: showGridPrefs( _( "PCB Editor" ) ); break;
574 case FRAME_FOOTPRINT_EDITOR: showGridPrefs( _( "Footprint Editor" ) ); break;
575 case FRAME_PL_EDITOR: showGridPrefs( _( "Drawing Sheet Editor" ) ); break;
576 case FRAME_GERBER: showGridPrefs( _( "Gerber Viewer" ) ); break;
577 default: wxFAIL_MSG( "Unknown frame: " + GetName() ); break;
578 }
579
580 return 0;
581}
582
583
585{
586 VECTOR2I origin = m_frame->GetGridOrigin();
587 WX_PT_ENTRY_DIALOG dlg( m_frame, _( "Grid Origin" ), _( "X:" ), _( "Y:" ), origin );
588
589 if( dlg.ShowModal() == wxID_OK )
590 {
592
596 }
597
598 return 0;
599}
600
601
603{
604 EDA_UNITS newUnit = aEvent.Parameter<EDA_UNITS>();
605
606 if( EDA_UNIT_UTILS::IsMetricUnit( newUnit ) )
607 m_metricUnit = newUnit;
608 else if( EDA_UNIT_UTILS::IsImperialUnit( newUnit ) )
609 m_imperialUnit = newUnit;
610 else
611 wxASSERT_MSG( false, wxS( "Invalid unit for the frame" ) );
612
613 m_frame->ChangeUserUnits( newUnit );
614 return 0;
615}
616
617
619{
623 return 0;
624}
625
626
628{
629 m_frame->SetStatusText( wxEmptyString );
632
633 return 0;
634}
635
636
638{
639 const KIGFX::VC_SETTINGS& vcSettings = m_toolMgr->GetCurrentToolVC();
640
641 // Use either the active tool forced cursor position or the general settings
642 if( vcSettings.m_forceCursorPosition )
644 else
646
648
649 return 0;
650}
651
652
654{
655 auto& galOpts = m_frame->GetGalDisplayOptions();
656
657 galOpts.m_forceDisplayCursor = !galOpts.m_forceDisplayCursor;
658 galOpts.WriteConfig( m_toolMgr->GetSettings()->m_Window );
659 galOpts.NotifyChanged();
660
661 return 0;
662}
663
664
666{
668
669 galOpts.m_fullscreenCursor = !galOpts.m_fullscreenCursor;
671 galOpts.NotifyChanged();
672
673 return 0;
674}
675
676
678{
680
681 if( canvas )
682 {
684
686
687 canvas->GetView()->UpdateAllItems( KIGFX::ALL );
688 canvas->ForceRefresh();
689 }
690
691 return 0;
692}
693
694
696{
698
699 // Cursor control
708
712
713 // Pan control
718
719 // Zoom control
730
731 // Grid control
742
743 // Units and coordinates
750
751 // Misc
755}
756
757
BASE_SCREEN class implementation.
static TOOL_ACTION gridProperties
Definition: actions.h:179
static TOOL_ACTION gridFastCycle
Definition: actions.h:171
static TOOL_ACTION toggleGrid
Definition: actions.h:177
static TOOL_ACTION zoomRedraw
Definition: actions.h:116
static TOOL_ACTION millimetersUnits
Definition: actions.h:185
static TOOL_ACTION gridFast1
Definition: actions.h:169
static TOOL_ACTION gridPrev
Definition: actions.h:173
static TOOL_ACTION cursorLeft
Definition: actions.h:151
static TOOL_ACTION zoomOutCenter
Definition: actions.h:120
static TOOL_ACTION togglePolarCoords
Definition: actions.h:188
static TOOL_ACTION zoomIn
Definition: actions.h:117
static TOOL_ACTION cursorLeftFast
Definition: actions.h:156
static TOOL_ACTION gridPreset
Definition: actions.h:176
static TOOL_ACTION cursorDown
Definition: actions.h:150
static TOOL_ACTION zoomOut
Definition: actions.h:118
static TOOL_ACTION milsUnits
Definition: actions.h:184
static TOOL_ACTION cursorRightFast
Definition: actions.h:157
static TOOL_ACTION toggleBoundingBoxes
Definition: actions.h:137
static TOOL_ACTION showContextMenu
Definition: actions.h:67
static TOOL_ACTION toggleCursor
Definition: actions.h:133
static TOOL_ACTION centerContents
Definition: actions.h:132
static TOOL_ACTION zoomCenter
Definition: actions.h:125
static TOOL_ACTION panDown
Definition: actions.h:164
static TOOL_ACTION cursorDblClick
Definition: actions.h:160
CURSOR_EVENT_TYPE
Definition: actions.h:239
@ CURSOR_DBL_CLICK
Definition: actions.h:250
@ CURSOR_RIGHT
Definition: actions.h:247
@ CURSOR_LEFT_FAST
Definition: actions.h:246
@ CURSOR_LEFT
Definition: actions.h:245
@ CURSOR_DOWN_FAST
Definition: actions.h:244
@ CURSOR_CLICK
Definition: actions.h:249
@ CURSOR_UP
Definition: actions.h:241
@ CURSOR_RIGHT_FAST
Definition: actions.h:248
@ CURSOR_DOWN
Definition: actions.h:243
@ CURSOR_UP_FAST
Definition: actions.h:242
@ CURSOR_RIGHT_CLICK
Definition: actions.h:251
static TOOL_ACTION cursorDownFast
Definition: actions.h:155
static TOOL_ACTION inchesUnits
Definition: actions.h:183
static TOOL_ACTION cursorUpFast
Definition: actions.h:154
static TOOL_ACTION toggleCursorStyle
Definition: actions.h:134
static TOOL_ACTION gridOrigin
Definition: actions.h:180
static TOOL_ACTION panLeft
Definition: actions.h:165
static TOOL_ACTION selectionTool
Definition: actions.h:192
static TOOL_ACTION cursorClick
Definition: actions.h:159
static TOOL_ACTION zoomFitScreen
Definition: actions.h:126
static TOOL_ACTION zoomPreset
Definition: actions.h:128
static TOOL_ACTION panUp
Definition: actions.h:163
static TOOL_ACTION zoomFitObjects
Definition: actions.h:127
static TOOL_ACTION toggleUnits
Definition: actions.h:187
static TOOL_ACTION zoomInCenter
Definition: actions.h:119
static TOOL_ACTION panRight
Definition: actions.h:166
static TOOL_ACTION gridSetOrigin
Definition: actions.h:174
static TOOL_ACTION gridFast2
Definition: actions.h:170
static TOOL_ACTION cursorUp
Cursor control with keyboard.
Definition: actions.h:149
static TOOL_ACTION refreshPreview
Definition: actions.h:139
static TOOL_ACTION toggleGridOverrides
Definition: actions.h:178
static TOOL_ACTION gridNext
Definition: actions.h:172
static TOOL_ACTION cursorRight
Definition: actions.h:152
static TOOL_ACTION resetLocalCoords
Definition: actions.h:189
WINDOW_SETTINGS m_Window
Definition: app_settings.h:172
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 ZoomCenter(const TOOL_EVENT &aEvent)
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:123
EDA_UNITS m_imperialUnit
Definition: common_tools.h:122
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 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:118
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:109
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:100
@ ZOOM_FIT_ALL
Zoom to fall all items in view INCLUDING page and border.
Definition: common_tools.h:101
@ ZOOM_FIT_OBJECTS
Zoom to fit all items in view EXCLUDING page and border.
Definition: common_tools.h:102
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.
FRAME_T GetFrameType() const
virtual APP_SETTINGS_BASE * config() const
Returns the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
void ShowPreferences(wxString aStartPage, wxString aStartParentPage)
Displays the preferences and settings of all opened editors paged dialog, starting with a particular ...
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
Returns bbox 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:291
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:68
double GetScale() const
Definition: view.h:277
virtual void SetScale(double aScale, VECTOR2D aAnchor={ 0, 0 })
Set the scaling factor, zooming around a given anchor point.
Definition: view.cpp:587
GAL * GetGAL() const
Return the #GAL this view is using to draw graphical primitives.
Definition: view.h:203
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:484
bool IsMirroredX() const
Return true if view is flipped across the X axis.
Definition: view.h:251
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
Definition: view.cpp:1563
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:221
void SetCenter(const VECTOR2D &aCenter)
Set the center point of the VIEW (i.e.
Definition: view.cpp:613
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
Definition: view.h:625
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:42
TOOL_MANAGER * m_toolMgr
Definition: tool_base.h:218
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
@ 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:167
void SetMousePosition(const VECTOR2D &aP)
Definition: tool_event.h:525
void SetParameter(T aParam)
Set a non-standard parameter assigned to the event.
Definition: tool_event.h:515
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:460
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:400
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()
Returns the value in internal units.
#define _(s)
EDA_UNITS
Definition: eda_units.h:46
@ 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)
Function DoubleValueFromString converts aTextValue to a double.
Definition: eda_units.cpp:576
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:58
@ TARGET_NONCACHED
Auxiliary rendering target (noncached)
Definition: definitions.h:49
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
Is the forced cursor position enabled.
Definition: view_controls.h:56
bool m_forceCursorPosition
Should the cursor be locked within the parent window area.
Definition: view_controls.h:59
GRID_SETTINGS grid
Definition: app_settings.h:81
std::vector< double > zoom_factors
Definition: app_settings.h:78
TOOL_ACTIONS
Definition: tool_event.h:63
@ TA_MOUSE_CLICK
Definition: tool_event.h:66
@ TA_MOUSE_DBLCLICK
Definition: tool_event.h:67
@ TA_CANCEL_TOOL
Definition: tool_event.h:89
@ TC_COMMAND
Definition: tool_event.h:56
@ TC_MOUSE
Definition: tool_event.h:54
@ MD_ALT
Definition: tool_event.h:144
@ MD_CTRL
Definition: tool_event.h:143
@ MD_SHIFT
Definition: tool_event.h:142
TOOL_MOUSE_BUTTONS
Definition: tool_event.h:129
@ BUT_LEFT
Definition: tool_event.h:131
@ BUT_RIGHT
Definition: tool_event.h:132
VECTOR2< double > VECTOR2D
Definition: vector2d.h:690
VECTOR2I ToVECTOR2I(const wxSize &aSize)
Definition: vector2wx.h:30
VECTOR2D ToVECTOR2D(const wxPoint &aPoint)
Definition: vector2wx.h:40