KiCad PCB EDA Suite
Loading...
Searching...
No Matches
eda_base_frame.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) 2017 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright (C) 2013 Wayne Stambaugh <[email protected]>
6 * Copyright (C) 2023 CERN (www.cern.ch)
7 * Copyright (C) 1992-2024 KiCad Developers, see AUTHORS.txt for contributors.
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, you may find one here:
21 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22 * or you may search the http://www.gnu.org website for the version 2 license,
23 * or you may write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27#include <eda_base_frame.h>
28
29#include <advanced_config.h>
30#include <bitmaps.h>
31#include <bitmap_store.h>
32#include <dialog_shim.h>
38#include <eda_dde.h>
39#include <file_history.h>
40#include <id.h>
41#include <kiface_base.h>
42#include <hotkeys_basic.h>
44#include <paths.h>
45#include <confirm.h>
47#include <pgm_base.h>
52#include <tool/action_manager.h>
53#include <tool/action_menu.h>
54#include <tool/action_toolbar.h>
55#include <tool/actions.h>
56#include <tool/common_control.h>
57#include <tool/tool_manager.h>
59#include <trace_helpers.h>
62#include <widgets/wx_infobar.h>
64#include <widgets/wx_grid.h>
65#include <widgets/wx_treebook.h>
66#include <wx/app.h>
67#include <wx/config.h>
68#include <wx/display.h>
69#include <wx/stdpaths.h>
70#include <wx/string.h>
71#include <wx/msgdlg.h>
72#include <kiplatform/app.h>
73#include <kiplatform/io.h>
74#include <kiplatform/ui.h>
75
76#include <functional>
77#include <kiface_ids.h>
78
79#ifdef KICAD_IPC_API
80#include <api/api_server.h>
81#endif
82
83
84// Minimum window size
85static const wxSize minSizeLookup( FRAME_T aFrameType, wxWindow* aWindow )
86{
87 switch( aFrameType )
88 {
90 return wxWindow::FromDIP( wxSize( 406, 354 ), aWindow );
91
92 default:
93 return wxWindow::FromDIP( wxSize( 500, 400 ), aWindow );
94 }
95}
96
97
98static const wxSize defaultSize( FRAME_T aFrameType, wxWindow* aWindow )
99{
100 switch( aFrameType )
101 {
103 return wxWindow::FromDIP( wxSize( 850, 540 ), aWindow );
104
105 default:
106 return wxWindow::FromDIP( wxSize( 1280, 720 ), aWindow );
107 }
108}
109
110
111BEGIN_EVENT_TABLE( EDA_BASE_FRAME, wxFrame )
112 // These event table entries are needed to handle events from the mac application menu
113 EVT_MENU( wxID_ABOUT, EDA_BASE_FRAME::OnKicadAbout )
114 EVT_MENU( wxID_PREFERENCES, EDA_BASE_FRAME::OnPreferences )
115
116 EVT_CHAR_HOOK( EDA_BASE_FRAME::OnCharHook )
117 EVT_MENU_OPEN( EDA_BASE_FRAME::OnMenuEvent )
118 EVT_MENU_CLOSE( EDA_BASE_FRAME::OnMenuEvent )
119 EVT_MENU_HIGHLIGHT_ALL( EDA_BASE_FRAME::OnMenuEvent )
120 EVT_MOVE( EDA_BASE_FRAME::OnMove )
121 EVT_SIZE( EDA_BASE_FRAME::OnSize )
122 EVT_MAXIMIZE( EDA_BASE_FRAME::OnMaximize )
123
124 EVT_SYS_COLOUR_CHANGED( EDA_BASE_FRAME::onSystemColorChange )
125 EVT_ICONIZE( EDA_BASE_FRAME::onIconize )
126END_EVENT_TABLE()
127
128
129void EDA_BASE_FRAME::commonInit( FRAME_T aFrameType )
130{
131 m_ident = aFrameType;
132 m_maximizeByDefault = false;
133 m_infoBar = nullptr;
134 m_settingsManager = nullptr;
135 m_fileHistory = nullptr;
136 m_supportsAutoSave = false;
137 m_autoSavePending = false;
138 m_undoRedoCountMax = DEFAULT_MAX_UNDO_ITEMS;
139 m_isClosing = false;
140 m_isNonUserClose = false;
141 m_autoSaveTimer = new wxTimer( this, ID_AUTO_SAVE_TIMER );
142 m_autoSaveRequired = false;
144 m_frameSize = defaultSize( aFrameType, this );
145 m_displayIndex = -1;
146
147 m_auimgr.SetArtProvider( new WX_AUI_DOCK_ART() );
148
149 m_settingsManager = &Pgm().GetSettingsManager();
150
151 // Set a reasonable minimal size for the frame
152 wxSize minSize = minSizeLookup( aFrameType, this );
153 SetSizeHints( minSize.x, minSize.y, -1, -1, -1, -1 );
154
155 // Store dimensions of the user area of the main window.
156 GetClientSize( &m_frameSize.x, &m_frameSize.y );
157
158 Connect( ID_AUTO_SAVE_TIMER, wxEVT_TIMER,
159 wxTimerEventHandler( EDA_BASE_FRAME::onAutoSaveTimer ) );
160
161 // hook wxEVT_CLOSE_WINDOW so we can call SaveSettings(). This function seems
162 // to be called before any other hook for wxCloseEvent, which is necessary.
163 Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( EDA_BASE_FRAME::windowClosing ) );
164
165 initExitKey();
166}
167
168
169EDA_BASE_FRAME::EDA_BASE_FRAME( wxWindow* aParent, FRAME_T aFrameType, const wxString& aTitle,
170 const wxPoint& aPos, const wxSize& aSize, long aStyle,
171 const wxString& aFrameName, KIWAY* aKiway,
172 const EDA_IU_SCALE& aIuScale ) :
173 wxFrame( aParent, wxID_ANY, aTitle, aPos, aSize, aStyle, aFrameName ),
174 TOOLS_HOLDER(),
175 KIWAY_HOLDER( aKiway, KIWAY_HOLDER::FRAME ),
177{
178 commonInit( aFrameType );
179}
180
181
182wxWindow* findQuasiModalDialog( wxWindow* aParent )
183{
184 for( wxWindow* child : aParent->GetChildren() )
185 {
186 if( DIALOG_SHIM* dlg = dynamic_cast<DIALOG_SHIM*>( child ) )
187 {
188 if( dlg->IsQuasiModal() )
189 return dlg;
190
191 if( wxWindow* nestedDlg = findQuasiModalDialog( child ) )
192 return nestedDlg;
193 }
194 }
195
196 return nullptr;
197}
198
199
201{
202 if( wxWindow* dlg = ::findQuasiModalDialog( this ) )
203 return dlg;
204
205 // FIXME: CvPcb is currently implemented on top of KIWAY_PLAYER rather than DIALOG_SHIM,
206 // so we have to look for it separately.
207 if( m_ident == FRAME_SCH )
208 {
209 wxWindow* cvpcb = wxWindow::FindWindowByName( wxS( "CvpcbFrame" ) );
210
211 if( cvpcb )
212 return cvpcb;
213 }
214
215 return nullptr;
216}
217
218
219void EDA_BASE_FRAME::windowClosing( wxCloseEvent& event )
220{
221 // Don't allow closing when a quasi-modal is open.
222 wxWindow* quasiModal = findQuasiModalDialog();
223
224 if( quasiModal )
225 {
226 // Raise and notify; don't give the user a warning regarding "quasi-modal dialogs"
227 // when they have no idea what those are.
228 quasiModal->Raise();
229 wxBell();
230
231 if( event.CanVeto() )
232 event.Veto();
233
234 return;
235 }
236
237
238 if( event.GetId() == wxEVT_QUERY_END_SESSION
239 || event.GetId() == wxEVT_END_SESSION )
240 {
241 // End session means the OS is going to terminate us
242 m_isNonUserClose = true;
243 }
244
245 if( canCloseWindow( event ) )
246 {
247 m_isClosing = true;
248
249 if( m_infoBar )
251
252 APP_SETTINGS_BASE* cfg = config();
253
254 if( cfg )
255 SaveSettings( cfg ); // virtual, wxFrame specific
256
258
259 // Destroy (safe delete frame) this frame only in non modal mode.
260 // In modal mode, the caller will call Destroy().
261 if( !IsModal() )
262 Destroy();
263 }
264 else
265 {
266 if( event.CanVeto() )
267 event.Veto();
268 }
269}
270
271
273{
274 delete m_autoSaveTimer;
275 delete m_fileHistory;
276
278
280
282}
283
284
285bool EDA_BASE_FRAME::ProcessEvent( wxEvent& aEvent )
286{
287#ifdef __WXMAC__
288 // Apple in its infinite wisdom will raise a disabled window before even passing
289 // us the event, so we have no way to stop it. Instead, we have to catch an
290 // improperly ordered disabled window and quasi-modal dialog here and reorder
291 // them.
292 if( !IsEnabled() && IsActive() )
293 {
294 wxWindow* dlg = findQuasiModalDialog();
295 if( dlg )
296 dlg->Raise();
297 }
298#endif
299
300 if( !wxFrame::ProcessEvent( aEvent ) )
301 return false;
302
303 if( Pgm().m_Quitting )
304 return true;
305
306 if( !m_isClosing && m_supportsAutoSave && IsShownOnScreen() && IsActive()
308 && GetAutoSaveInterval() > 0 )
309 {
310 if( !m_autoSavePending )
311 {
312 wxLogTrace( traceAutoSave, wxT( "Starting auto save timer." ) );
313 m_autoSaveTimer->Start( GetAutoSaveInterval() * 1000, wxTIMER_ONE_SHOT );
314 m_autoSavePending = true;
315 }
316 else if( m_autoSaveTimer->IsRunning() )
317 {
318 wxLogTrace( traceAutoSave, wxT( "Stopping auto save timer." ) );
319 m_autoSaveTimer->Stop();
320 m_autoSavePending = false;
321 }
322 }
323
324 return true;
325}
326
327
329{
331}
332
333
334void EDA_BASE_FRAME::onAutoSaveTimer( wxTimerEvent& aEvent )
335{
336 // Don't stomp on someone else's timer event.
337 if( aEvent.GetId() != ID_AUTO_SAVE_TIMER )
338 {
339 aEvent.Skip();
340 return;
341 }
342
343 if( !doAutoSave() )
344 m_autoSaveTimer->Start( GetAutoSaveInterval() * 1000, wxTIMER_ONE_SHOT );
345}
346
347
349{
350 wxCHECK_MSG( false, true, wxT( "Auto save timer function not overridden. Bad programmer!" ) );
351}
352
353
354void EDA_BASE_FRAME::OnCharHook( wxKeyEvent& aKeyEvent )
355{
356 wxLogTrace( kicadTraceKeyEvent, wxS( "EDA_BASE_FRAME::OnCharHook %s" ), dump( aKeyEvent ) );
357
358 // Key events can be filtered here.
359 // Currently no filtering is made.
360 aKeyEvent.Skip();
361}
362
363
364void EDA_BASE_FRAME::OnMenuEvent( wxMenuEvent& aEvent )
365{
366 if( !m_toolDispatcher )
367 aEvent.Skip();
368 else
370}
371
372
374{
376 std::placeholders::_1,
377 this,
378 aConditions );
379
380 m_uiUpdateMap[aID] = evtFunc;
381
382 Bind( wxEVT_UPDATE_UI, evtFunc, aID );
383}
384
385
387{
388 const auto it = m_uiUpdateMap.find( aID );
389
390 if( it == m_uiUpdateMap.end() )
391 return;
392
393 Unbind( wxEVT_UPDATE_UI, it->second, aID );
394}
395
396
397void EDA_BASE_FRAME::HandleUpdateUIEvent( wxUpdateUIEvent& aEvent, EDA_BASE_FRAME* aFrame,
398 ACTION_CONDITIONS aCond )
399{
400 bool checkRes = false;
401 bool enableRes = true;
402 bool showRes = true;
403 bool isCut = aEvent.GetId() == ACTIONS::cut.GetUIId();
404 bool isCopy = aEvent.GetId() == ACTIONS::copy.GetUIId();
405 bool isPaste = aEvent.GetId() == ACTIONS::paste.GetUIId();
406 SELECTION& selection = aFrame->GetCurrentSelection();
407
408 try
409 {
410 checkRes = aCond.checkCondition( selection );
411 enableRes = aCond.enableCondition( selection );
412 showRes = aCond.showCondition( selection );
413 }
414 catch( std::exception& )
415 {
416 // Something broke with the conditions, just skip the event.
417 aEvent.Skip();
418 return;
419 }
420
421 if( showRes && aEvent.GetId() == ACTIONS::undo.GetUIId() )
422 {
423 wxString msg = _( "Undo" );
424
425 if( enableRes )
426 msg += wxS( " " ) + aFrame->GetUndoActionDescription();
427
428 aEvent.SetText( msg );
429 }
430 else if( showRes && aEvent.GetId() == ACTIONS::redo.GetUIId() )
431 {
432 wxString msg = _( "Redo" );
433
434 if( enableRes )
435 msg += wxS( " " ) + aFrame->GetRedoActionDescription();
436
437 aEvent.SetText( msg );
438 }
439
440 if( isCut || isCopy || isPaste )
441 {
442 wxWindow* focus = wxWindow::FindFocus();
443 wxTextEntry* textEntry = dynamic_cast<wxTextEntry*>( focus );
444
445 if( textEntry && isCut && textEntry->CanCut() )
446 enableRes = true;
447 else if( textEntry && isCopy && textEntry->CanCopy() )
448 enableRes = true;
449 else if( textEntry && isPaste && textEntry->CanPaste() )
450 enableRes = true;
451 else if( dynamic_cast<WX_GRID*>( focus ) )
452 enableRes = false; // Must disable menu in order to get command as CharHook event
453 }
454
455 aEvent.Enable( enableRes );
456 aEvent.Show( showRes );
457
458 if( aEvent.IsCheckable() )
459 aEvent.Check( checkRes );
460}
461
462
464{
465 // Setup the conditions to check a language menu item
466 auto isCurrentLang =
467 [] ( const SELECTION& aSel, int aLangIdentifier )
468 {
469 return Pgm().GetSelectedLanguageIdentifier() == aLangIdentifier;
470 };
471
472 for( unsigned ii = 0; LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
473 {
475 cond.Check( std::bind( isCurrentLang, std::placeholders::_1,
476 LanguagesList[ii].m_WX_Lang_Identifier ) );
477
478 RegisterUIUpdateHandler( LanguagesList[ii].m_KI_Lang_Identifier, cond );
479 }
480}
481
482
484{
492 CallAfter( [this]()
493 {
494 if( !m_isClosing )
496 } );
497}
498
499
500void EDA_BASE_FRAME::SetMenuBar( wxMenuBar* menu_bar )
501{
502 wxFrame::SetMenuBar( menu_bar );
503
504 // Move Help menu back to end of menubar
505
506 int pos = GetMenuBar()->FindMenu( _( "&Help" ) + wxS( " " ) );
507
508 if( pos != wxNOT_FOUND )
509 {
510 wxMenu* helpMenu = GetMenuBar()->Remove( pos );
511 GetMenuBar()->Append( helpMenu, _( "&Help" ) + wxS( " " ) );
512 }
513}
514
515
516void EDA_BASE_FRAME::AddStandardHelpMenu( wxMenuBar* aMenuBar )
517{
519 ACTION_MENU* helpMenu = new ACTION_MENU( false, commonControl );
520
521 helpMenu->Add( ACTIONS::help );
522 helpMenu->Add( ACTIONS::gettingStarted );
523 helpMenu->Add( ACTIONS::listHotKeys );
524 helpMenu->Add( ACTIONS::getInvolved );
525 helpMenu->Add( ACTIONS::donate );
526 helpMenu->Add( ACTIONS::reportBug );
527
528 helpMenu->AppendSeparator();
529 helpMenu->Add( ACTIONS::about );
530
531 // Trailing space keeps OSX from hijacking our menu (and disabling everything in it).
532 aMenuBar->Append( helpMenu, _( "&Help" ) + wxS( " " ) );
533
534 // This change is only needed on macOS, and creates a bug on Windows
535 #ifdef __WXMAC__
536 helpMenu->wxMenu::SetTitle( _( "&Help" ) + wxS( " " ) );
537 #endif
538}
539
540
542{
544
545 if( GetMenuBar() )
546 {
548 GetMenuBar()->Refresh();
549 }
550}
551
552
553void EDA_BASE_FRAME::CommonSettingsChanged( bool aEnvVarsChanged, bool aTextVarsChanged )
554{
555 TOOLS_HOLDER::CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
556
557 COMMON_SETTINGS* settings = Pgm().GetCommonSettings();
558
559#ifdef KICAD_IPC_API
560 bool running = Pgm().GetApiServer().Running();
561
562 if( running && !settings->m_Api.enable_server )
563 Pgm().GetApiServer().Stop();
564 else if( !running && settings->m_Api.enable_server )
565 Pgm().GetApiServer().Start();
566#endif
567
568 if( m_fileHistory )
569 {
570 int historySize = settings->m_System.file_history_size;
571 m_fileHistory->SetMaxFiles( (unsigned) std::max( 0, historySize ) );
572 }
573
575 ThemeChanged();
576
577 if( GetMenuBar() )
578 {
579 // For icons in menus, icon scaling & hotkeys
581 GetMenuBar()->Refresh();
582 }
583}
584
585
587{
589
590 // Update all the toolbars to have new icons
591 wxAuiPaneInfoArray panes = m_auimgr.GetAllPanes();
592
593 for( size_t i = 0; i < panes.GetCount(); ++i )
594 {
595 if( ACTION_TOOLBAR* toolbar = dynamic_cast<ACTION_TOOLBAR*>( panes[i].window ) )
596 toolbar->RefreshBitmaps();
597 }
598}
599
600
601void EDA_BASE_FRAME::OnSize( wxSizeEvent& aEvent )
602{
603#ifdef __WXMAC__
604 int currentDisplay = wxDisplay::GetFromWindow( this );
605
606 if( m_displayIndex >= 0 && currentDisplay >= 0 && currentDisplay != m_displayIndex )
607 {
608 wxLogTrace( traceDisplayLocation, wxS( "OnSize: current display changed %d to %d" ),
609 m_displayIndex, currentDisplay );
610 m_displayIndex = currentDisplay;
612 }
613#endif
614
615 aEvent.Skip();
616}
617
618
619void EDA_BASE_FRAME::LoadWindowState( const wxString& aFileName )
620{
621 if( !Pgm().GetCommonSettings()->m_Session.remember_open_files )
622 return;
623
624 const PROJECT_FILE_STATE* state = Prj().GetLocalSettings().GetFileState( aFileName );
625
626 if( state != nullptr )
627 {
628 LoadWindowState( state->window );
629 }
630}
631
632
634{
635 bool wasDefault = false;
636
637 m_framePos.x = aState.pos_x;
638 m_framePos.y = aState.pos_y;
639 m_frameSize.x = aState.size_x;
640 m_frameSize.y = aState.size_y;
641
642 wxLogTrace( traceDisplayLocation, wxS( "Config position (%d, %d) with size (%d, %d)" ),
644
645 // Ensure minimum size is set if the stored config was zero-initialized
646 wxSize minSize = minSizeLookup( m_ident, this );
647 if( m_frameSize.x < minSize.x || m_frameSize.y < minSize.y )
648 {
650 wasDefault = true;
651
652 wxLogTrace( traceDisplayLocation, wxS( "Using minimum size (%d, %d)" ),
654 }
655
656 wxLogTrace( traceDisplayLocation, wxS( "Number of displays: %d" ), wxDisplay::GetCount() );
657
658 if( aState.display >= wxDisplay::GetCount() )
659 {
660 wxLogTrace( traceDisplayLocation, wxS( "Previous display not found" ) );
661
662 // If it isn't attached, use the first display
663 // Warning wxDisplay has 2 ctor variants. the parameter needs a type:
664 const unsigned int index = 0;
665 wxDisplay display( index );
666 wxRect clientSize = display.GetGeometry();
667
668 m_framePos = wxDefaultPosition;
669
670 // Ensure the window fits on the display, since the other one could have been larger
671 if( m_frameSize.x > clientSize.width )
672 m_frameSize.x = clientSize.width;
673
674 if( m_frameSize.y > clientSize.height )
675 m_frameSize.y = clientSize.height;
676 }
677 else
678 {
679 wxPoint upperRight( m_framePos.x + m_frameSize.x, m_framePos.y );
680 wxPoint upperLeft( m_framePos.x, m_framePos.y );
681
682 wxDisplay display( aState.display );
683 wxRect clientSize = display.GetClientArea();
684
685 int yLimTop = clientSize.y;
686 int yLimBottom = clientSize.y + clientSize.height;
687 int xLimLeft = clientSize.x;
688 int xLimRight = clientSize.x + clientSize.width;
689
690 if( upperLeft.x > xLimRight || // Upper left corner too close to right edge of screen
691 upperRight.x < xLimLeft || // Upper right corner too close to left edge of screen
692 upperLeft.y < yLimTop || // Upper corner too close to the bottom of the screen
693 upperLeft.y > yLimBottom )
694 {
695 m_framePos = wxDefaultPosition;
696 wxLogTrace( traceDisplayLocation, wxS( "Resetting to default position" ) );
697 }
698 }
699
700 wxLogTrace( traceDisplayLocation, wxS( "Final window position (%d, %d) with size (%d, %d)" ),
702
703 SetSize( m_framePos.x, m_framePos.y, m_frameSize.x, m_frameSize.y );
704
705 // Center the window if we reset to default
706 if( m_framePos.x == -1 )
707 {
708 wxLogTrace( traceDisplayLocation, wxS( "Centering window" ) );
709 Center();
710 m_framePos = GetPosition();
711 }
712
713 // Record the frame sizes in an un-maximized state
716
717 // Maximize if we were maximized before
718 if( aState.maximized || ( wasDefault && m_maximizeByDefault ) )
719 {
720 wxLogTrace( traceDisplayLocation, wxS( "Maximizing window" ) );
721 Maximize();
722 }
723
724 m_displayIndex = wxDisplay::GetFromWindow( this );
725}
726
727
729{
730 wxDisplay display( wxDisplay::GetFromWindow( this ) );
731 wxRect clientSize = display.GetClientArea();
732 wxPoint pos = GetPosition();
733 wxSize size = GetWindowSize();
734
735 wxLogTrace( traceDisplayLocation,
736 wxS( "ensureWindowIsOnScreen: clientArea (%d, %d) w %d h %d" ),
737 clientSize.x, clientSize.y,
738 clientSize.width, clientSize.height );
739
740 if( pos.y < clientSize.y )
741 {
742 wxLogTrace( traceDisplayLocation,
743 wxS( "ensureWindowIsOnScreen: y pos %d below minimum, setting to %d" ), pos.y,
744 clientSize.y );
745 pos.y = clientSize.y;
746 }
747
748 if( pos.x < clientSize.x )
749 {
750 wxLogTrace( traceDisplayLocation,
751 wxS( "ensureWindowIsOnScreen: x pos %d is off the client rect, setting to %d" ),
752 pos.x, clientSize.x );
753 pos.x = clientSize.x;
754 }
755
756 if( pos.x + size.x - clientSize.x > clientSize.width )
757 {
758 int newWidth = clientSize.width - ( pos.x - clientSize.x );
759 wxLogTrace( traceDisplayLocation,
760 wxS( "ensureWindowIsOnScreen: effective width %d above available %d, setting "
761 "to %d" ), pos.x + size.x, clientSize.width, newWidth );
762 size.x = newWidth;
763 }
764
765 if( pos.y + size.y - clientSize.y > clientSize.height )
766 {
767 int newHeight = clientSize.height - ( pos.y - clientSize.y );
768 wxLogTrace( traceDisplayLocation,
769 wxS( "ensureWindowIsOnScreen: effective height %d above available %d, setting "
770 "to %d" ), pos.y + size.y, clientSize.height, newHeight );
771 size.y = newHeight;
772 }
773
774 wxLogTrace( traceDisplayLocation, wxS( "Updating window position (%d, %d) with size (%d, %d)" ),
775 pos.x, pos.y, size.x, size.y );
776
777 SetSize( pos.x, pos.y, size.x, size.y );
778}
779
780
782{
783 LoadWindowState( aCfg->state );
784
786 m_mruPath = aCfg->mru_path;
787
789}
790
791
793{
794 if( IsIconized() )
795 return;
796
797 // If the window is maximized, we use the saved window size from before it was maximized
798 if( IsMaximized() )
799 {
802 }
803 else
804 {
806 m_framePos = GetPosition();
807 }
808
809 aCfg->state.pos_x = m_framePos.x;
810 aCfg->state.pos_y = m_framePos.y;
811 aCfg->state.size_x = m_frameSize.x;
812 aCfg->state.size_y = m_frameSize.y;
813 aCfg->state.maximized = IsMaximized();
814 aCfg->state.display = wxDisplay::GetFromWindow( this );
815
816 wxLogTrace( traceDisplayLocation, wxS( "Saving window maximized: %s" ),
817 IsMaximized() ? wxS( "true" ) : wxS( "false" ) );
818 wxLogTrace( traceDisplayLocation, wxS( "Saving config position (%d, %d) with size (%d, %d)" ),
820
821 // Once this is fully implemented, wxAuiManager will be used to maintain
822 // the persistence of the main frame and all it's managed windows and
823 // all of the legacy frame persistence position code can be removed.
824 aCfg->perspective = m_auimgr.SavePerspective().ToStdString();
825
826 aCfg->mru_path = m_mruPath;
827}
828
829
831{
833
834 // Get file history size from common settings
835 int fileHistorySize = Pgm().GetCommonSettings()->m_System.file_history_size;
836
837 // Load the recently used files into the history menu
838 m_fileHistory = new FILE_HISTORY( (unsigned) std::max( 1, fileHistorySize ),
840 m_fileHistory->Load( *aCfg );
841}
842
843
845{
846 wxCHECK( config(), /* void */ );
847
849
850 bool fileOpen = m_isClosing && m_isNonUserClose;
851
852 wxString currentlyOpenedFile = GetCurrentFileName();
853
854 if( Pgm().GetCommonSettings()->m_Session.remember_open_files && !currentlyOpenedFile.IsEmpty() )
855 {
856 wxFileName rfn( currentlyOpenedFile );
857 rfn.MakeRelativeTo( Prj().GetProjectPath() );
858 Prj().GetLocalSettings().SaveFileState( rfn.GetFullPath(), &aCfg->m_Window, fileOpen );
859 }
860
861 // Save the recently used files list
862 if( m_fileHistory )
863 {
864 // Save the currently opened file in the file history
865 if( !currentlyOpenedFile.IsEmpty() )
866 UpdateFileHistory( currentlyOpenedFile );
867
868 m_fileHistory->Save( *aCfg );
869 }
870}
871
872
874{
875 return &aCfg->m_Window;
876}
877
878
880{
881 // KICAD_MANAGER_FRAME overrides this
882 return Kiface().KifaceSettings();
883}
884
885
887{
888 return Kiface().KifaceSearch();
889}
890
891
893{
894 return Kiface().GetHelpFileName();
895}
896
897
898void EDA_BASE_FRAME::PrintMsg( const wxString& text )
899{
900 SetStatusText( text );
901}
902
903
905{
906#if defined( __WXOSX_MAC__ )
908#else
909 m_infoBar = new WX_INFOBAR( this, &m_auimgr );
910
911 m_auimgr.AddPane( m_infoBar, EDA_PANE().InfoBar().Name( wxS( "InfoBar" ) ).Top().Layer(1) );
912#endif
913}
914
915
917{
918#if defined( __WXOSX_MAC__ )
919 m_auimgr.Update();
920#else
921 // Call Update() to fix all pane default sizes, especially the "InfoBar" pane before
922 // hiding it.
923 m_auimgr.Update();
924
925 // We don't want the infobar displayed right away
926 m_auimgr.GetPane( wxS( "InfoBar" ) ).Hide();
927 m_auimgr.Update();
928#endif
929}
930
931
932void EDA_BASE_FRAME::ShowInfoBarError( const wxString& aErrorMsg, bool aShowCloseButton,
934{
936
937 if( aShowCloseButton )
939
940 GetInfoBar()->ShowMessageFor( aErrorMsg, 8000, wxICON_ERROR, aType );
941}
942
943
944void EDA_BASE_FRAME::ShowInfoBarError( const wxString& aErrorMsg, bool aShowCloseButton,
945 std::function<void(void)> aCallback )
946{
948
949 if( aShowCloseButton )
951
952 if( aCallback )
953 m_infoBar->SetCallback( aCallback );
954
955 GetInfoBar()->ShowMessageFor( aErrorMsg, 6000, wxICON_ERROR );
956}
957
958
959void EDA_BASE_FRAME::ShowInfoBarWarning( const wxString& aWarningMsg, bool aShowCloseButton )
960{
962
963 if( aShowCloseButton )
965
966 GetInfoBar()->ShowMessageFor( aWarningMsg, 6000, wxICON_WARNING );
967}
968
969
970void EDA_BASE_FRAME::ShowInfoBarMsg( const wxString& aMsg, bool aShowCloseButton )
971{
973
974 if( aShowCloseButton )
976
977 GetInfoBar()->ShowMessageFor( aMsg, 8000, wxICON_INFORMATION );
978}
979
980
981void EDA_BASE_FRAME::UpdateFileHistory( const wxString& FullFileName, FILE_HISTORY* aFileHistory )
982{
983 if( !aFileHistory )
984 aFileHistory = m_fileHistory;
985
986 wxASSERT( aFileHistory );
987
988 aFileHistory->AddFileToHistory( FullFileName );
989
990 // Update the menubar to update the file history menu
991 if( !m_isClosing && GetMenuBar() )
992 {
994 GetMenuBar()->Refresh();
995 }
996}
997
998
999wxString EDA_BASE_FRAME::GetFileFromHistory( int cmdId, const wxString& type,
1000 FILE_HISTORY* aFileHistory )
1001{
1002 if( !aFileHistory )
1003 aFileHistory = m_fileHistory;
1004
1005 wxASSERT( aFileHistory );
1006
1007 int baseId = aFileHistory->GetBaseId();
1008
1009 wxASSERT( cmdId >= baseId && cmdId < baseId + (int) aFileHistory->GetCount() );
1010
1011 unsigned i = cmdId - baseId;
1012
1013 if( i < aFileHistory->GetCount() )
1014 {
1015 wxString fn = aFileHistory->GetHistoryFile( i );
1016
1017 if( wxFileName::FileExists( fn ) )
1018 {
1019 return fn;
1020 }
1021 else
1022 {
1023 DisplayErrorMessage( this, wxString::Format( _( "File '%s' was not found." ), fn ) );
1024 aFileHistory->RemoveFileFromHistory( i );
1025 }
1026 }
1027
1028 // Update the menubar to update the file history menu
1029 if( GetMenuBar() )
1030 {
1032 GetMenuBar()->Refresh();
1033 }
1034
1035 return wxEmptyString;
1036}
1037
1038
1040{
1041 if( !aFileHistory )
1042 aFileHistory = m_fileHistory;
1043
1044 wxASSERT( aFileHistory );
1045
1046 aFileHistory->ClearFileHistory();
1047
1048 // Update the menubar to update the file history menu
1049 if( GetMenuBar() )
1050 {
1052 GetMenuBar()->Refresh();
1053 }
1054}
1055
1056
1057void EDA_BASE_FRAME::OnKicadAbout( wxCommandEvent& event )
1058{
1059 void ShowAboutDialog( EDA_BASE_FRAME * aParent ); // See AboutDialog_main.cpp
1060 ShowAboutDialog( this );
1061}
1062
1063
1064void EDA_BASE_FRAME::OnPreferences( wxCommandEvent& event )
1065{
1066 ShowPreferences( wxEmptyString, wxEmptyString );
1067}
1068
1069
1070void EDA_BASE_FRAME::ShowPreferences( wxString aStartPage, wxString aStartParentPage )
1071{
1072 PAGED_DIALOG dlg( this, _( "Preferences" ), true, true, wxEmptyString,
1073 wxWindow::FromDIP( wxSize( 980, 560 ), NULL ) );
1074
1075 dlg.SetEvtHandlerEnabled( false );
1076
1077 {
1078 WX_BUSY_INDICATOR busy_cursor;
1079
1080 WX_TREEBOOK* book = dlg.GetTreebook();
1081 PANEL_HOTKEYS_EDITOR* hotkeysPanel = new PANEL_HOTKEYS_EDITOR( this, book, false );
1082 KIFACE* kiface = nullptr;
1083 std::vector<int> expand;
1084
1085 Kiway().GetActions( hotkeysPanel->ActionsList() );
1086
1087 book->AddLazyPage(
1088 []( wxWindow* aParent ) -> wxWindow*
1089 {
1090 return new PANEL_COMMON_SETTINGS( aParent );
1091 },
1092 _( "Common" ) );
1093
1094 book->AddLazyPage(
1095 []( wxWindow* aParent ) -> wxWindow*
1096 {
1097 return new PANEL_MOUSE_SETTINGS( aParent );
1098 }, _( "Mouse and Touchpad" ) );
1099
1100 book->AddPage( hotkeysPanel, _( "Hotkeys" ) );
1101
1102 // This currently allows pre-defined repositories that we
1103 // don't use, so keep it disabled at the moment
1104 if( ADVANCED_CFG::GetCfg().m_EnableGit && false )
1105 {
1106 book->AddLazyPage(
1107 []( wxWindow* aParent ) -> wxWindow*
1108 {
1109 return new PANEL_GIT_REPOS( aParent );
1110 }, _( "Version Control" ) );
1111 }
1112
1113 #ifdef KICAD_USE_SENTRY
1114 book->AddLazyPage(
1115 []( wxWindow* aParent ) -> wxWindow*
1116 {
1117 return new PANEL_DATA_COLLECTION( aParent );
1118 }, _( "Data Collection" ) );
1119 #endif
1120
1121 #define LAZY_CTOR( key ) \
1122 [this, kiface]( wxWindow* aParent ) \
1123 { \
1124 return kiface->CreateKiWindow( aParent, key, &Kiway() ); \
1125 }
1126
1127 // If a dll is not loaded, the loader will show an error message.
1128
1129 try
1130 {
1132
1133 if( !kiface )
1134 return;
1135
1136 kiface->GetActions( hotkeysPanel->ActionsList() );
1137
1139 expand.push_back( (int) book->GetPageCount() );
1140
1141 book->AddPage( new wxPanel( book ), _( "Symbol Editor" ) );
1142 book->AddLazySubPage( LAZY_CTOR( PANEL_SYM_DISP_OPTIONS ), _( "Display Options" ) );
1143 book->AddLazySubPage( LAZY_CTOR( PANEL_SYM_EDIT_GRIDS ), _( "Grids" ) );
1144 book->AddLazySubPage( LAZY_CTOR( PANEL_SYM_EDIT_OPTIONS ), _( "Editing Options" ) );
1145 book->AddLazySubPage( LAZY_CTOR( PANEL_SYM_COLORS ), _( "Colors" ) );
1146
1147 if( GetFrameType() == FRAME_SCH )
1148 expand.push_back( (int) book->GetPageCount() );
1149
1150 book->AddPage( new wxPanel( book ), _( "Schematic Editor" ) );
1151 book->AddLazySubPage( LAZY_CTOR( PANEL_SCH_DISP_OPTIONS ), _( "Display Options" ) );
1152 book->AddLazySubPage( LAZY_CTOR( PANEL_SCH_GRIDS ), _( "Grids" ) );
1153 book->AddLazySubPage( LAZY_CTOR( PANEL_SCH_EDIT_OPTIONS ), _( "Editing Options" ) );
1154 book->AddLazySubPage( LAZY_CTOR( PANEL_SCH_ANNO_OPTIONS ), _( "Annotation Options" ) );
1155 book->AddLazySubPage( LAZY_CTOR( PANEL_SCH_COLORS ), _( "Colors" ) );
1156 book->AddLazySubPage( LAZY_CTOR( PANEL_SCH_FIELD_NAME_TEMPLATES ), _( "Field Name Templates" ) );
1157 book->AddLazySubPage( LAZY_CTOR( PANEL_SCH_SIMULATOR ), _( "Simulator" ) );
1158 }
1159 catch( ... )
1160 {
1161 }
1162
1163 try
1164 {
1166
1167 if( !kiface )
1168 return;
1169
1170 kiface->GetActions( hotkeysPanel->ActionsList() );
1171
1173 expand.push_back( (int) book->GetPageCount() );
1174
1175 book->AddPage( new wxPanel( book ), _( "Footprint Editor" ) );
1176 book->AddLazySubPage( LAZY_CTOR( PANEL_FP_DISPLAY_OPTIONS ), _( "Display Options" ) );
1177 book->AddLazySubPage( LAZY_CTOR( PANEL_FP_GRIDS ), _( "Grids" ) );
1178 book->AddLazySubPage( LAZY_CTOR( PANEL_FP_ORIGINS_AXES ), _( "Origins & Axes" ) );
1179 book->AddLazySubPage( LAZY_CTOR( PANEL_FP_EDIT_OPTIONS ), _( "Editing Options" ) );
1180 book->AddLazySubPage( LAZY_CTOR( PANEL_FP_COLORS ), _( "Colors" ) );
1181 book->AddLazySubPage( LAZY_CTOR( PANEL_FP_DEFAULT_VALUES ), _( "Default Values" ) );
1182
1184 expand.push_back( (int) book->GetPageCount() );
1185
1186 book->AddPage( new wxPanel( book ), _( "PCB Editor" ) );
1187 book->AddLazySubPage( LAZY_CTOR( PANEL_PCB_DISPLAY_OPTS ), _( "Display Options" ) );
1188 book->AddLazySubPage( LAZY_CTOR( PANEL_PCB_GRIDS ), _( "Grids" ) );
1189 book->AddLazySubPage( LAZY_CTOR( PANEL_PCB_ORIGINS_AXES ), _( "Origins & Axes" ) );
1190 book->AddLazySubPage( LAZY_CTOR( PANEL_PCB_EDIT_OPTIONS ), _( "Editing Options" ) );
1191 book->AddLazySubPage( LAZY_CTOR( PANEL_PCB_COLORS ), _( "Colors" ) );
1192 book->AddLazySubPage( LAZY_CTOR( PANEL_PCB_ACTION_PLUGINS ), _( "Action Plugins" ) );
1193
1195 expand.push_back( (int) book->GetPageCount() );
1196
1197 book->AddPage( new wxPanel( book ), _( "3D Viewer" ) );
1198 book->AddLazySubPage( LAZY_CTOR( PANEL_3DV_DISPLAY_OPTIONS ), _( "General" ) );
1199 book->AddLazySubPage( LAZY_CTOR( PANEL_3DV_OPENGL ), _( "Realtime Renderer" ) );
1200 book->AddLazySubPage( LAZY_CTOR( PANEL_3DV_RAYTRACING ), _( "Raytracing Renderer" ) );
1201 }
1202 catch( ... )
1203 {
1204 }
1205
1206 try
1207 {
1209
1210 if( !kiface )
1211 return;
1212
1213 kiface->GetActions( hotkeysPanel->ActionsList() );
1214
1215 if( GetFrameType() == FRAME_GERBER )
1216 expand.push_back( (int) book->GetPageCount() );
1217
1218 book->AddPage( new wxPanel( book ), _( "Gerber Viewer" ) );
1219 book->AddLazySubPage( LAZY_CTOR( PANEL_GBR_DISPLAY_OPTIONS ), _( "Display Options" ) );
1220 book->AddLazySubPage( LAZY_CTOR( PANEL_GBR_COLORS ), _( "Colors" ) );
1221 book->AddLazySubPage( LAZY_CTOR( PANEL_GBR_GRIDS ), _( "Grids" ) );
1222 book->AddLazySubPage( LAZY_CTOR( PANEL_GBR_EXCELLON_OPTIONS ), _( "Excellon Options" ) );
1223 }
1224 catch( ... )
1225 {
1226 }
1227
1228 try
1229 {
1231
1232 if( !kiface )
1233 return;
1234
1235 kiface->GetActions( hotkeysPanel->ActionsList() );
1236
1237 if( GetFrameType() == FRAME_PL_EDITOR )
1238 expand.push_back( (int) book->GetPageCount() );
1239
1240 book->AddPage( new wxPanel( book ), _( "Drawing Sheet Editor" ) );
1241 book->AddLazySubPage( LAZY_CTOR( PANEL_DS_DISPLAY_OPTIONS ), _( "Display Options" ) );
1242 book->AddLazySubPage( LAZY_CTOR( PANEL_DS_GRIDS ), _( "Grids" ) );
1243 book->AddLazySubPage( LAZY_CTOR( PANEL_DS_COLORS ), _( "Colors" ) );
1244
1245 book->AddLazyPage(
1246 []( wxWindow* aParent ) -> wxWindow*
1247 {
1248 return new PANEL_PACKAGES_AND_UPDATES( aParent );
1249 }, _( "Packages and Updates" ) );
1250 }
1251 catch( ... )
1252 {
1253 }
1254
1255#ifdef KICAD_IPC_API
1256 book->AddPage( new PANEL_PLUGIN_SETTINGS( book ), _( "Plugins" ) );
1257#endif
1258
1259 // Update all of the action hotkeys. The process of loading the actions through
1260 // the KiFACE will only get us the default hotkeys
1261 ReadHotKeyConfigIntoActions( wxEmptyString, hotkeysPanel->ActionsList() );
1262
1263 for( size_t i = 0; i < book->GetPageCount(); ++i )
1264 book->GetPage( i )->Layout();
1265
1266 for( int page : expand )
1267 book->ExpandNode( page );
1268
1269 if( !aStartPage.IsEmpty() )
1270 dlg.SetInitialPage( aStartPage, aStartParentPage );
1271
1272 dlg.SetEvtHandlerEnabled( true );
1273#undef LAZY_CTOR
1274 }
1275
1276 if( dlg.ShowModal() == wxID_OK )
1277 {
1278 // Update our grids that are cached in the tool
1281 dlg.Kiway().CommonSettingsChanged( false, false );
1282 }
1283
1284}
1285
1286
1287void EDA_BASE_FRAME::OnDropFiles( wxDropFilesEvent& aEvent )
1288{
1289 wxString* files = aEvent.GetFiles();
1290
1291 for( int nb = 0; nb < aEvent.GetNumberOfFiles(); nb++ )
1292 {
1293 const wxFileName fn = wxFileName( files[nb] );
1294 wxString ext = fn.GetExt();
1295
1296 // Alias all gerber files as GerberFileExtension
1299
1300 if( m_acceptedExts.find( ext.ToStdString() ) != m_acceptedExts.end() )
1301 m_AcceptedFiles.emplace_back( fn );
1302 }
1303
1305 m_AcceptedFiles.clear();
1306}
1307
1308
1310{
1311 for( const wxFileName& file : m_AcceptedFiles )
1312 {
1313 wxString fn = file.GetFullPath();
1314 m_toolManager->RunAction<wxString*>( *m_acceptedExts.at( file.GetExt() ), &fn );
1315 }
1316}
1317
1318
1319bool EDA_BASE_FRAME::IsWritable( const wxFileName& aFileName, bool aVerbose )
1320{
1321 wxString msg;
1322 wxFileName fn = aFileName;
1323
1324 // Check for absence of a file path with a file name. Unfortunately KiCad
1325 // uses paths relative to the current project path without the ./ part which
1326 // confuses wxFileName. Making the file name path absolute may be less than
1327 // elegant but it solves the problem.
1328 if( fn.GetPath().IsEmpty() && fn.HasName() )
1329 fn.MakeAbsolute();
1330
1331 wxCHECK_MSG( fn.IsOk(), false,
1332 wxT( "File name object is invalid. Bad programmer!" ) );
1333 wxCHECK_MSG( !fn.GetPath().IsEmpty(), false,
1334 wxT( "File name object path <" ) + fn.GetFullPath() +
1335 wxT( "> is not set. Bad programmer!" ) );
1336
1337 if( fn.IsDir() && !fn.IsDirWritable() )
1338 {
1339 msg.Printf( _( "Insufficient permissions to folder '%s'." ), fn.GetPath() );
1340 }
1341 else if( !fn.FileExists() && !fn.IsDirWritable() )
1342 {
1343 msg.Printf( _( "Insufficient permissions to save file '%s'." ), fn.GetFullPath() );
1344 }
1345 else if( fn.FileExists() && !fn.IsFileWritable() )
1346 {
1347 msg.Printf( _( "Insufficient permissions to save file '%s'." ), fn.GetFullPath() );
1348 }
1349
1350 if( !msg.IsEmpty() )
1351 {
1352 if( aVerbose )
1353 DisplayErrorMessage( this, msg );
1354
1355 return false;
1356 }
1357
1358 return true;
1359}
1360
1361
1362void EDA_BASE_FRAME::CheckForAutoSaveFile( const wxFileName& aFileName )
1363{
1364 if( !Pgm().IsGUI() )
1365 return;
1366
1367 wxCHECK_RET( aFileName.IsOk(), wxT( "Invalid file name!" ) );
1368
1369 wxFileName autoSaveFileName = aFileName;
1370
1371 // Check for auto save file.
1372 autoSaveFileName.SetName( FILEEXT::AutoSaveFilePrefix + aFileName.GetName() );
1373
1374 wxLogTrace( traceAutoSave,
1375 wxT( "Checking for auto save file " ) + autoSaveFileName.GetFullPath() );
1376
1377 if( !autoSaveFileName.FileExists() )
1378 return;
1379
1380 wxString msg = wxString::Format( _( "Well this is potentially embarrassing!\n"
1381 "It appears that the last time you were editing\n"
1382 "%s\n"
1383 "KiCad exited before saving.\n"
1384 "\n"
1385 "Do you wish to open the auto-saved file instead?" ),
1386 aFileName.GetFullName() );
1387
1388 int response = wxMessageBox( msg, Pgm().App().GetAppDisplayName(), wxYES_NO | wxICON_QUESTION,
1389 this );
1390
1391 // Make a backup of the current file, delete the file, and rename the auto save file to
1392 // the file name.
1393 if( response == wxYES )
1394 {
1395 // Preserve the permissions of the current file
1396 KIPLATFORM::IO::DuplicatePermissions( aFileName.GetFullPath(), autoSaveFileName.GetFullPath() );
1397
1398 if( !wxRenameFile( autoSaveFileName.GetFullPath(), aFileName.GetFullPath() ) )
1399 {
1400 wxMessageBox( _( "The auto save file could not be renamed to the board file name." ),
1401 Pgm().App().GetAppDisplayName(), wxOK | wxICON_EXCLAMATION, this );
1402 }
1403 }
1404 else
1405 {
1406 DeleteAutoSaveFile( aFileName );
1407 }
1408}
1409
1410
1411void EDA_BASE_FRAME::DeleteAutoSaveFile( const wxFileName& aFileName )
1412{
1413 if( !Pgm().IsGUI() )
1414 return;
1415
1416 wxCHECK_RET( aFileName.IsOk(), wxT( "Invalid file name!" ) );
1417
1418 wxFileName autoSaveFn = aFileName;
1419 autoSaveFn.SetName( FILEEXT::AutoSaveFilePrefix + aFileName.GetName() );
1420
1421 if( autoSaveFn.FileExists() )
1422 {
1423 wxLogTrace( traceAutoSave, wxT( "Removing auto save file " ) + autoSaveFn.GetFullPath() );
1424 wxRemoveFile( autoSaveFn.GetFullPath() );
1425 }
1426}
1427
1428
1430{
1431 // This function should be overridden in child classes
1432 return false;
1433}
1434
1435
1437{
1438 wxAcceleratorEntry entries[1];
1439 entries[0].Set( wxACCEL_CTRL, int( 'Q' ), wxID_EXIT );
1440 wxAcceleratorTable accel( 1, entries );
1441 SetAcceleratorTable( accel );
1442}
1443
1444
1446{
1449}
1450
1451
1453{
1454 m_undoList.PushCommand( aNewitem );
1455
1456 // Delete the extra items, if count max reached
1457 if( m_undoRedoCountMax > 0 )
1458 {
1459 int extraitems = GetUndoCommandCount() - m_undoRedoCountMax;
1460
1461 if( extraitems > 0 )
1462 ClearUndoORRedoList( UNDO_LIST, extraitems );
1463 }
1464}
1465
1466
1468{
1469 m_redoList.PushCommand( aNewitem );
1470
1471 // Delete the extra items, if count max reached
1472 if( m_undoRedoCountMax > 0 )
1473 {
1474 int extraitems = GetRedoCommandCount() - m_undoRedoCountMax;
1475
1476 if( extraitems > 0 )
1477 ClearUndoORRedoList( REDO_LIST, extraitems );
1478 }
1479}
1480
1481
1483{
1484 return m_undoList.PopCommand();
1485}
1486
1487
1489{
1490 return m_redoList.PopCommand();
1491}
1492
1493
1495{
1496 if( GetUndoCommandCount() > 0 )
1497 return m_undoList.m_CommandsList.back()->GetDescription();
1498
1499 return wxEmptyString;
1500}
1501
1502
1504{
1505 if( GetRedoCommandCount() > 0 )
1506 return m_redoList.m_CommandsList.back()->GetDescription();
1507
1508 return wxEmptyString;
1509}
1510
1511
1513{
1514 m_autoSaveRequired = true;
1515}
1516
1517
1519{
1520 SetUserUnits( aUnits );
1522
1523 wxCommandEvent e( EDA_EVT_UNITS_CHANGED );
1524 e.SetInt( static_cast<int>( aUnits ) );
1525 e.SetClientData( this );
1526 ProcessEventLocally( e );
1527}
1528
1529
1530void EDA_BASE_FRAME::OnMaximize( wxMaximizeEvent& aEvent )
1531{
1532 // When we maximize the window, we want to save the old information
1533 // so that we can add it to the settings on next window load.
1534 // Contrary to the documentation, this event seems to be generated
1535 // when the window is also being unmaximized on OSX, so we only
1536 // capture the size information when we maximize the window when on OSX.
1537#ifdef __WXOSX__
1538 if( !IsMaximized() )
1539#endif
1540 {
1542 m_normalFramePos = GetPosition();
1543 wxLogTrace( traceDisplayLocation,
1544 "Maximizing window - Saving position (%d, %d) with size (%d, %d)",
1547 }
1548
1549 // Skip event to actually maximize the window
1550 aEvent.Skip();
1551}
1552
1553
1555{
1556#ifdef __WXGTK__
1557 wxSize winSize = GetSize();
1558
1559 // GTK includes the window decorations in the normal GetSize call,
1560 // so we have to use a GTK-specific sizing call that returns the
1561 // non-decorated window size.
1563 {
1564 int width = 0;
1565 int height = 0;
1566 GTKDoGetSize( &width, &height );
1567
1568 winSize.Set( width, height );
1569 }
1570#else
1571 wxSize winSize = GetSize();
1572#endif
1573
1574 return winSize;
1575}
1576
1577
1579{
1580 // Update the icon theme when the system theme changes and update the toolbars
1582 ThemeChanged();
1583
1584 // This isn't handled by ThemeChanged()
1585 if( GetMenuBar() )
1586 {
1587 // For icons in menus, icon scaling & hotkeys
1589 GetMenuBar()->Refresh();
1590 }
1591}
1592
1593
1594void EDA_BASE_FRAME::onSystemColorChange( wxSysColourChangedEvent& aEvent )
1595{
1596 // Call the handler to update the colors used in the frame
1598
1599 // Skip the change event to ensure the rest of the window controls get it
1600 aEvent.Skip();
1601}
1602
1603
1604void EDA_BASE_FRAME::onIconize( wxIconizeEvent& aEvent )
1605{
1606 // Call the handler
1607 handleIconizeEvent( aEvent );
1608
1609 // Skip the event.
1610 aEvent.Skip();
1611}
1612
1613
1614#ifdef _WIN32
1615WXLRESULT EDA_BASE_FRAME::MSWWindowProc( WXUINT message, WXWPARAM wParam, WXLPARAM lParam )
1616{
1617 // This will help avoid the menu keeping focus when the alt key is released
1618 // You can still trigger accelerators as long as you hold down alt
1619 if( message == WM_SYSCOMMAND )
1620 {
1621 if( wParam == SC_KEYMENU && ( lParam >> 16 ) <= 0 )
1622 return 0;
1623 }
1624
1625 return wxFrame::MSWWindowProc( message, wParam, lParam );
1626}
1627#endif
1628
1629
1638{
1639 ACTION_MENU* langsMenu = new ACTION_MENU( false, aControlTool );
1640 langsMenu->SetTitle( _( "Set Language" ) );
1641 langsMenu->SetIcon( BITMAPS::language );
1642
1643 wxString tooltip;
1644
1645 for( unsigned ii = 0; LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
1646 {
1647 wxString label;
1648
1649 if( LanguagesList[ii].m_DoNotTranslate )
1650 label = LanguagesList[ii].m_Lang_Label;
1651 else
1652 label = wxGetTranslation( LanguagesList[ii].m_Lang_Label );
1653
1654 wxMenuItem* item =
1655 new wxMenuItem( langsMenu,
1656 LanguagesList[ii].m_KI_Lang_Identifier, // wxMenuItem wxID
1657 label, tooltip, wxITEM_CHECK );
1658
1659 langsMenu->Append( item );
1660 }
1661
1662 // This must be done after the items are added
1663 aMasterMenu->Add( langsMenu );
1664}
void ShowAboutDialog(EDA_BASE_FRAME *aParent)
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
void ClearScaledBitmapCache()
Wipes out the scaled bitmap cache so that the icon theme can be changed.
Definition: bitmap.cpp:172
BITMAP_STORE * GetBitmapStore()
Definition: bitmap.cpp:92
static TOOL_ACTION paste
Definition: actions.h:70
static TOOL_ACTION about
Definition: actions.h:217
static TOOL_ACTION reportBug
Definition: actions.h:221
static TOOL_ACTION copy
Definition: actions.h:69
static TOOL_ACTION donate
Definition: actions.h:219
static TOOL_ACTION listHotKeys
Definition: actions.h:218
static TOOL_ACTION getInvolved
Definition: actions.h:220
static TOOL_ACTION undo
Definition: actions.h:66
static TOOL_ACTION redo
Definition: actions.h:67
static TOOL_ACTION cut
Definition: actions.h:68
static TOOL_ACTION gettingStarted
Definition: actions.h:215
static TOOL_ACTION help
Definition: actions.h:216
Defines the structure of a menu based on ACTIONs.
Definition: action_menu.h:49
void SetTitle(const wxString &aTitle) override
Set title for the menu.
Definition: action_menu.cpp:92
void SetIcon(BITMAPS aIcon)
Assign an icon for the entry.
Definition: action_menu.cpp:78
wxMenuItem * Add(const wxString &aLabel, int aId, BITMAPS aIcon)
Add a wxWidgets-style entry to the menu.
Define the structure of a toolbar with buttons that invoke ACTIONs.
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
APP_SETTINGS_BASE is a settings class that should be derived for each standalone KiCad application.
Definition: app_settings.h:92
WINDOW_SETTINGS m_Window
Definition: app_settings.h:172
void ThemeChanged()
Notifies the store that the icon theme has been changed by the user, so caches must be invalidated.
Handle actions that are shared between different applications.
Dialog helper object to sit in the inheritance tree between wxDialog and any class written by wxFormB...
Definition: dialog_shim.h:88
The base frame for deriving all KiCad main window classes.
virtual wxString help_name()
virtual bool doAutoSave()
This should be overridden by the derived class to handle the auto save feature.
void LoadWindowState(const wxString &aFileName)
FRAME_T GetFrameType() const
virtual void UnregisterUIUpdateHandler(int aID) override
Unregister a UI handler for a given ID that was registered using RegisterUIUpdateHandler.
virtual bool isAutoSaveRequired() const
Return the auto save status of the application.
virtual APP_SETTINGS_BASE * config() const
Returns the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
virtual void handleIconizeEvent(wxIconizeEvent &aEvent)
Handle a window iconize event.
virtual void PushCommandToUndoList(PICKED_ITEMS_LIST *aItem)
Add a command to undo in the undo list.
void windowClosing(wxCloseEvent &event)
(with its unexpected name so it does not collide with the real OnWindowClose() function provided in d...
virtual void OnCharHook(wxKeyEvent &aKeyEvent)
Capture the key event before it is sent to the GUI.
virtual int GetRedoCommandCount() const
UNDO_REDO_CONTAINER m_undoList
virtual void OnMove(wxMoveEvent &aEvent)
virtual WINDOW_SETTINGS * GetWindowSettings(APP_SETTINGS_BASE *aCfg)
Return a pointer to the window settings for this frame.
virtual void doCloseWindow()
void OnMenuEvent(wxMenuEvent &event)
The TOOL_DISPATCHER needs these to work around some issues in wxWidgets where the menu events aren't ...
virtual bool IsModal() const
Return true if the frame is shown in our modal mode and false if the frame is shown as an usual frame...
void ShowChangedLanguage() override
Redraw the menus and what not in current language.
virtual void HandleSystemColorChange()
Update the UI in response to a change in the system colors.
virtual void setupUIConditions()
Setup the UI conditions for the various actions and their controls in this frame.
void ensureWindowIsOnScreen()
void LoadWindowSettings(const WINDOW_SETTINGS *aCfg)
Load window settings from the given settings object.
std::vector< wxFileName > m_AcceptedFiles
virtual void CheckForAutoSaveFile(const wxFileName &aFileName)
Check if an auto save file exists for aFileName and takes the appropriate action depending on the use...
void OnKicadAbout(wxCommandEvent &event)
virtual void ClearUndoRedoList()
Clear the undo and redo list using ClearUndoORRedoList()
virtual void DoWithAcceptedFiles()
Execute action on accepted dropped file.
virtual void OnModify()
Must be called after a model change in order to set the "modify" flag and do other frame-specific pro...
wxWindow * findQuasiModalDialog()
static void HandleUpdateUIEvent(wxUpdateUIEvent &aEvent, EDA_BASE_FRAME *aFrame, ACTION_CONDITIONS aCond)
Handle events generated when the UI is trying to figure out the current state of the UI controls rela...
wxString m_perspective
virtual void ClearUndoORRedoList(UNDO_REDO_LIST aList, int aItemCount=-1)
Remove the aItemCount of old commands from aList and delete commands, pickers and picked items if nee...
virtual void ThemeChanged()
Process light/dark theme change.
wxSize m_normalFrameSize
EDA_BASE_FRAME(wxWindow *aParent, FRAME_T aFrameType, const wxString &aTitle, const wxPoint &aPos, const wxSize &aSize, long aStyle, const wxString &aFrameName, KIWAY *aKiway, const EDA_IU_SCALE &aIuScale)
void ShowPreferences(wxString aStartPage, wxString aStartParentPage)
Displays the preferences and settings of all opened editors paged dialog, starting with a particular ...
void initExitKey()
Sets the common key-pair for exiting the application (Ctrl-Q) and ties it to the wxID_EXIT event id.
void OnPreferences(wxCommandEvent &event)
virtual const SEARCH_STACK & sys_search()
Return a SEARCH_STACK pertaining to entire program.
WX_INFOBAR * m_infoBar
void onAutoSaveTimer(wxTimerEvent &aEvent)
Handle the auto save timer event.
void SaveWindowSettings(WINDOW_SETTINGS *aCfg)
Save window settings to the given settings object.
virtual wxString GetRedoActionDescription() const
void FinishAUIInitialization()
virtual wxString GetCurrentFileName() const
Get the full filename + path of the currently opened file in the frame.
void ChangeUserUnits(EDA_UNITS aUnits)
void AddMenuLanguageList(ACTION_MENU *aMasterMenu, TOOL_INTERACTIVE *aControlTool)
Function AddMenuLanguageList creates a menu list for language choice, and add it as submenu to Master...
void SetMenuBar(wxMenuBar *menu_bar) override
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...
wxTimer * m_autoSaveTimer
void UpdateFileHistory(const wxString &FullFileName, FILE_HISTORY *aFileHistory=nullptr)
Update the list of recently opened files.
wxAuiManager m_auimgr
void PrintMsg(const wxString &text)
void commonInit(FRAME_T aFrameType)
Collect common initialization functions used in all CTORs.
virtual bool IsContentModified() const
Get if the contents of the frame have been modified since the last save.
void ShowInfoBarWarning(const wxString &aWarningMsg, bool aShowCloseButton=false)
Show the WX_INFOBAR displayed on the top of the canvas with a message and a warning icon on the left ...
virtual PICKED_ITEMS_LIST * PopCommandFromRedoList()
Return the last command to undo and remove it from list, nothing is deleted.
void ClearFileHistory(FILE_HISTORY *aFileHistory=nullptr)
Removes all files from the file history.
std::map< int, UIUpdateHandler > m_uiUpdateMap
< Map containing the UI update handlers registered with wx for each action.
UNDO_REDO_CONTAINER m_redoList
virtual void LoadSettings(APP_SETTINGS_BASE *aCfg)
Load common frame parameters from a configuration file.
void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged) override
Notification event that some of the common (suite-wide) settings have changed.
FILE_HISTORY * m_fileHistory
virtual void DeleteAutoSaveFile(const wxFileName &aFileName)
virtual void OnSize(wxSizeEvent &aEvent)
virtual wxString GetUndoActionDescription() const
virtual PICKED_ITEMS_LIST * PopCommandFromUndoList()
Return the last command to undo and remove it from list, nothing is deleted.
virtual bool canCloseWindow(wxCloseEvent &aCloseEvent)
bool ProcessEvent(wxEvent &aEvent) override
Override the default process event handler to implement the auto save feature.
bool IsWritable(const wxFileName &aFileName, bool aVerbose=true)
Checks if aFileName can be written.
wxPoint m_normalFramePos
void OnMaximize(wxMaximizeEvent &aEvent)
virtual void OnDropFiles(wxDropFilesEvent &aEvent)
Handles event fired when a file is dropped to the window.
std::map< const wxString, TOOL_ACTION * > m_acceptedExts
Associates files extensions with action to execute.
void onIconize(wxIconizeEvent &aEvent)
virtual void unitsChangeRefresh()
Called when when the units setting has changed to allow for any derived classes to handle refreshing ...
wxString GetFileFromHistory(int cmdId, const wxString &type, FILE_HISTORY *aFileHistory=nullptr)
Fetches the file name from the file history list.
wxSize GetWindowSize()
Get the undecorated window size that can be used for restoring the window size.
int GetAutoSaveInterval() const
virtual void SaveSettings(APP_SETTINGS_BASE *aCfg)
Save common frame parameters to a configuration data file.
void onSystemColorChange(wxSysColourChangedEvent &aEvent)
virtual int GetUndoCommandCount() const
virtual void RegisterUIUpdateHandler(int aID, const ACTION_CONDITIONS &aConditions) override
Register a UI update handler for the control with ID aID.
virtual void PushCommandToRedoList(PICKED_ITEMS_LIST *aItem)
Add a command to redo in the redo list.
void ShowInfoBarError(const wxString &aErrorMsg, bool aShowCloseButton=false, WX_INFOBAR::MESSAGE_TYPE aType=WX_INFOBAR::MESSAGE_TYPE::GENERIC)
Show the WX_INFOBAR displayed on the top of the canvas with a message and an error icon on the left o...
bool m_isClosing
Set by NonUserClose() to indicate that the user did not request the current close.
void AddStandardHelpMenu(wxMenuBar *aMenuBar)
Adds the standard KiCad help menu to the menubar.
wxString m_mruPath
void ReCreateMenuBar()
Recreates the menu bar.
virtual void doReCreateMenuBar()
WX_INFOBAR * GetInfoBar()
Specialization of the wxAuiPaneInfo class for KiCad panels.
This class implements a file history object to store a list of files, that can then be added to a men...
Definition: file_history.h:43
void AddFileToHistory(const wxString &aFile) override
Adds a file to the history.
void ClearFileHistory()
Clear all entries from the file history.
void Save(APP_SETTINGS_BASE &aSettings)
Saves history into a JSON settings object.
void SetMaxFiles(size_t aMaxFiles)
Update the number of files that will be contained inside the file history.
void Load(const APP_SETTINGS_BASE &aSettings)
Loads history from a JSON settings object.
SEARCH_STACK & KifaceSearch()
Only for DSO specific 'non-library' files.
Definition: kiface_base.h:116
APP_SETTINGS_BASE * KifaceSettings() const
Definition: kiface_base.h:95
void GetActions(std::vector< TOOL_ACTION * > &aActions) const override
Append this Kiface's registered actions to the given list.
Definition: kiface_base.h:118
const wxString & GetHelpFileName() const
Return just the basename portion of the current help file.
Definition: kiface_base.h:112
A mix in class which holds the location of a wxWindow's KIWAY.
Definition: kiway_holder.h:39
PROJECT & Prj() const
Return a reference to the PROJECT associated with this KIWAY.
KIWAY & Kiway() const
Return a reference to the KIWAY that this object has an opportunity to participate in.
Definition: kiway_holder.h:55
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition: kiway.h:279
virtual void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged)
Call CommonSettingsChanged() on all KIWAY_PLAYERs.
Definition: kiway.cpp:617
virtual KIFACE * KiFACE(FACE_T aFaceId, bool doLoad=true)
Return the KIFACE* given a FACE_T.
Definition: kiway.cpp:202
@ FACE_SCH
eeschema DSO
Definition: kiway.h:286
@ FACE_PL_EDITOR
Definition: kiway.h:290
@ FACE_PCB
pcbnew DSO
Definition: kiway.h:287
@ FACE_GERBVIEW
Definition: kiway.h:289
virtual void GetActions(std::vector< TOOL_ACTION * > &aActions) const
Append all registered actions to the given list.
Definition: kiway.cpp:536
WX_TREEBOOK * GetTreebook()
Definition: paged_dialog.h:39
void SetInitialPage(const wxString &aPage, const wxString &aParentPage=wxEmptyString)
std::vector< TOOL_ACTION * > & ActionsList()
static wxString GetDefaultUserProjectsPath()
Gets the default path we point users to create projects.
Definition: paths.cpp:129
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition: pgm_base.cpp:678
virtual int GetSelectedLanguageIdentifier() const
Definition: pgm_base.h:238
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:142
A holder to handle information on schematic or board items.
void SaveFileState(const wxString &aFileName, const WINDOW_SETTINGS *aWindowCfg, bool aOpen)
const PROJECT_FILE_STATE * GetFileState(const wxString &aFileName)
virtual PROJECT_LOCAL_SETTINGS & GetLocalSettings() const
Definition: project.h:172
Look for files in a number of paths.
Definition: search_stack.h:43
virtual wxWindow * GetToolCanvas() const =0
Canvas access.
TOOL_MANAGER * m_toolManager
Definition: tools_holder.h:167
virtual void ShowChangedLanguage()
TOOL_DISPATCHER * m_toolDispatcher
Definition: tools_holder.h:169
virtual SELECTION & GetCurrentSelection()
Get the current selection from the canvas area.
Definition: tools_holder.h:98
virtual void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged)
Notification event that some of the common (suite-wide) settings have changed.
int GetUIId() const
Definition: tool_action.h:339
@ REDRAW
Full drawing refresh.
Definition: tool_base.h:83
virtual void DispatchWxEvent(wxEvent &aEvent)
Process wxEvents (mostly UI events), translate them to TOOL_EVENTs, and make tools handle those.
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
void ResetTools(TOOL_BASE::RESET_REASON aReason)
Reset all tools (i.e.
void PushCommand(PICKED_ITEMS_LIST *aCommand)
PICKED_ITEMS_LIST * PopCommand()
std::vector< PICKED_ITEMS_LIST * > m_CommandsList
void SetUserUnits(EDA_UNITS aUnits)
Simple wrapper around wxBusyCursor for used with the generic BUSY_INDICATOR interface.
A modified version of the wxInfoBar class that allows us to:
Definition: wx_infobar.h:75
void RemoveAllButtons()
Remove all the buttons that have been added by the user.
Definition: wx_infobar.cpp:301
void ShowMessageFor(const wxString &aMessage, int aTime, int aFlags=wxICON_INFORMATION, MESSAGE_TYPE aType=WX_INFOBAR::MESSAGE_TYPE::GENERIC)
Show the infobar with the provided message and icon for a specific period of time.
Definition: wx_infobar.cpp:140
MESSAGE_TYPE
Sets the type of message for special handling if needed.
Definition: wx_infobar.h:93
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
Definition: wx_infobar.cpp:187
void AddCloseButton(const wxString &aTooltip=_("Hide this message."))
Add the default close button to the infobar on the right side.
Definition: wx_infobar.cpp:291
void SetCallback(std::function< void(void)> aCallback)
Provide a callback to be called when the infobar is dismissed (either by user action or timer).
Definition: wx_infobar.h:157
bool AddLazyPage(std::function< wxWindow *(wxWindow *aParent)> aLazyCtor, const wxString &text, bool bSelect=false, int imageId=NO_IMAGE)
Definition: wx_treebook.cpp:89
bool AddLazySubPage(std::function< wxWindow *(wxWindow *aParent)> aLazyCtor, const wxString &text, bool bSelect=false, int imageId=NO_IMAGE)
Definition: wx_treebook.cpp:96
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:195
This file is part of the common library.
const int minSize
Push and Shove router track width and via size dialog.
#define _(s)
static const wxSize minSizeLookup(FRAME_T aFrameType, wxWindow *aWindow)
#define LAZY_CTOR(key)
static const wxSize defaultSize(FRAME_T aFrameType, wxWindow *aWindow)
wxWindow * findQuasiModalDialog(wxWindow *aParent)
Base window classes and related definitions.
#define DEFAULT_MAX_UNDO_ITEMS
std::function< void(wxUpdateUIEvent &) > UIUpdateHandler
This is the handler functor for the update UI events.
void SocketCleanup()
Definition: eda_dde.cpp:319
DDE server & client.
EDA_UNITS
Definition: eda_units.h:46
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:33
@ PANEL_PCB_GRIDS
Definition: frame_type.h:93
@ FRAME_PCB_EDITOR
Definition: frame_type.h:42
@ PANEL_SYM_EDIT_GRIDS
Definition: frame_type.h:73
@ FRAME_SCH_SYMBOL_EDITOR
Definition: frame_type.h:35
@ PANEL_SCH_FIELD_NAME_TEMPLATES
Definition: frame_type.h:82
@ PANEL_GBR_DISPLAY_OPTIONS
Definition: frame_type.h:103
@ PANEL_3DV_OPENGL
Definition: frame_type.h:100
@ PANEL_PCB_ORIGINS_AXES
Definition: frame_type.h:97
@ PANEL_PCB_EDIT_OPTIONS
Definition: frame_type.h:94
@ PANEL_SCH_DISP_OPTIONS
Definition: frame_type.h:77
@ PANEL_FP_DISPLAY_OPTIONS
Definition: frame_type.h:85
@ PANEL_SCH_SIMULATOR
Definition: frame_type.h:83
@ FRAME_SCH
Definition: frame_type.h:34
@ PANEL_DS_COLORS
Definition: frame_type.h:111
@ PANEL_PCB_COLORS
Definition: frame_type.h:95
@ PANEL_3DV_RAYTRACING
Definition: frame_type.h:101
@ PANEL_SYM_EDIT_OPTIONS
Definition: frame_type.h:74
@ PANEL_FP_GRIDS
Definition: frame_type.h:86
@ PANEL_SCH_EDIT_OPTIONS
Definition: frame_type.h:79
@ PANEL_FP_ORIGINS_AXES
Definition: frame_type.h:90
@ PANEL_SYM_DISP_OPTIONS
Definition: frame_type.h:72
@ PANEL_PCB_DISPLAY_OPTS
Definition: frame_type.h:92
@ PANEL_FP_COLORS
Definition: frame_type.h:88
@ PANEL_SYM_COLORS
Definition: frame_type.h:75
@ FRAME_PL_EDITOR
Definition: frame_type.h:59
@ PANEL_GBR_GRIDS
Definition: frame_type.h:106
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
@ FRAME_GERBER
Definition: frame_type.h:57
@ PANEL_DS_GRIDS
Definition: frame_type.h:110
@ FRAME_PCB_DISPLAY3D
Definition: frame_type.h:47
@ PANEL_FP_EDIT_OPTIONS
Definition: frame_type.h:87
@ PANEL_SCH_ANNO_OPTIONS
Definition: frame_type.h:80
@ PANEL_SCH_GRIDS
Definition: frame_type.h:78
@ PANEL_PCB_ACTION_PLUGINS
Definition: frame_type.h:96
@ PANEL_FP_DEFAULT_VALUES
Definition: frame_type.h:89
@ PANEL_3DV_DISPLAY_OPTIONS
Definition: frame_type.h:99
@ PANEL_DS_DISPLAY_OPTIONS
Definition: frame_type.h:109
@ PANEL_SCH_COLORS
Definition: frame_type.h:81
@ PANEL_GBR_COLORS
Definition: frame_type.h:107
@ PANEL_GBR_EXCELLON_OPTIONS
Definition: frame_type.h:105
@ KICAD_MAIN_FRAME_T
Definition: frame_type.h:68
bool m_EnableGit
Enable git integration.
static const std::string GerberFileExtension
static const std::string AutoSaveFilePrefix
static bool IsGerberFileExtension(const wxString &ext)
const wxChar *const traceAutoSave
Flag to enable auto save feature debug tracing.
const wxChar *const kicadTraceKeyEvent
Flag to enable wxKeyEvent debug tracing.
const wxChar *const traceDisplayLocation
Flag to enable debug output of display positioning logic.
void ReadHotKeyConfigIntoActions(const wxString &aFileName, std::vector< TOOL_ACTION * > &aActions)
Reads a hotkey config file into a list of actions.
@ ID_FILE_LIST_CLEAR
Definition: id.h:87
@ ID_FILE1
Definition: id.h:84
@ ID_AUTO_SAVE_TIMER
Definition: id.h:79
void RemoveShutdownBlockReason(wxWindow *aWindow)
Removes any shutdown block reason set.
Definition: gtk/app.cpp:85
bool DuplicatePermissions(const wxString &aSrc, const wxString &aDest)
Duplicates the file security data from one file to another ensuring that they are the same between bo...
Definition: gtk/io.cpp:40
PGM_BASE & Pgm()
The global Program "get" accessor.
Definition: pgm_base.cpp:1059
LANGUAGE_DESCR LanguagesList[]
An array containing all the languages that KiCad supports.
Definition: pgm_base.cpp:95
see class PGM_BASE
Functors that can be used to figure out how the action controls should be displayed in the UI and if ...
SELECTION_CONDITION enableCondition
Returns true if the UI control should be enabled.
SELECTION_CONDITION checkCondition
Returns true if the UI control should be checked.
SELECTION_CONDITION showCondition
Returns true if the UI control should be shown.
ACTION_CONDITIONS & Check(const SELECTION_CONDITION &aCondition)
Implement a participant in the KIWAY alchemy.
Definition: kiway.h:151
int m_KI_Lang_Identifier
KiCad identifier used in menu selection (See id.h)
Definition: pgm_base.h:73
wxString m_Lang_Label
Labels used in menus.
Definition: pgm_base.h:76
struct WINDOW_STATE window
Stores the common settings that are saved and loaded for each window / frame.
Definition: app_settings.h:74
WINDOW_STATE state
Definition: app_settings.h:75
wxString mru_path
Definition: app_settings.h:76
wxString perspective
Definition: app_settings.h:77
Stores the window positioning/state.
Definition: app_settings.h:61
unsigned int display
Definition: app_settings.h:67
IFACE KIFACE_BASE kiface("pcb_test_frame", KIWAY::FACE_PCB)
wxString dump(const wxArrayString &aArray)
Debug helper for printing wxArrayString contents.
wxLogTrace helper definitions.