KiCad PCB EDA Suite
dialog_shim.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) 2012 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
5 * Copyright (C) 2012-2022 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <dialog_shim.h>
26#include <ignore.h>
27#include <kiway_player.h>
28#include <kiway.h>
29#include <pgm_base.h>
30#include <tool/tool_manager.h>
31#include <kiplatform/ui.h>
32
33#include <wx/display.h>
34#include <wx/evtloop.h>
35#include <wx/app.h>
36#include <wx/event.h>
37#include <wx/grid.h>
38#include <wx/bmpbuttn.h>
39#include <wx/textctrl.h>
40#include <wx/stc/stc.h>
41
42#include <algorithm>
43
46{
47 wxWindow* m_win;
48
49public:
50
51 WDO_ENABLE_DISABLE( wxWindow* aWindow ) :
52 m_win( aWindow )
53 {
54 if( m_win )
55 m_win->Disable();
56 }
57
59 {
60 if( m_win )
61 {
62 m_win->Enable();
63 m_win->Raise(); // let's focus back on the parent window
64 }
65 }
66};
67
68
69BEGIN_EVENT_TABLE( DIALOG_SHIM, wxDialog )
70 // If dialog has a grid and the grid has an active cell editor
71 // Esc key closes cell editor, otherwise Esc key closes the dialog.
72 EVT_GRID_EDITOR_SHOWN( DIALOG_SHIM::OnGridEditorShown )
73 EVT_GRID_EDITOR_HIDDEN( DIALOG_SHIM::OnGridEditorHidden )
74 EVT_CHAR_HOOK( DIALOG_SHIM::OnCharHook )
75END_EVENT_TABLE()
76
77
78DIALOG_SHIM::DIALOG_SHIM( wxWindow* aParent, wxWindowID id, const wxString& title,
79 const wxPoint& pos, const wxSize& size, long style,
80 const wxString& name ) :
81 wxDialog( aParent, id, title, pos, size, style, name ),
82 KIWAY_HOLDER( nullptr, KIWAY_HOLDER::DIALOG ),
83 m_units( EDA_UNITS::MILLIMETRES ),
84 m_useCalculatedSize( false ),
85 m_firstPaintEvent( true ),
86 m_initialFocusTarget( nullptr ),
87 m_qmodal_loop( nullptr ),
88 m_qmodal_showing( false ),
89 m_qmodal_parent_disabler( nullptr ),
90 m_parentFrame( nullptr )
91{
92 KIWAY_HOLDER* kiwayHolder = nullptr;
93 m_initialSize = size;
94
95 if( aParent )
96 {
97 kiwayHolder = dynamic_cast<KIWAY_HOLDER*>( aParent );
98
99 while( !kiwayHolder && aParent->GetParent() )
100 {
101 aParent = aParent->GetParent();
102 kiwayHolder = dynamic_cast<KIWAY_HOLDER*>( aParent );
103 }
104 }
105
106 // Inherit units from parent
107 if( kiwayHolder && kiwayHolder->GetType() == KIWAY_HOLDER::FRAME )
108 m_units = static_cast<EDA_BASE_FRAME*>( kiwayHolder )->GetUserUnits();
109 else if( kiwayHolder && kiwayHolder->GetType() == KIWAY_HOLDER::DIALOG )
110 m_units = static_cast<DIALOG_SHIM*>( kiwayHolder )->GetUserUnits();
111
112 // Don't mouse-warp after a dialog run from the context menu
113 if( kiwayHolder && kiwayHolder->GetType() == KIWAY_HOLDER::FRAME )
114 {
115 m_parentFrame = static_cast<EDA_BASE_FRAME*>( kiwayHolder );
116 TOOL_MANAGER* toolMgr = m_parentFrame->GetToolManager();
117
118 if( toolMgr && toolMgr->IsContextMenuActive() )
119 toolMgr->VetoContextMenuMouseWarp();
120 }
121
122 // Set up the message bus
123 if( kiwayHolder )
124 SetKiway( this, &kiwayHolder->Kiway() );
125
126 if( HasKiway() )
127 Kiway().SetBlockingDialog( this );
128
129 Bind( wxEVT_CLOSE_WINDOW, &DIALOG_SHIM::OnCloseWindow, this );
130 Bind( wxEVT_BUTTON, &DIALOG_SHIM::OnButton, this );
131
132#ifdef __WINDOWS__
133 // On Windows, the app top windows can be brought to the foreground (at least temporarily)
134 // in certain circumstances such as when calling an external tool in Eeschema BOM generation.
135 // So set the parent frame (if exists) to top window to avoid this annoying behavior.
136 if( kiwayHolder && kiwayHolder->GetType() == KIWAY_HOLDER::FRAME )
137 Pgm().App().SetTopWindow( (EDA_BASE_FRAME*) kiwayHolder );
138#endif
139
140 Connect( wxEVT_PAINT, wxPaintEventHandler( DIALOG_SHIM::OnPaint ) );
141}
142
143
145{
146 // if the dialog is quasi-modal, this will end its event loop
147 if( IsQuasiModal() )
148 EndQuasiModal( wxID_CANCEL );
149
150 if( HasKiway() )
151 Kiway().SetBlockingDialog( nullptr );
152
154 delete m_qmodal_parent_disabler; // usually NULL by now
155}
156
157
159{
160 // must be called from the constructor of derived classes,
161 // when all widgets are initialized, and therefore their size fixed
162
163 // SetSizeHints fixes the minimal size of sizers in the dialog
164 // (SetSizeHints calls Fit(), so no need to call it)
165 GetSizer()->SetSizeHints( this );
166}
167
168
169void DIALOG_SHIM::setSizeInDU( int x, int y )
170{
171 wxSize sz( x, y );
172 SetSize( ConvertDialogToPixels( sz ) );
173}
174
175
177{
178 wxSize sz( x, 0 );
179 return ConvertDialogToPixels( sz ).x;
180}
181
182
184{
185 wxSize sz( 0, y );
186 return ConvertDialogToPixels( sz ).y;
187}
188
189
190// our hashtable is an implementation secret, don't need or want it in a header file
191#include <hashtables.h>
192#include <typeinfo>
193
194static std::unordered_map<std::string, wxRect> class_map;
195
196
197void DIALOG_SHIM::SetPosition( const wxPoint& aNewPosition )
198{
199 wxDialog::SetPosition( aNewPosition );
200
201 // Now update the stored position:
202 const char* hash_key;
203
204 if( m_hash_key.size() )
205 {
206 // a special case like EDA_LIST_DIALOG, which has multiple uses.
207 hash_key = m_hash_key.c_str();
208 }
209 else
210 {
211 hash_key = typeid(*this).name();
212 }
213
214 std::unordered_map<std::string, wxRect>::iterator it = class_map.find( hash_key );
215
216 if( it == class_map.end() )
217 return;
218
219 wxRect rect = it->second;
220 rect.SetPosition( aNewPosition );
221
222 class_map[ hash_key ] = rect;
223}
224
225
226bool DIALOG_SHIM::Show( bool show )
227{
228 bool ret;
229 const char* hash_key;
230
231 if( m_hash_key.size() )
232 {
233 // a special case like EDA_LIST_DIALOG, which has multiple uses.
234 hash_key = m_hash_key.c_str();
235 }
236 else
237 {
238 hash_key = typeid(*this).name();
239 }
240
241 // Show or hide the window. If hiding, save current position and size.
242 // If showing, use previous position and size.
243 if( show )
244 {
245#ifndef __WINDOWS__
246 wxDialog::Raise(); // Needed on OS X and some other window managers (i.e. Unity)
247#endif
248 ret = wxDialog::Show( show );
249
250 // classname is key, returns a zeroed-out default wxRect if none existed before.
251 wxRect savedDialogRect = class_map[ hash_key ];
252
253 if( savedDialogRect.GetSize().x != 0 && savedDialogRect.GetSize().y != 0 )
254 {
256 {
257 SetSize( savedDialogRect.GetPosition().x, savedDialogRect.GetPosition().y,
258 wxDialog::GetSize().x, wxDialog::GetSize().y, 0 );
259 }
260 else
261 {
262 SetSize( savedDialogRect.GetPosition().x, savedDialogRect.GetPosition().y,
263 std::max( wxDialog::GetSize().x, savedDialogRect.GetSize().x ),
264 std::max( wxDialog::GetSize().y, savedDialogRect.GetSize().y ),
265 0 );
266 }
267 }
268 else if( m_initialSize != wxDefaultSize )
269 SetSize( m_initialSize );
270
271 // Be sure that the dialog appears in a visible area
272 // (the dialog position might have been stored at the time when it was
273 // shown on another display)
274 if( wxDisplay::GetFromWindow( this ) == wxNOT_FOUND )
275 Centre();
276 }
277 else
278 {
279 // Save the dialog's position & size before hiding, using classname as key
280 class_map[ hash_key ] = wxRect( wxDialog::GetPosition(), wxDialog::GetSize() );
281
282#ifdef __WXMAC__
283 if ( m_eventLoop )
284 m_eventLoop->Exit( GetReturnCode() ); // Needed for APP-MODAL dlgs on OSX
285#endif
286
287 ret = wxDialog::Show( show );
288 }
289
290 return ret;
291}
292
293
295{
296 const char* hash_key;
297
298 if( m_hash_key.size() )
299 {
300 // a special case like EDA_LIST_DIALOG, which has multiple uses.
301 hash_key = m_hash_key.c_str();
302 }
303 else
304 {
305 hash_key = typeid(*this).name();
306 }
307
308 std::unordered_map<std::string, wxRect>::iterator it = class_map.find( hash_key );
309
310 if( it == class_map.end() )
311 return;
312
313 wxRect rect = it->second;
314 rect.SetSize( wxSize( 0, 0 ) );
315 class_map[ hash_key ] = rect;
316}
317
318
319bool DIALOG_SHIM::Enable( bool enable )
320{
321 // so we can do logging of this state change:
322 return wxDialog::Enable( enable );
323}
324
325
326// Recursive descent doing a SelectAll() in wxTextCtrls.
327// MacOS User Interface Guidelines state that when tabbing to a text control all its
328// text should be selected. Since wxWidgets fails to implement this, we do it here.
329static void selectAllInTextCtrls( wxWindowList& children )
330{
331 for( wxWindow* child : children )
332 {
333 if( wxTextCtrl* childTextCtrl = dynamic_cast<wxTextCtrl*>( child ) )
334 {
335 // We don't currently run this on GTK because some window managers don't hide the
336 // selection in non-active controls, and other window managers do the selection
337 // automatically anyway.
338#if defined( __WXMAC__ ) || defined( __WXMSW__ )
339 if( !childTextCtrl->GetStringSelection().IsEmpty() )
340 {
341 // Respect an existing selection
342 }
343 else
344 {
345 childTextCtrl->SelectAll();
346 }
347#else
348 ignore_unused( childTextCtrl );
349#endif
350 }
351 else if( wxStyledTextCtrl* scintilla = dynamic_cast<wxStyledTextCtrl*>( child ) )
352 {
353 if( !scintilla->GetSelectedText().IsEmpty() )
354 {
355 // Respect an existing selection
356 }
357 else
358 {
359 scintilla->SelectAll();
360 }
361 }
362#ifdef __WXMAC__
363 // Temp hack for square (looking) buttons on OSX. Will likely be made redundant
364 // by the image store....
365 else if( dynamic_cast<wxBitmapButton*>( child ) != nullptr )
366 {
367 wxSize minSize( 29, 27 );
368 wxRect rect = child->GetRect();
369
370 child->ConvertDialogToPixels( minSize );
371
372 rect.Inflate( std::max( 0, minSize.x - rect.GetWidth() ),
373 std::max( 0, minSize.y - rect.GetHeight() ) );
374
375 child->SetMinSize( rect.GetSize() );
376 child->SetSize( rect );
377 }
378#endif
379 else
380 {
381 selectAllInTextCtrls( child->GetChildren() );
382 }
383 }
384}
385
386
387void DIALOG_SHIM::OnPaint( wxPaintEvent &event )
388{
390 {
392
393 selectAllInTextCtrls( GetChildren() );
394
397 else
398 KIPLATFORM::UI::ForceFocus( this ); // Focus the dialog itself
399
400 m_firstPaintEvent = false;
401 }
402
403 event.Skip();
404}
405
406
408{
409 if( !GetTitle().StartsWith( "*" ) )
410 SetTitle( "*" + GetTitle() );
411}
412
413
414/*
415 Quasi-Modal Mode Explained:
416
417 The gtk calls in wxDialog::ShowModal() cause event routing problems if that
418 modal dialog then tries to use KIWAY_PLAYER::ShowModal(). The latter shows up
419 and mostly works but does not respond to the window decoration close button.
420 There is no way to get around this without reversing the gtk calls temporarily.
421
422 Quasi-Modal mode is our own almost modal mode which disables only the parent
423 of the DIALOG_SHIM, leaving other frames operable and while staying captured in the
424 nested event loop. This avoids the gtk calls and leaves event routing pure
425 and sufficient to operate the KIWAY_PLAYER::ShowModal() properly. When using
426 ShowQuasiModal() you have to use EndQuasiModal() in your dialogs and not
427 EndModal(). There is also IsQuasiModal() but its value can only be true
428 when the nested event loop is active. Do not mix the modal and quasi-modal
429 functions. Use one set or the other.
430
431 You might find this behavior preferable over a pure modal mode, and it was said
432 that only the Mac has this natively, but now other platforms have something
433 similar. You CAN use it anywhere for any dialog. But you MUST use it when
434 you want to use KIWAY_PLAYER::ShowModal() from a dialog event.
435*/
436
438{
439 // This is an exception safe way to zero a pointer before returning.
440 // Yes, even though DismissModal() clears this first normally, this is
441 // here in case there's an exception before the dialog is dismissed.
442 struct NULLER
443 {
444 void*& m_what;
445 NULLER( void*& aPtr ) : m_what( aPtr ) {}
446 ~NULLER() { m_what = nullptr; } // indeed, set it to NULL on destruction
447 } clear_this( (void*&) m_qmodal_loop );
448
449 // release the mouse if it's currently captured as the window having it
450 // will be disabled when this dialog is shown -- but will still keep the
451 // capture making it impossible to do anything in the modal dialog itself
452 wxWindow* win = wxWindow::GetCapture();
453 if( win )
454 win->ReleaseMouse();
455
456 // Get the optimal parent
457 wxWindow* parent = GetParentForModalDialog( GetParent(), GetWindowStyle() );
458
459 wxASSERT_MSG( !m_qmodal_parent_disabler, wxT( "Caller using ShowQuasiModal() twice on same "
460 "window?" ) );
461
462 // quasi-modal: disable only my "optimal" parent
464
465 // Apple in its infinite wisdom will raise a disabled window before even passing
466 // us the event, so we have no way to stop it. Instead, we must set an order on
467 // the windows so that the quasi-modal will be pushed in front of the disabled
468 // window when it is raised.
470
471 Show( true );
472
473 m_qmodal_showing = true;
474
475 WX_EVENT_LOOP event_loop;
476
477 m_qmodal_loop = &event_loop;
478
479 event_loop.Run();
480
481 m_qmodal_showing = false;
482
483 return GetReturnCode();
484}
485
486
487void DIALOG_SHIM::EndQuasiModal( int retCode )
488{
489 // Hook up validator and transfer data from controls handling so quasi-modal dialogs
490 // handle validation in the same way as other dialogs.
491 if( ( retCode == wxID_OK ) && ( !Validate() || !TransferDataFromWindow() ) )
492 return;
493
494 SetReturnCode( retCode );
495
496 if( !IsQuasiModal() )
497 {
498 wxFAIL_MSG( wxT( "Either DIALOG_SHIM::EndQuasiModal was called twice, or ShowQuasiModal"
499 "wasn't called" ) );
500 return;
501 }
502
503 if( m_qmodal_loop )
504 {
505 if( m_qmodal_loop->IsRunning() )
506 m_qmodal_loop->Exit( 0 );
507 else
508 m_qmodal_loop->ScheduleExit( 0 );
509
510 m_qmodal_loop = nullptr;
511 }
512
514 m_qmodal_parent_disabler = nullptr;
515
516 Show( false );
517}
518
519
520void DIALOG_SHIM::OnCloseWindow( wxCloseEvent& aEvent )
521{
522 if( IsQuasiModal() )
523 {
524 EndQuasiModal( wxID_CANCEL );
525 return;
526 }
527
528 // This is mandatory to allow wxDialogBase::OnCloseWindow() to be called.
529 aEvent.Skip();
530}
531
532
533void DIALOG_SHIM::OnButton( wxCommandEvent& aEvent )
534{
535 const int id = aEvent.GetId();
536
537 // If we are pressing a button to exit, we need to enable the escapeID
538 // otherwise the dialog does not process cancel
539 if( id == wxID_CANCEL )
540 SetEscapeId( wxID_ANY );
541
542 if( IsQuasiModal() )
543 {
544 if( id == GetAffirmativeId() )
545 {
546 EndQuasiModal( id );
547 }
548 else if( id == wxID_APPLY )
549 {
550 // Dialogs that provide Apply buttons should make sure data is valid before
551 // allowing a transfer, as there is no other way to indicate failure
552 // (i.e. the dialog can't refuse to close as it might with OK, because it
553 // isn't closing anyway)
554 if( Validate() )
555 {
556 ignore_unused( TransferDataFromWindow() );
557 }
558 }
559 else if( id == GetEscapeId() || (id == wxID_CANCEL && GetEscapeId() == wxID_ANY) )
560 {
561 EndQuasiModal( wxID_CANCEL );
562 }
563 else // not a standard button
564 {
565 aEvent.Skip();
566 }
567
568 return;
569 }
570
571 // This is mandatory to allow wxDialogBase::OnButton() to be called.
572 aEvent.Skip();
573}
574
575
576void DIALOG_SHIM::OnCharHook( wxKeyEvent& aEvt )
577{
578 if( aEvt.GetKeyCode() == 'U' && aEvt.GetModifiers() == wxMOD_CONTROL )
579 {
580 if( m_parentFrame )
581 {
583 return;
584 }
585 }
586 // shift-return (Mac default) or Ctrl-Return (GTK) for OK
587 else if( aEvt.GetKeyCode() == WXK_RETURN && ( aEvt.ShiftDown() || aEvt.ControlDown() ) )
588 {
589 wxPostEvent( this, wxCommandEvent( wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK ) );
590 return;
591 }
592 else if( aEvt.GetKeyCode() == WXK_TAB && !aEvt.ControlDown() )
593 {
594 wxWindow* currentWindow = wxWindow::FindFocus();
595 int currentIdx = -1;
596 int delta = aEvt.ShiftDown() ? -1 : 1;
597
598 auto advance =
599 [&]( int& idx )
600 {
601 // Wrap-around modulus
602 int size = m_tabOrder.size();
603 idx = ( ( idx + delta ) % size + size ) % size;
604 };
605
606 for( size_t i = 0; i < m_tabOrder.size(); ++i )
607 {
608 if( m_tabOrder[i] == currentWindow )
609 {
610 currentIdx = (int) i;
611 break;
612 }
613 }
614
615 if( currentIdx >= 0 )
616 {
617 advance( currentIdx );
618
619 //todo: We don't currently have non-textentry dialog boxes but this will break if
620 // we add them.
621#ifdef __APPLE__
622 while( dynamic_cast<wxTextEntry*>( m_tabOrder[ currentIdx ] ) == nullptr )
623 advance( currentIdx );
624#endif
625
626 m_tabOrder[ currentIdx ]->SetFocus();
627 return;
628 }
629 }
630
631 aEvt.Skip();
632}
633
634
635void DIALOG_SHIM::OnGridEditorShown( wxGridEvent& event )
636{
637 SetEscapeId( wxID_NONE );
638 event.Skip();
639}
640
641
642void DIALOG_SHIM::OnGridEditorHidden( wxGridEvent& event )
643{
644 SetEscapeId( wxID_ANY );
645 event.Skip();
646}
647
648
649static void recursiveDescent( wxSizer* aSizer, std::map<int, wxString>& aLabels )
650{
651 wxStdDialogButtonSizer* sdbSizer = dynamic_cast<wxStdDialogButtonSizer*>( aSizer );
652
653 auto setupButton =
654 [&]( wxButton* aButton )
655 {
656 if( aLabels.count( aButton->GetId() ) > 0 )
657 {
658 aButton->SetLabel( aLabels[ aButton->GetId() ] );
659 }
660 else
661 {
662 // wxWidgets has an uneven track record when the language is changed on
663 // the fly so we set them even when they don't appear in the label map
664 switch( aButton->GetId() )
665 {
666 case wxID_OK: aButton->SetLabel( _( "&OK" ) ); break;
667 case wxID_CANCEL: aButton->SetLabel( _( "&Cancel" ) ); break;
668 case wxID_YES: aButton->SetLabel( _( "&Yes" ) ); break;
669 case wxID_NO: aButton->SetLabel( _( "&No" ) ); break;
670 case wxID_APPLY: aButton->SetLabel( _( "&Apply" ) ); break;
671 case wxID_SAVE: aButton->SetLabel( _( "&Save" ) ); break;
672 case wxID_HELP: aButton->SetLabel( _( "&Help" ) ); break;
673 case wxID_CONTEXT_HELP: aButton->SetLabel( _( "&Help" ) ); break;
674 }
675 }
676 };
677
678 if( sdbSizer )
679 {
680 if( sdbSizer->GetAffirmativeButton() )
681 setupButton( sdbSizer->GetAffirmativeButton() );
682
683 if( sdbSizer->GetApplyButton() )
684 setupButton( sdbSizer->GetApplyButton() );
685
686 if( sdbSizer->GetNegativeButton() )
687 setupButton( sdbSizer->GetNegativeButton() );
688
689 if( sdbSizer->GetCancelButton() )
690 setupButton( sdbSizer->GetCancelButton() );
691
692 if( sdbSizer->GetHelpButton() )
693 setupButton( sdbSizer->GetHelpButton() );
694
695 sdbSizer->Layout();
696
697 if( sdbSizer->GetAffirmativeButton() )
698 sdbSizer->GetAffirmativeButton()->SetDefault();
699 }
700
701 for( wxSizerItem* item : aSizer->GetChildren() )
702 {
703 if( item->GetSizer() )
704 recursiveDescent( item->GetSizer(), aLabels );
705 }
706}
707
708
709void DIALOG_SHIM::SetupStandardButtons( std::map<int, wxString> aLabels )
710{
711 recursiveDescent( GetSizer(), aLabels );
712}
const char * name
Definition: DXF_plotter.cpp:56
Dialog helper object to sit in the inheritance tree between wxDialog and any class written by wxFormB...
Definition: dialog_shim.h:83
std::vector< wxWindow * > m_tabOrder
Definition: dialog_shim.h:222
void OnPaint(wxPaintEvent &event)
bool m_qmodal_showing
Definition: dialog_shim.h:217
int vertPixelsFromDU(int y) const
Convert an integer number of dialog units to pixels, vertically.
bool Show(bool show) override
void SetupStandardButtons(std::map< int, wxString > aLabels={})
int ShowQuasiModal()
std::string m_hash_key
Definition: dialog_shim.h:203
bool m_firstPaintEvent
Definition: dialog_shim.h:212
int horizPixelsFromDU(int x) const
Convert an integer number of dialog units to pixels, horizontally.
void resetSize()
Clear the existing dialog size and position.
void setSizeInDU(int x, int y)
Set the dialog to the given dimensions in "dialog units".
bool IsQuasiModal() const
Definition: dialog_shim.h:106
void OnGridEditorShown(wxGridEvent &event)
WDO_ENABLE_DISABLE * m_qmodal_parent_disabler
Definition: dialog_shim.h:218
bool m_useCalculatedSize
Definition: dialog_shim.h:207
void EndQuasiModal(int retCode)
void OnModify()
void OnButton(wxCommandEvent &aEvent)
Properly handle the default button events when in the quasimodal mode when not calling EndQuasiModal ...
void finishDialogSettings()
In all dialogs, we must call the same functions to fix minimal dlg size, the default position and per...
wxWindow * m_initialFocusTarget
Definition: dialog_shim.h:213
bool Enable(bool enable) override
void SetPosition(const wxPoint &aNewPosition)
Force the position of the dialog to a new position.
void OnCloseWindow(wxCloseEvent &aEvent)
Properly handle the wxCloseEvent when in the quasimodal mode when not calling EndQuasiModal which is ...
wxSize m_initialSize
Definition: dialog_shim.h:225
EDA_BASE_FRAME * m_parentFrame
Definition: dialog_shim.h:220
virtual void OnCharHook(wxKeyEvent &aEvt)
void OnGridEditorHidden(wxGridEvent &event)
EDA_UNITS GetUserUnits() const
Definition: dialog_shim.h:121
WX_EVENT_LOOP * m_qmodal_loop
Definition: dialog_shim.h:215
The base frame for deriving all KiCad main window classes.
virtual void ToggleUserUnits()
A mix in class which holds the location of a wxWindow's KIWAY.
Definition: kiway_holder.h:37
KIWAY & Kiway() const
Return a reference to the KIWAY that this object has an opportunity to participate in.
Definition: kiway_holder.h:53
bool HasKiway() const
Safety check before asking for the Kiway reference.
Definition: kiway_holder.h:63
HOLDER_TYPE GetType() const
Definition: kiway_holder.h:46
void SetBlockingDialog(wxWindow *aWin)
Definition: kiway.cpp:622
Master controller class:
Definition: tool_manager.h:55
bool IsContextMenuActive() const
True while processing a context menu.
Definition: tool_manager.h:413
void VetoContextMenuMouseWarp()
Disable mouse warping after the current context menu is closed.
Definition: tool_manager.h:424
EDA_UNITS GetUserUnits() const
Toggle a window's "enable" status to disabled, then enabled on destruction.
Definition: dialog_shim.cpp:46
WDO_ENABLE_DISABLE(wxWindow *aWindow)
Definition: dialog_shim.cpp:51
static void recursiveDescent(wxSizer *aSizer, std::map< int, wxString > &aLabels)
static std::unordered_map< std::string, wxRect > class_map
static void selectAllInTextCtrls(wxWindowList &children)
const int minSize
Push and Shove router track width and via size dialog.
#define _(s)
EDA_UNITS
Definition: eda_units.h:43
void ignore_unused(const T &)
Definition: ignore.h:24
KIWAY Kiway
#define WX_EVENT_LOOP
Definition: kiway_player.h:41
void FixupCancelButtonCmdKeyCollision(wxWindow *aWindow)
Definition: gtk/ui.cpp:71
void ReparentQuasiModal(wxNonOwnedWindow *aWindow)
Move a window's parent to be the top-level window and force the window to be on top.
Definition: gtk/ui.cpp:65
void ForceFocus(wxWindow *aWindow)
Pass the current focus to the window.
Definition: gtk/ui.cpp:44
void SetPosition(const wxString &aStr, const wxString &aDefaultMeasurementUnit, int *aX, int *aY, const wxString &aActualConversion)
see class PGM_BASE
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:111
constexpr int delta