KiCad PCB EDA Suite
KIWAY Class Reference

A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad process. More...

#include <kiway.h>

Inheritance diagram for KIWAY:

Public Types

enum  FACE_T {
  FACE_SCH, FACE_PCB, FACE_CVPCB, FACE_GERBVIEW,
  FACE_PL_EDITOR, FACE_PCB_CALCULATOR, FACE_BMP2CMP, FACE_PYTHON,
  KIWAY_FACE_COUNT
}
 Known KIFACE implementations. More...
 

Public Member Functions

 ~KIWAY () throw ()
 
virtual KIFACEKiFACE (FACE_T aFaceId, bool doLoad=true)
 Return the KIFACE* given a FACE_T. More...
 
virtual KIWAY_PLAYERPlayer (FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
 Return the KIWAY_PLAYER* given a FRAME_T. More...
 
virtual bool PlayerClose (FRAME_T aFrameType, bool doForce)
 Call the KIWAY_PLAYER::Close( bool force ) function on the window and if not vetoed, returns true, else false. More...
 
virtual bool PlayersClose (bool doForce)
 Call the KIWAY_PLAYER::Close( bool force ) function on all the windows and if none are vetoed, returns true, else false. More...
 
virtual void ExpressMail (FRAME_T aDestination, MAIL_T aCommand, std::string &aPayload, wxWindow *aSource=nullptr)
 Send aPayload to aDestination from aSource. More...
 
virtual PROJECTPrj () const
 Return the PROJECT associated with this KIWAY. More...
 
virtual void SetLanguage (int aLanguage)
 Change the language and then calls ShowChangedLanguage() on all #KIWAY_PLAYERs. More...
 
virtual void CommonSettingsChanged (bool aEnvVarsChanged, bool aTextVarsChanged)
 Call CommonSettingsChanged() on all KIWAY_PLAYERs. More...
 
virtual void ProjectChanged ()
 Calls ProjectChanged() on all KIWAY_PLAYERs. More...
 
 KIWAY (PGM_BASE *aProgram, int aCtlBits, wxFrame *aTop=nullptr)
 
void SetTop (wxFrame *aTop)
 Tell this KIWAY about the top most frame in the program and optionally allows it to play the role of one of the KIWAY_PLAYERs if launched from single_top.cpp. More...
 
wxFrame * GetTop ()
 
void OnKiCadExit ()
 
void OnKiwayEnd ()
 
bool ProcessEvent (wxEvent &aEvent) override
 

Static Public Member Functions

static FACE_T KifaceType (FRAME_T aFrameType)
 A simple mapping function which returns the FACE_T which is known to implement aFrameType. More...
 

Private Member Functions

const wxString dso_search_path (FACE_T aFaceId)
 Get the [path &] name of the DSO holding the requested FACE_T. More...
 
bool set_kiface (FACE_T aFaceType, KIFACE *aKiface)
 
KIWAY_PLAYERGetPlayerFrame (FRAME_T aFrameType)
 

Private Attributes

PGM_BASEm_program
 
int m_ctl
 
wxFrame * m_top
 
std::atomic< wxWindowID > m_playerFrameId [KIWAY_PLAYER_COUNT]
 

Static Private Attributes

static KIFACEm_kiface [KIWAY_FACE_COUNT]
 
static int m_kiface_version [KIWAY_FACE_COUNT]
 

Friends

struct PGM_SINGLE_TOP
 

Detailed Description

A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad process.

It makes it possible to call between DSOs without having to link them together, and without having to link to the top process module which houses the KIWAY(s). More importantly it makes it possible to send custom wxEvents between DSOs and from the top process module down into the DSOs. The latter capability is thought useful for driving the lower DSOs from a python test rig or for demo (automation) purposes.

Most all calls are via virtual functions, which means C++ vtables are used to hold function pointers and eliminate the need to link to specific object code libraries, speeding development and encouraging clearly defined interface design. Unlike Microsoft COM, which is a multi-vendor design supporting DLL's built at various points in time, the KIWAY alchemy is single project, with all components being built at the same time. So one should expect solid compatibility between all KiCad components, as long at they are compiled at the same time.

There is one KIWAY in the launching portion of the process for each open KiCad project. Each project has its own KIWAY. Available to each KIWAY is an actual PROJECT data structure. If you have a KIWAY, you can get to the PROJECT using KIWAY::Prj().

In summary, a KIWAY facilitates communicating between DSOs, where the topic of the communication is project specific. Here a "project" means a BOARD and a SCHEMATIC and a NETLIST, (anything relating to production of a single BOARD and added to class PROJECT.)

Definition at line 260 of file kiway.h.

Member Enumeration Documentation

◆ FACE_T

Known KIFACE implementations.

Enumerator
FACE_SCH 

eeschema DSO

FACE_PCB 

pcbnew DSO

FACE_CVPCB 
FACE_GERBVIEW 
FACE_PL_EDITOR 
FACE_PCB_CALCULATOR 
FACE_BMP2CMP 
FACE_PYTHON 
KIWAY_FACE_COUNT 

Definition at line 266 of file kiway.h.

Constructor & Destructor Documentation

◆ ~KIWAY()

KIWAY::~KIWAY ( )
throw (
)
inline

Definition at line 280 of file kiway.h.

280 {}

◆ KIWAY()

KIWAY::KIWAY ( PGM_BASE aProgram,
int  aCtlBits,
wxFrame *  aTop = nullptr 
)

Definition at line 52 of file kiway.cpp.

52  :
53  m_program( aProgram ), m_ctl( aCtlBits ), m_top( nullptr )
54 {
55  SetTop( aTop ); // hook player_destroy_handler() into aTop.
56 
57  // Set the array of all known frame window IDs to empty = wxID_NONE,
58  // once they are be created, they are added with FRAME_T as index to this array.
59  // Note: A non empty entry does not mean the frame still exists.
60  // It means only the frame was created at least once. It can be destroyed after.
61  // These entries are not cleared automatically on window closing. The purpose is just
62  // to allow a call to wxWindow::FindWindowById() using a FRAME_T frame type
63  for( int n = 0; n < KIWAY_PLAYER_COUNT; n++ )
64  m_playerFrameId[n] = wxID_NONE;
65 }
std::atomic< wxWindowID > m_playerFrameId[KIWAY_PLAYER_COUNT]
Definition: kiway.h:435
PGM_BASE * m_program
Definition: kiway.h:424
int m_ctl
Definition: kiway.h:425
void SetTop(wxFrame *aTop)
Tell this KIWAY about the top most frame in the program and optionally allows it to play the role of ...
Definition: kiway.cpp:83
wxFrame * m_top
Definition: kiway.h:427
int PGM_BASE * aProgram
Definition: cvpcb.cpp:110

References KIWAY_PLAYER_COUNT, m_playerFrameId, and SetTop().

Member Function Documentation

◆ CommonSettingsChanged()

void KIWAY::CommonSettingsChanged ( bool  aEnvVarsChanged,
bool  aTextVarsChanged 
)
virtual

Call CommonSettingsChanged() on all KIWAY_PLAYERs.

Use after changing suite-wide options such as panning, autosave interval, etc.

Definition at line 564 of file kiway.cpp.

565 {
567  {
568  // A dynamic_cast could be better, but creates link issues
569  // (some basic_frame functions not found) on some platforms,
570  // so a static_cast is used.
571  EDA_BASE_FRAME* top = static_cast<EDA_BASE_FRAME*>( m_top );
572 
573  if( top )
574  top->CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
575  }
576 
577  for( unsigned i=0; i < KIWAY_PLAYER_COUNT; ++i )
578  {
579  KIWAY_PLAYER* frame = GetPlayerFrame( ( FRAME_T )i );
580 
581  if( frame )
582  frame->CommonSettingsChanged( aEnvVarsChanged, aTextVarsChanged );
583  }
584 }
#define KFCTL_CPP_PROJECT_SUITE
Running under C++ project mgr, possibly with others.
Definition: kiway.h:157
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:64
KIWAY_PLAYER * GetPlayerFrame(FRAME_T aFrameType)
Definition: kiway.cpp:375
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:32
int m_ctl
Definition: kiway.h:425
void CommonSettingsChanged(bool aEnvVarsChanged, bool aTextVarsChanged) override
Notification event that some of the common (suite-wide) settings have changed.
The base frame for deriving all KiCad main window classes.
wxFrame * m_top
Definition: kiway.h:427

References EDA_BASE_FRAME::CommonSettingsChanged(), GetPlayerFrame(), KFCTL_CPP_PROJECT_SUITE, KIWAY_PLAYER_COUNT, m_ctl, and m_top.

Referenced by COMMON_CONTROL::ConfigurePaths(), PCB::IFACE::CreateWindow(), EDA_BASE_FRAME::OnPreferences(), PCB_EDIT_FRAME::ShowBoardSetupDialog(), and SCH_EDIT_FRAME::ShowSchematicSetupDialog().

◆ dso_search_path()

const wxString KIWAY::dso_search_path ( FACE_T  aFaceId)
private

Get the [path &] name of the DSO holding the requested FACE_T.

Definition at line 105 of file kiway.cpp.

106 {
107  const char* name;
108 
109  switch( aFaceId )
110  {
111  case FACE_SCH: name = KIFACE_PREFIX "eeschema"; break;
112  case FACE_PCB: name = KIFACE_PREFIX "pcbnew"; break;
113  case FACE_CVPCB: name = KIFACE_PREFIX "cvpcb"; break;
114  case FACE_GERBVIEW: name = KIFACE_PREFIX "gerbview"; break;
115  case FACE_PL_EDITOR: name = KIFACE_PREFIX "pl_editor"; break;
116  case FACE_PCB_CALCULATOR: name = KIFACE_PREFIX "pcb_calculator"; break;
117  case FACE_BMP2CMP: name = KIFACE_PREFIX "bitmap2component"; break;
118  case FACE_PYTHON: name = KIFACE_PREFIX "kipython"; break;
119 
120  default:
121  wxASSERT_MSG( 0, wxT( "caller has a bug, passed a bad aFaceId" ) );
122  return wxEmptyString;
123  }
124 
125 #ifndef __WXMAC__
126  wxString path;
127 
129  {
130  // The 2 *.cpp program launchers: single_top.cpp and kicad.cpp expect
131  // the *.kiface's to reside in same directory as their binaries do.
132  path = wxStandardPaths::Get().GetExecutablePath();
133  }
134 
135  wxFileName fn = path;
136 #else
137  // we have the dso's in main OSX bundle kicad.app/Contents/PlugIns
138  wxFileName fn = Pgm().GetExecutablePath();
139  fn.AppendDir( wxT( "Contents" ) );
140  fn.AppendDir( wxT( "PlugIns" ) );
141 #endif
142 
143  fn.SetName( name );
144 
145  // To speed up development, it's sometimes nice to run kicad from inside
146  // the build path. In that case, each program will be in a subdirectory.
147  // To find the DSOs, we need to go up one directory and then enter a subdirectory.
148 
149  if( wxGetEnv( wxT( "KICAD_RUN_FROM_BUILD_DIR" ), nullptr ) )
150  {
151 #ifdef __WXMAC__
152  // On Mac, all of the kifaces are placed in the kicad.app bundle, even though the individual
153  // standalone binaries are placed in separate bundles before the make install step runs.
154  // So, we have to jump up to the kicad directory, then the PlugIns section of the kicad
155  // bundle.
156  fn = wxStandardPaths::Get().GetExecutablePath();
157 
158  fn.RemoveLastDir();
159  fn.RemoveLastDir();
160  fn.RemoveLastDir();
161  fn.RemoveLastDir();
162  fn.AppendDir( wxT( "kicad" ) );
163  fn.AppendDir( wxT( "kicad.app" ) );
164  fn.AppendDir( wxT( "Contents" ) );
165  fn.AppendDir( wxT( "PlugIns" ) );
166  fn.SetName( name );
167 #else
168  const char* dirName;
169 
170  // The subdirectories usually have the same name as the kiface
171  switch( aFaceId )
172  {
173  case FACE_PL_EDITOR: dirName = "pagelayout_editor"; break;
174  case FACE_PYTHON: dirName = "scripting"; break;
175  default: dirName = name + 1; break;
176  }
177 
178  fn.RemoveLastDir();
179  fn.AppendDir( dirName );
180 #endif
181  }
182 
183  // Here a "suffix" == an extension with a preceding '.',
184  // so skip the preceding '.' to get an extension
185  fn.SetExt( &KIFACE_SUFFIX[1] );
186 
187  return fn.GetFullPath();
188 }
#define KFCTL_CPP_PROJECT_SUITE
Running under C++ project mgr, possibly with others.
Definition: kiway.h:157
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:106
int m_ctl
Definition: kiway.h:425
pcbnew DSO
Definition: kiway.h:269
eeschema DSO
Definition: kiway.h:268
const char * name
Definition: DXF_plotter.cpp:56
#define KFCTL_STANDALONE
Running as a standalone Top.
Definition: kiway.h:156

References FACE_BMP2CMP, FACE_CVPCB, FACE_GERBVIEW, FACE_PCB, FACE_PCB_CALCULATOR, FACE_PL_EDITOR, FACE_PYTHON, FACE_SCH, KFCTL_CPP_PROJECT_SUITE, KFCTL_STANDALONE, m_ctl, name, path, and Pgm().

Referenced by KiFACE().

◆ ExpressMail()

void KIWAY::ExpressMail ( FRAME_T  aDestination,
MAIL_T  aCommand,
std::string &  aPayload,
wxWindow *  aSource = nullptr 
)
virtual

◆ GetPlayerFrame()

KIWAY_PLAYER * KIWAY::GetPlayerFrame ( FRAME_T  aFrameType)
private
Returns
the reference of the KIWAY_PLAYER having the type aFrameType if exists, or NULL if this KIWAY_PLAYER was not yet created, or was closed

Definition at line 375 of file kiway.cpp.

376 {
377  wxWindowID storedId = m_playerFrameId[aFrameType];
378 
379  if( storedId == wxID_NONE )
380  return nullptr;
381 
382  wxWindow* frame = wxWindow::FindWindowById( storedId );
383 
384  // Since wxWindow::FindWindow*() is not cheap (especially if the window does not exist),
385  // clear invalid entries to save CPU on repeated calls that do not lead to frame creation
386  if( !frame )
387  m_playerFrameId[aFrameType].compare_exchange_strong( storedId, wxID_NONE );
388 
389  return static_cast<KIWAY_PLAYER*>( frame );
390 }
std::atomic< wxWindowID > m_playerFrameId[KIWAY_PLAYER_COUNT]
Definition: kiway.h:435

References m_playerFrameId.

Referenced by CommonSettingsChanged(), Player(), PlayerClose(), ProjectChanged(), and SetLanguage().

◆ GetTop()

wxFrame* KIWAY::GetTop ( )
inline

Definition at line 387 of file kiway.h.

387 { return m_top; }
wxFrame * m_top
Definition: kiway.h:427

References m_top.

◆ KiFACE()

KIFACE * KIWAY::KiFACE ( FACE_T  aFaceId,
bool  doLoad = true 
)
virtual

Return the KIFACE* given a FACE_T.

If it is not already loaded, the KIFACE is loaded and initialized with a call to KIFACE::OnKifaceStart().

Definition at line 197 of file kiway.cpp.

198 {
199  // Since this will be called from python, cannot assume that code will
200  // not pass a bad aFaceId.
201  if( (unsigned) aFaceId >= arrayDim( m_kiface ) )
202  {
203  // @todo : throw an exception here for python's benefit, at least that
204  // way it gets some explanatory text.
205 
206  wxASSERT_MSG( 0, wxT( "caller has a bug, passed a bad aFaceId" ) );
207  return nullptr;
208  }
209 
210  // return the previously loaded KIFACE, if it was.
211  if( m_kiface[aFaceId] )
212  return m_kiface[aFaceId];
213 
214  wxString msg;
215 
216  // DSO with KIFACE has not been loaded yet, does caller want to load it?
217  if( doLoad )
218  {
219  wxString dname = dso_search_path( aFaceId );
220 
221  // Insert DLL search path for kicad_3dsg from build dir
222  if( wxGetEnv( wxT( "KICAD_RUN_FROM_BUILD_DIR" ), nullptr ) )
223  {
224  wxFileName myPath = wxStandardPaths::Get().GetExecutablePath();
225 
226  if( !myPath.GetPath().EndsWith( wxT( "pcbnew" ) ) )
227  {
228  myPath.RemoveLastDir();
229  myPath.AppendDir( wxT( "pcbnew" ) );
231  }
232  }
233 
234 #ifdef KICAD_WIN32_VERIFY_CODESIGN
235  bool codeSignOk = KIPLATFORM::ENV::VerifyFileSignature( dname );
236  if( !codeSignOk )
237  {
238  msg.Printf( _( "Failed to verify kiface library '%s' signature." ), dname );
239  THROW_IO_ERROR( msg );
240  }
241 #endif
242 
243  wxDynamicLibrary dso;
244 
245  void* addr = nullptr;
246 
247  // For some reason wxDynamicLibrary::Load() crashes in some languages
248  // (chinese for instance) when loading the dynamic library.
249  // The crash happens for Eeschema.
250  // So switch to "C" locale during loading (LC_COLLATE is enough).
251  int lc_new_type = LC_COLLATE;
252  std::string user_locale = setlocale( lc_new_type, nullptr );
253  setlocale( lc_new_type, "C" );
254 
255  bool success = dso.Load( dname, wxDL_VERBATIM | wxDL_NOW | wxDL_GLOBAL );
256 
257  setlocale( lc_new_type, user_locale.c_str() );
258 
259  if( !success )
260  {
261  // Failure: error reporting UI was done via wxLogSysError().
262  // No further reporting required here. Apparently this is not true on all
263  // platforms and/or wxWidgets builds and KiCad will crash. Throwing the exception
264  // here and catching it in the KiCad launcher resolves the crash issue. See bug
265  // report https://bugs.launchpad.net/kicad/+bug/1577786.
266 
267  msg.Printf( _( "Failed to load kiface library '%s'." ), dname );
268  THROW_IO_ERROR( msg );
269  }
270  else if( ( addr = dso.GetSymbol( wxT( KIFACE_INSTANCE_NAME_AND_VERSION ) ) ) == nullptr )
271  {
272  // Failure: error reporting UI was done via wxLogSysError().
273  // No further reporting required here. Assume the same thing applies here as
274  // above with the Load() call. This has not been tested.
275  msg.Printf( _( "Could not read instance name and version from kiface library '%s'." ),
276  dname );
277  THROW_IO_ERROR( msg );
278  }
279  else
280  {
281  KIFACE_GETTER_FUNC* ki_getter = (KIFACE_GETTER_FUNC*) addr;
282 
283  KIFACE* kiface = ki_getter( &m_kiface_version[aFaceId], KIFACE_VERSION, m_program );
284 
285  // KIFACE_GETTER_FUNC function comment (API) says the non-NULL is unconditional.
286  wxASSERT_MSG( kiface,
287  wxT( "attempted DSO has a bug, failed to return a KIFACE*" ) );
288 
289  // Give the DSO a single chance to do its "process level" initialization.
290  // "Process level" specifically means stay away from any projects in there.
291  if( kiface->OnKifaceStart( m_program, m_ctl ) )
292  {
293  // Tell dso's wxDynamicLibrary destructor not to Unload() the program image.
294  ignore_unused( dso.Detach() );
295 
296  return m_kiface[aFaceId] = kiface;
297  }
298  }
299 
300  // In any of the failure cases above, dso.Unload() should be called here
301  // by dso destructor.
302  // However:
303 
304  // There is a file installation bug. We only look for KIFACE's which we know
305  // to exist, and we did not find one. If we do not find one, this is an
306  // installation bug.
307 
308  msg = wxString::Format( _( "Fatal Installation Bug. File:\n"
309  "'%s'\ncould not be loaded\n" ), dname );
310 
311  if( ! wxFileExists( dname ) )
312  msg << _( "It is missing.\n" );
313  else
314  msg << _( "Perhaps a shared library (.dll or .so) file is missing.\n" );
315 
316  msg << _( "From command line: argv[0]:\n'" );
317  msg << wxStandardPaths::Get().GetExecutablePath() << wxT( "'\n" );
318 
319  // This is a fatal error, one from which we cannot recover, nor do we want
320  // to protect against in client code which would require numerous noisy
321  // tests in numerous places. So we inform the user that the installation
322  // is bad. This exception will likely not get caught until way up in the
323  // wxApp derivative, at which point the process will exit gracefully.
324  THROW_IO_ERROR( msg );
325  }
326 
327  return nullptr;
328 }
BITMAP2CMP_SETTINGS kiface
#define KIFACE_VERSION
The KIWAY and KIFACE classes are used to communicate between various process modules,...
Definition: kiway.h:109
bool VerifyFileSignature(const wxString &aPath)
Validates the code signing signature of a given file This is most likely only ever going to be applic...
PGM_BASE * m_program
Definition: kiway.h:424
void AddDynamicLibrarySearchPath(const wxString &aPath)
Inserts a search path for loading dynamic libraries.
Definition: gtk/app.cpp:93
#define KIFACE_INSTANCE_NAME_AND_VERSION
Definition: kiway.h:114
KIFACE * KIFACE_GETTER_FUNC(int *aKIFACEversion, int aKIWAYversion, PGM_BASE *aProgram)
Point to the one and only KIFACE export.
Definition: kiway.h:458
int m_ctl
Definition: kiway.h:425
#define _(s)
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Returns # of elements in an array.
Definition: arraydim.h:31
const wxString dso_search_path(FACE_T aFaceId)
Get the [path &] name of the DSO holding the requested FACE_T.
Definition: kiway.cpp:105
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
Implement a participant in the KIWAY alchemy.
Definition: kiway.h:148
void ignore_unused(const T &)
Definition: ignore.h:24
static int m_kiface_version[KIWAY_FACE_COUNT]
Definition: kiway.h:422
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38
static KIFACE * m_kiface[KIWAY_FACE_COUNT]
Definition: kiway.h:421

References _, KIPLATFORM::APP::AddDynamicLibrarySearchPath(), arrayDim(), dso_search_path(), Format(), ignore_unused(), kiface, KIFACE_INSTANCE_NAME_AND_VERSION, KIFACE_VERSION, m_ctl, m_kiface, m_kiface_version, m_program, THROW_IO_ERROR, and KIPLATFORM::ENV::VerifyFileSignature().

Referenced by COMMON_CONTROL::ConfigurePaths(), FOOTPRINT_PREVIEW_PANEL_BASE::Create(), get_instance_from_id(), SCRIPTING_TOOL::Init(), SAVE_AS_TRAVERSER::OnFile(), PROJECT::PcbFootprintLibs(), Player(), and COMMON_CONTROL::ShowLibraryTable().

◆ KifaceType()

KIWAY::FACE_T KIWAY::KifaceType ( FRAME_T  aFrameType)
static

A simple mapping function which returns the FACE_T which is known to implement aFrameType.

Returns
a valid value KIWAY::FACE_T or FACE_T(-1) if given a bad aFrameType.

Definition at line 331 of file kiway.cpp.

332 {
333  switch( aFrameType )
334  {
335  case FRAME_SCH:
337  case FRAME_SCH_VIEWER:
339  case FRAME_SIMULATOR:
340  return FACE_SCH;
341 
342  case FRAME_PCB_EDITOR:
347  case FRAME_PCB_DISPLAY3D:
348  return FACE_PCB;
349 
350  case FRAME_CVPCB:
351  case FRAME_CVPCB_DISPLAY:
352  return FACE_CVPCB;
353 
354  case FRAME_PYTHON:
355  return FACE_PYTHON;
356 
357  case FRAME_GERBER:
358  return FACE_GERBVIEW;
359 
360  case FRAME_PL_EDITOR:
361  return FACE_PL_EDITOR;
362 
363  case FRAME_CALC:
364  return FACE_PCB_CALCULATOR;
365 
366  case FRAME_BM2CMP:
367  return FACE_BMP2CMP;
368 
369  default:
370  return FACE_T( -1 );
371  }
372 }
pcbnew DSO
Definition: kiway.h:269
FACE_T
Known KIFACE implementations.
Definition: kiway.h:266
eeschema DSO
Definition: kiway.h:268

References FACE_BMP2CMP, FACE_CVPCB, FACE_GERBVIEW, FACE_PCB, FACE_PCB_CALCULATOR, FACE_PL_EDITOR, FACE_PYTHON, FACE_SCH, FRAME_BM2CMP, FRAME_CALC, FRAME_CVPCB, FRAME_CVPCB_DISPLAY, FRAME_FOOTPRINT_EDITOR, FRAME_FOOTPRINT_VIEWER, FRAME_FOOTPRINT_VIEWER_MODAL, FRAME_FOOTPRINT_WIZARD, FRAME_GERBER, FRAME_PCB_DISPLAY3D, FRAME_PCB_EDITOR, FRAME_PL_EDITOR, FRAME_PYTHON, FRAME_SCH, FRAME_SCH_SYMBOL_EDITOR, FRAME_SCH_VIEWER, FRAME_SCH_VIEWER_MODAL, and FRAME_SIMULATOR.

Referenced by PGM_SINGLE_TOP::OnPgmInit(), and Player().

◆ OnKiCadExit()

void KIWAY::OnKiCadExit ( )

Definition at line 636 of file kiway.cpp.

637 {
639  {
640  // A dynamic_cast could be better, but creates link issues
641  // (some basic_frame functions not found) on some platforms,
642  // so a static_cast is used.
643  EDA_BASE_FRAME* top = static_cast<EDA_BASE_FRAME*>( m_top );
644 
645  if( top )
646  top->Close( false );
647  }
648 }
#define KFCTL_CPP_PROJECT_SUITE
Running under C++ project mgr, possibly with others.
Definition: kiway.h:157
int m_ctl
Definition: kiway.h:425
The base frame for deriving all KiCad main window classes.
wxFrame * m_top
Definition: kiway.h:427

References KFCTL_CPP_PROJECT_SUITE, m_ctl, and m_top.

Referenced by PL_EDITOR_FRAME::OnExit(), SCH_EDIT_FRAME::OnExit(), FOOTPRINT_EDIT_FRAME::OnExitKiCad(), FOOTPRINT_VIEWER_FRAME::OnExitKiCad(), SYMBOL_EDIT_FRAME::OnExitKiCad(), and PCB_EDIT_FRAME::OnQuit().

◆ OnKiwayEnd()

void KIWAY::OnKiwayEnd ( )

Definition at line 651 of file kiway.cpp.

652 {
653  for( KIFACE* i : m_kiface )
654  {
655  if( i )
656  i->OnKifaceEnd();
657  }
658 }
Implement a participant in the KIWAY alchemy.
Definition: kiway.h:148
static KIFACE * m_kiface[KIWAY_FACE_COUNT]
Definition: kiway.h:421

References m_kiface.

Referenced by CreateWindow(), PGM_KICAD::OnPgmExit(), PGM_SINGLE_TOP::OnPgmExit(), and PGM_MOCK_EESCHEMA_FRAME::OnPgmExit().

◆ Player()

KIWAY_PLAYER * KIWAY::Player ( FRAME_T  aFrameType,
bool  doCreate = true,
wxTopLevelWindow *  aParent = nullptr 
)
virtual

Return the KIWAY_PLAYER* given a FRAME_T.

If it is not already created, the required KIFACE is found and loaded and initialized if necessary, then the KIWAY_PLAYER window is created but not shown. Caller must Show() it. If it is already created, then the existing KIWAY_PLAYER* pointer is returned.

Parameters
aFrameTypeis from enum FRAME_T.
doCreatewhen true asks that the player be created if it is not already created, false means do not create and maybe return NULL.
aParentis a parent for modal KIWAY_PLAYER frames, otherwise NULL used only when doCreate = true and by KIWAY_PLAYER frames created in modal form
Returns
a valid opened KIWAY_PLAYER or NULL if there is something wrong or doCreate was false and the player has yet to be created.
Exceptions
IO_ERRORif the *.kiface file could not be found, filled with text saying what.

Definition at line 393 of file kiway.cpp.

394 {
395  // Since this will be called from python, cannot assume that code will
396  // not pass a bad aFrameType.
397  if( (unsigned) aFrameType >= KIWAY_PLAYER_COUNT )
398  {
399  // @todo : throw an exception here for python's benefit, at least that
400  // way it gets some explanatory text.
401 
402  wxASSERT_MSG( 0, wxT( "caller has a bug, passed a bad aFrameType" ) );
403  return nullptr;
404  }
405 
406  // return the previously opened window
407  KIWAY_PLAYER* frame = GetPlayerFrame( aFrameType );
408 
409  if( frame )
410  return frame;
411 
412  if( doCreate )
413  {
414  try
415  {
416  FACE_T face_type = KifaceType( aFrameType );
417  KIFACE* kiface = KiFACE( face_type );
418 
419  frame = (KIWAY_PLAYER*) kiface->CreateWindow(
420  aParent, // Parent window of frame in modal mode,
421  // NULL in non modal mode
422  aFrameType,
423  this,
424  m_ctl // questionable need, these same flags
425  // were passed to KIFACE::OnKifaceStart()
426  );
427 
428  m_playerFrameId[aFrameType].store( frame->GetId() );
429  return frame;
430  }
431  catch( const IO_ERROR& ioe )
432  {
433  DisplayErrorMessage( nullptr, _( "Error loading editor." ), ioe.What() );
434  }
435  catch( const std::exception& e)
436  {
437  DisplayErrorMessage( nullptr, _( "Error loading editor." ), e.what() );
438  }
439  catch( ... )
440  {
441  DisplayErrorMessage( nullptr, _( "Error loading editor." ) );
442  }
443  }
444 
445  return nullptr;
446 }
BITMAP2CMP_SETTINGS kiface
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:64
std::atomic< wxWindowID > m_playerFrameId[KIWAY_PLAYER_COUNT]
Definition: kiway.h:435
static FACE_T KifaceType(FRAME_T aFrameType)
A simple mapping function which returns the FACE_T which is known to implement aFrameType.
Definition: kiway.cpp:331
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:292
KIWAY_PLAYER * GetPlayerFrame(FRAME_T aFrameType)
Definition: kiway.cpp:375
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
int m_ctl
Definition: kiway.h:425
#define _(s)
virtual KIFACE * KiFACE(FACE_T aFaceId, bool doLoad=true)
Return the KIFACE* given a FACE_T.
Definition: kiway.cpp:197
FACE_T
Known KIFACE implementations.
Definition: kiway.h:266
Implement a participant in the KIWAY alchemy.
Definition: kiway.h:148
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:75

References _, DisplayErrorMessage(), GetPlayerFrame(), kiface, KiFACE(), KifaceType(), KIWAY_PLAYER_COUNT, m_ctl, m_playerFrameId, and IO_ERROR::What().

Referenced by FOOTPRINT_VIEWER_FRAME::AddFootprintToPCB(), PCB_BASE_EDIT_FRAME::AddLibrary(), SYMBOL_EDITOR_CONTROL::AddSymbolToSchematic(), SCH_EDIT_FRAME::AskToSaveChanges(), SYMBOL_EDIT_FRAME::CanCloseSymbolFromSchematic(), PCB_EDIT_FRAME::canCloseWindow(), SCH_EDIT_FRAME::canCloseWindow(), FOOTPRINT_EDITOR_CONTROL::CreateFootprint(), FIELDS_GRID_TRICKS::doPopupSelection(), FIELDS_EDITOR_GRID_TRICKS::doPopupSelection(), BOARD_EDITOR_CONTROL::EditFpInFpEditor(), SCH_EDITOR_CONTROL::EditWithSymbolEditor(), BACK_ANNOTATE::FetchNetlistFromPCB(), KICAD_MANAGER_FRAME::ImportNonKiCadProject(), InvokePcbLibTableEditor(), InvokeSchEditSymbolLibTable(), EDA_DRAW_FRAME::IsScriptingConsoleVisible(), DIALOG_CHANGE_SYMBOLS::launchMatchIdSymbolBrowser(), DIALOG_CHANGE_SYMBOLS::launchNewIdSymbolBrowser(), FOOTPRINT_EDIT_FRAME::LoadFootprintFromBoard(), TEXT_BUTTON_SYMBOL_CHOOSER::OnButtonClick(), TEXT_BUTTON_FP_CHOOSER::OnButtonClick(), SCH_EDIT_FRAME::OnOpenCvpcb(), SCH_EDIT_FRAME::OnOpenPcbnew(), PGM_SINGLE_TOP::OnPgmInit(), EDA_BASE_FRAME::OnPreferences(), DIALOG_SYMBOL_REMAP::OnRemapSymbols(), DIALOG_FIELD_PROPERTIES::OnTextValueSelectButtonClick(), FOOTPRINT_EDIT_FRAME::OnUpdateLoadFootprintFromBoard(), SCH_EDIT_FRAME::OnUpdatePCB(), FOOTPRINT_EDIT_FRAME::OnUpdateSaveFootprintToBoard(), SCH_BASE_FRAME::PickSymbolFromLibBrowser(), ProcessEvent(), SCH_EDIT_TOOL::Properties(), SCH_EDITOR_CONTROL::rescueProject(), PCB_EDIT_FRAME::RunEeschema(), EE_INSPECTION_TOOL::RunSimulation(), SYMBOL_EDIT_FRAME::Save(), SYMBOL_EDIT_FRAME::saveCurrentSymbol(), FOOTPRINT_EDIT_FRAME::SaveFootprintToBoard(), EDA_DRAW_FRAME::ScriptingConsoleEnableDisable(), PCB_BASE_FRAME::SelectFootprintFromLibBrowser(), PCB_EDIT_FRAME::ShowFootprintPropertiesDialog(), CVPCB_CONTROL::ShowFootprintViewer(), COMMON_CONTROL::ShowPlayer(), KICAD_MANAGER_CONTROL::ShowPlayer(), SIM_PLOT_FRAME::SIM_PLOT_FRAME(), PCB_EDIT_FRAME::TestStandalone(), BOARD_EDITOR_CONTROL::UpdateSchematicFromPCB(), and DIALOG_EXCHANGE_FOOTPRINTS::ViewAndSelectFootprint().

◆ PlayerClose()

bool KIWAY::PlayerClose ( FRAME_T  aFrameType,
bool  doForce 
)
virtual

Call the KIWAY_PLAYER::Close( bool force ) function on the window and if not vetoed, returns true, else false.

If window actually closes, then this KIWAY marks it as not opened internally.

Returns
true if the window is closed and not vetoed, else false.

Definition at line 449 of file kiway.cpp.

450 {
451  // Since this will be called from python, cannot assume that code will
452  // not pass a bad aFrameType.
453  if( (unsigned) aFrameType >= KIWAY_PLAYER_COUNT )
454  {
455  // @todo : throw an exception here for python's benefit, at least that
456  // way it gets some explanatory text.
457 
458  wxASSERT_MSG( 0, wxT( "caller has a bug, passed a bad aFrameType" ) );
459  return false;
460  }
461 
462  KIWAY_PLAYER* frame = GetPlayerFrame( aFrameType );
463 
464  if( frame == nullptr ) // Already closed
465  return true;
466 
467  if( frame->NonUserClose( doForce ) )
468  return true;
469 
470  return false;
471 }
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:64
KIWAY_PLAYER * GetPlayerFrame(FRAME_T aFrameType)
Definition: kiway.cpp:375
bool NonUserClose(bool aForce)

References GetPlayerFrame(), KIWAY_PLAYER_COUNT, and EDA_BASE_FRAME::NonUserClose().

Referenced by PlayersClose().

◆ PlayersClose()

bool KIWAY::PlayersClose ( bool  doForce)
virtual

Call the KIWAY_PLAYER::Close( bool force ) function on all the windows and if none are vetoed, returns true, else false.

If any window actually closes, then* this KIWAY marks it as not opened internally.

Returns
true indicates that all windows closed because none were vetoed, false means at least one cast a veto. Any that cast a veto are still open.

Definition at line 474 of file kiway.cpp.

475 {
476  bool ret = true;
477 
478  for( unsigned i=0; i < KIWAY_PLAYER_COUNT; ++i )
479  {
480  ret = ret && PlayerClose( FRAME_T( i ), doForce );
481  }
482 
483  return ret;
484 }
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:32
virtual bool PlayerClose(FRAME_T aFrameType, bool doForce)
Call the KIWAY_PLAYER::Close( bool force ) function on the window and if not vetoed,...
Definition: kiway.cpp:449

References KIWAY_PLAYER_COUNT, and PlayerClose().

◆ Prj()

PROJECT & KIWAY::Prj ( ) const
virtual

Return the PROJECT associated with this KIWAY.

This is here as an accessor, so that there is freedom to put the actual PROJECT storage in a place decided by the implementation, and not known to the caller.

Definition at line 191 of file kiway.cpp.

192 {
193  return Pgm().GetSettingsManager().Prj();
194 }
virtual PROJECT & Prj() const
Return the PROJECT associated with this KIWAY.
Definition: kiway.cpp:191
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:106

References Pgm(), and Prj().

Referenced by PCB::IFACE::CreateWindow(), SYMBOL_PREVIEW_WIDGET::DisplaySymbol(), FOOTPRINT_LIST::GetInstance(), InvokePcbLibTableEditor(), InvokeSchEditSymbolLibTable(), LIB_TREE_MODEL_ADAPTER::LIB_TREE_MODEL_ADAPTER(), KIWAY_HOLDER::Prj(), Prj(), Prj(), and LIB_TREE_MODEL_ADAPTER::SavePinnedItems().

◆ ProcessEvent()

bool KIWAY::ProcessEvent ( wxEvent &  aEvent)
override

Definition at line 610 of file kiway.cpp.

611 {
612  KIWAY_EXPRESS* mail = dynamic_cast<KIWAY_EXPRESS*>( &aEvent );
613 
614  if( mail )
615  {
616  FRAME_T dest = mail->Dest();
617 
618  // see if recipient is alive
619  KIWAY_PLAYER* alive = Player( dest, false );
620 
621  if( alive )
622  {
623 #if 1
624  return alive->ProcessEvent( aEvent );
625 #else
626  alive->KiwayMailIn( *mail );
627  return true;
628 #endif
629  }
630  }
631 
632  return false;
633 }
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:64
Carry a payload from one KIWAY_PLAYER to another within a PROJECT.
Definition: kiway_express.h:38
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:32
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:393
virtual void KiwayMailIn(KIWAY_EXPRESS &aEvent)
Receive KIWAY_EXPRESS messages from other players.
FRAME_T Dest()
Return the destination player id of the message.
Definition: kiway_express.h:44
bool ProcessEvent(wxEvent &aEvent) override
Override the default process event handler to implement the auto save feature.

References KIWAY_EXPRESS::Dest(), KIWAY_PLAYER::KiwayMailIn(), Player(), and EDA_BASE_FRAME::ProcessEvent().

Referenced by ExpressMail().

◆ ProjectChanged()

void KIWAY::ProjectChanged ( )
virtual

Calls ProjectChanged() on all KIWAY_PLAYERs.

Used after changing the project to ensure all players are updated correctly.

Definition at line 587 of file kiway.cpp.

588 {
590  {
591  // A dynamic_cast could be better, but creates link issues
592  // (some basic_frame functions not found) on some platforms,
593  // so a static_cast is used.
594  EDA_BASE_FRAME* top = static_cast<EDA_BASE_FRAME*>( m_top );
595 
596  if( top )
597  top->ProjectChanged();
598  }
599 
600  for( unsigned i=0; i < KIWAY_PLAYER_COUNT; ++i )
601  {
602  KIWAY_PLAYER* frame = GetPlayerFrame( ( FRAME_T )i );
603 
604  if( frame )
605  frame->ProjectChanged();
606  }
607 }
#define KFCTL_CPP_PROJECT_SUITE
Running under C++ project mgr, possibly with others.
Definition: kiway.h:157
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:64
KIWAY_PLAYER * GetPlayerFrame(FRAME_T aFrameType)
Definition: kiway.cpp:375
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:32
int m_ctl
Definition: kiway.h:425
The base frame for deriving all KiCad main window classes.
virtual void ProjectChanged()
Notification event that the project has changed.
wxFrame * m_top
Definition: kiway.h:427

References GetPlayerFrame(), KFCTL_CPP_PROJECT_SUITE, KIWAY_PLAYER_COUNT, m_ctl, m_top, and EDA_BASE_FRAME::ProjectChanged().

Referenced by SETTINGS_MANAGER::LoadProject(), and SETTINGS_MANAGER::UnloadProject().

◆ set_kiface()

bool KIWAY::set_kiface ( FACE_T  aFaceType,
KIFACE aKiface 
)
inlineprivate

Definition at line 404 of file kiway.h.

405  {
406  if( (unsigned) aFaceType < (unsigned) KIWAY_FACE_COUNT )
407  {
408  m_kiface[aFaceType] = aKiface;
409  return true;
410  }
411 
412  return false;
413  }
static KIFACE * m_kiface[KIWAY_FACE_COUNT]
Definition: kiway.h:421

References KIWAY_FACE_COUNT, and m_kiface.

Referenced by PGM_SINGLE_TOP::OnPgmInit().

◆ SetLanguage()

void KIWAY::SetLanguage ( int  aLanguage)
virtual

Change the language and then calls ShowChangedLanguage() on all #KIWAY_PLAYERs.

Definition at line 496 of file kiway.cpp.

497 {
498  wxString errMsg;
499  bool ret = false;
500 
501  {
502  // Only allow the traces to be logged by wx. We use our own system to log when the
503  // OS doesn't support the language, so we want to hide the wx error.
504  WX_LOG_TRACE_ONLY logtraceOnly;
505  Pgm().SetLanguageIdentifier( aLanguage );
506  ret = Pgm().SetLanguage( errMsg );
507  }
508 
509  if( !ret )
510  {
511  wxString lang;
512 
513  for( unsigned ii = 0; LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
514  {
515  if( aLanguage == LanguagesList[ii].m_KI_Lang_Identifier )
516  {
517  if( LanguagesList[ii].m_DoNotTranslate )
518  lang = LanguagesList[ii].m_Lang_Label;
519  else
520  lang = wxGetTranslation( LanguagesList[ii].m_Lang_Label );
521 
522  break;
523  }
524  }
525 
526  DisplayErrorMessage( nullptr,
527  wxString::Format( _( "Unable to switch language to %s" ), lang ),
528  errMsg );
529  return;
530  }
531 
532 #if 1
533  // This is a risky hack that goes away if we allow the language to be
534  // set only from the top most frame if !Kiface.IsSingle()
535 
536  // Only for the C++ project manager, and not for the python one and not for
537  // single_top do we look for the EDA_BASE_FRAME as the top level window.
538  // For single_top this is not needed because that window is registered in
539  // the array below.
541  {
542  // A dynamic_cast could be better, but creates link issues
543  // (some basic_frame functions not found) on some platforms,
544  // so a static_cast is used.
545  EDA_BASE_FRAME* top = static_cast<EDA_BASE_FRAME*>( m_top );
546 
547  if( top )
548  top->ShowChangedLanguage();
549  }
550 #endif
551 
552  for( unsigned i=0; i < KIWAY_PLAYER_COUNT; ++i )
553  {
554  KIWAY_PLAYER* frame = GetPlayerFrame( ( FRAME_T )i );
555 
556  if( frame )
557  {
558  frame->ShowChangedLanguage();
559  }
560  }
561 }
#define KFCTL_CPP_PROJECT_SUITE
Running under C++ project mgr, possibly with others.
Definition: kiway.h:157
LANGUAGE_DESCR LanguagesList[]
An array containing all the languages that KiCad supports.
Definition: pgm_base.cpp:71
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:64
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:292
void ShowChangedLanguage() override
Redraw the menus and what not in current language.
KIWAY_PLAYER * GetPlayerFrame(FRAME_T aFrameType)
Definition: kiway.cpp:375
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:32
int m_KI_Lang_Identifier
KiCad identifier used in menu selection (See id.h)
Definition: pgm_base.h:65
virtual void SetLanguage(int aLanguage)
Change the language and then calls ShowChangedLanguage() on all #KIWAY_PLAYERs.
Definition: kiway.cpp:496
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
Definition: single_top.cpp:106
int m_ctl
Definition: kiway.h:425
#define _(s)
wxString m_Lang_Label
Labels used in menus.
Definition: pgm_base.h:68
A logger class that filters out all log messages that are not generated by wxLogTrace and ignores the...
Definition: logging.h:31
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
The base frame for deriving all KiCad main window classes.
wxFrame * m_top
Definition: kiway.h:427

References _, DisplayErrorMessage(), Format(), GetPlayerFrame(), KFCTL_CPP_PROJECT_SUITE, KIWAY_PLAYER_COUNT, LanguagesList, m_ctl, LANGUAGE_DESCR::m_KI_Lang_Identifier, LANGUAGE_DESCR::m_Lang_Label, m_top, Pgm(), SetLanguage(), and EDA_BASE_FRAME::ShowChangedLanguage().

Referenced by KICAD_MANAGER_FRAME::language_change(), KIWAY_PLAYER::language_change(), and SetLanguage().

◆ SetTop()

void KIWAY::SetTop ( wxFrame *  aTop)

Tell this KIWAY about the top most frame in the program and optionally allows it to play the role of one of the KIWAY_PLAYERs if launched from single_top.cpp.

Parameters
aTopis the top most wxFrame in the entire program.

Definition at line 83 of file kiway.cpp.

84 {
85 #if 0
86  if( m_top )
87  {
88  m_top->Disconnect( wxEVT_DESTROY,
89  wxWindowDestroyEventHandler( KIWAY::player_destroy_handler ),
90  nullptr, this );
91  }
92 
93  if( aTop )
94  {
95  aTop->Connect( wxEVT_DESTROY,
96  wxWindowDestroyEventHandler( KIWAY::player_destroy_handler ),
97  nullptr, this );
98  }
99 #endif
100 
101  m_top = aTop;
102 }
wxFrame * m_top
Definition: kiway.h:427

References m_top.

Referenced by KIWAY(), PGM_KICAD::OnPgmInit(), and PGM_SINGLE_TOP::OnPgmInit().

Friends And Related Function Documentation

◆ PGM_SINGLE_TOP

friend struct PGM_SINGLE_TOP
friend

Definition at line 262 of file kiway.h.

Member Data Documentation

◆ m_ctl

int KIWAY::m_ctl
private

◆ m_kiface

KIFACE * KIWAY::m_kiface
staticprivate

Definition at line 421 of file kiway.h.

Referenced by KiFACE(), OnKiwayEnd(), and set_kiface().

◆ m_kiface_version

int KIWAY::m_kiface_version
staticprivate

Definition at line 422 of file kiway.h.

Referenced by KiFACE().

◆ m_playerFrameId

std::atomic<wxWindowID> KIWAY::m_playerFrameId[KIWAY_PLAYER_COUNT]
private

Definition at line 435 of file kiway.h.

Referenced by GetPlayerFrame(), KIWAY(), and Player().

◆ m_program

PGM_BASE* KIWAY::m_program
private

Definition at line 424 of file kiway.h.

Referenced by KiFACE().

◆ m_top

wxFrame* KIWAY::m_top
private

Definition at line 427 of file kiway.h.

Referenced by CommonSettingsChanged(), GetTop(), OnKiCadExit(), ProjectChanged(), SetLanguage(), and SetTop().


The documentation for this class was generated from the following files: