KiCad PCB EDA Suite
Loading...
Searching...
No Matches
kicad.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) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright The 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
31#include <wx/filename.h>
32#include <wx/log.h>
33#include <wx/app.h>
34#include <wx/stdpaths.h>
35#include <wx/msgdlg.h>
36#include <wx/cmdline.h>
37
38#include <env_vars.h>
39#include <file_history.h>
40#include <hotkeys_basic.h>
41#include <kiway.h>
42#include <macros.h>
43#include <paths.h>
44#include <richio.h>
47#include <systemdirsappend.h>
48#include <trace_helpers.h>
50#include <confirm.h>
51
52#include <git2.h>
53#include <stdexcept>
54
55#include "pgm_kicad.h"
56#include "kicad_manager_frame.h"
57
58#include <kiplatform/app.h>
60
61#ifdef KICAD_IPC_API
62#include <api/api_server.h>
63#endif
64
65// a dummy to quiet linking with EDA_BASE_FRAME::config();
66#include <kiface_base.h>
68{
69 // This function should never be called. It is only referenced from
70 // EDA_BASE_FRAME::config() and this is only provided to satisfy the linker,
71 // not to be actually called.
72 wxLogFatalError( wxT( "Unexpected call to Kiface() in kicad/kicad.cpp" ) );
73
74 throw std::logic_error( "Unexpected call to Kiface() in kicad/kicad.cpp" );
75}
76
77
79
81{
82 return program;
83}
84
85
87{
88 App().SetAppDisplayName( wxT( "KiCad" ) );
89
90#if defined(DEBUG)
91 wxString absoluteArgv0 = wxStandardPaths::Get().GetExecutablePath();
92
93 if( !wxIsAbsolutePath( absoluteArgv0 ) )
94 {
95 wxLogError( wxT( "No meaningful argv[0]" ) );
96 return false;
97 }
98#endif
99
100 // Initialize the git library before trying to initialize individual programs
101 git_libgit2_init();
102
103 static const wxCmdLineEntryDesc desc[] = {
104 { wxCMD_LINE_OPTION, "f", "frame", "Frame to load", wxCMD_LINE_VAL_STRING, 0 },
105 { wxCMD_LINE_SWITCH, "n", "new", "New instance of KiCad, does not attempt to load previously open files",
106 wxCMD_LINE_VAL_NONE, 0 },
107#ifndef __WXOSX__
108 { wxCMD_LINE_SWITCH, nullptr, "software-rendering", "Use software rendering instead of OpenGL",
109 wxCMD_LINE_VAL_NONE, 0 },
110#endif
111 { wxCMD_LINE_PARAM, nullptr, nullptr, "File to load", wxCMD_LINE_VAL_STRING,
112 wxCMD_LINE_PARAM_MULTIPLE | wxCMD_LINE_PARAM_OPTIONAL },
113 { wxCMD_LINE_NONE, nullptr, nullptr, nullptr, wxCMD_LINE_VAL_NONE, 0 }
114 };
115
116 wxCmdLineParser parser( App().argc, App().argv );
117 parser.SetDesc( desc );
118 parser.Parse( false );
119
120 FRAME_T appType = KICAD_MAIN_FRAME_T;
121
122 const struct
123 {
124 wxString name;
125 FRAME_T type;
126 } frameTypes[] = { { wxT( "pcb" ), FRAME_PCB_EDITOR },
127 { wxT( "fpedit" ), FRAME_FOOTPRINT_EDITOR },
128 { wxT( "sch" ), FRAME_SCH },
129 { wxT( "calc" ), FRAME_CALC },
130 { wxT( "bm2cmp" ), FRAME_BM2CMP },
131 { wxT( "ds" ), FRAME_PL_EDITOR },
132 { wxT( "gerb" ), FRAME_GERBER },
133 { wxT( "" ), FRAME_T_COUNT } };
134
135 wxString frameName;
136
137 if( parser.Found( "frame", &frameName ) )
138 {
139 appType = FRAME_T_COUNT;
140
141 for( const auto& it : frameTypes )
142 {
143 if( it.name == frameName )
144 appType = it.type;
145 }
146
147 if( appType == FRAME_T_COUNT )
148 {
149 wxLogError( wxT( "Unknown frame: %s" ), frameName );
150 // Clean up
151 OnPgmExit();
152 return false;
153 }
154 }
155
156 if( appType == KICAD_MAIN_FRAME_T )
157 {
159 }
160 else
161 {
163 }
164
165#ifndef __WXMAC__
166 if( parser.Found( "software-rendering" ) )
167 {
168 wxSetEnv( "KICAD_SOFTWARE_RENDERING", "1" );
169 }
170#endif
171
172 bool skipPythonInit = false;
173
174 if( appType == FRAME_BM2CMP || appType == FRAME_PL_EDITOR || appType == FRAME_GERBER
175 || appType == FRAME_CALC )
176 skipPythonInit = true;
177
178 if( !InitPgm( false, skipPythonInit ) )
179 return false;
180
184 m_bm.Init();
185
186 // Add search paths to feed the PGM_KICAD::SysSearch() function,
187 // currently limited in support to only look for project templates
188 {
189 SEARCH_STACK bases;
190
191 SystemDirsAppend( &bases );
192
193 for( unsigned i = 0; i < bases.GetCount(); ++i )
194 {
195 wxFileName fn( bases[i], wxEmptyString );
196
197 // Add KiCad template file path to search path list.
198 fn.AppendDir( wxT( "template" ) );
199
200 // Only add path if exists and can be read by the user.
201 if( fn.DirExists() && fn.IsDirReadable() )
202 m_bm.m_search.AddPaths( fn.GetPath() );
203 }
204
205 // The versioned TEMPLATE_DIR takes precedence over the search stack template path.
206 if( std::optional<wxString> v = ENV_VAR::GetVersionedEnvVarValue( GetLocalEnvVariables(),
207 wxT( "TEMPLATE_DIR" ) ) )
208 {
209 if( !v->IsEmpty() )
210 m_bm.m_search.Insert( *v, 0 );
211 }
212
213 // We've been adding system (installed default) search paths so far, now for user paths
214 // The default user search path is inside KIPLATFORM::ENV::GetDocumentsPath()
216
217 // ...but the user can override that default with the KICAD_USER_TEMPLATE_DIR env var
218 ENV_VAR_MAP_CITER it = GetLocalEnvVariables().find( "KICAD_USER_TEMPLATE_DIR" );
219
220 if( it != GetLocalEnvVariables().end() && it->second.GetValue() != wxEmptyString )
221 m_bm.m_search.Insert( it->second.GetValue(), 0 );
222 }
223
224 wxFrame* frame = nullptr;
225 KIWAY_PLAYER* playerFrame = nullptr;
226 KICAD_MANAGER_FRAME* managerFrame = nullptr;
227
228 if( appType == KICAD_MAIN_FRAME_T )
229 {
230 managerFrame = new KICAD_MANAGER_FRAME( nullptr, wxT( "KiCad" ), wxDefaultPosition,
231 wxWindow::FromDIP( wxSize( 775, -1 ), NULL ) );
232 frame = managerFrame;
233 }
234 else
235 {
236 // Use KIWAY to create a top window, which registers its existence also.
237 // "TOP_FRAME" is a macro that is passed on compiler command line from CMake,
238 // and is one of the types in FRAME_T.
239 playerFrame = Kiway.Player( appType, true );
240 frame = playerFrame;
241
242 if( frame == nullptr )
243 {
244 return false;
245 }
246 }
247
248 App().SetTopWindow( frame );
249
250 if( playerFrame )
251 App().SetAppDisplayName( playerFrame->GetAboutTitle() );
252
253 Kiway.SetTop( frame );
254
255 KIPLATFORM::ENV::SetAppDetailsForWindow( frame, '"' + wxStandardPaths::Get().GetExecutablePath() + '"' + " -n",
256 frame->GetTitle() );
257
258 KICAD_SETTINGS* settings = static_cast<KICAD_SETTINGS*>( PgmSettings() );
259
260#ifdef KICAD_IPC_API
261 m_api_server = std::make_unique<KICAD_API_SERVER>();
262 m_api_common_handler = std::make_unique<API_HANDLER_COMMON>();
263 m_api_server->RegisterHandler( m_api_common_handler.get() );
264#endif
265
266 wxString projToLoad;
267
268 HideSplash();
269
270 if( playerFrame && parser.GetParamCount() )
271 {
272 // Now after the frame processing, the rest of the positional args are files
273 std::vector<wxString> fileArgs;
274 /*
275 gerbview handles multiple project data files, i.e. gerber files on
276 cmd line. Others currently do not, they handle only one. For common
277 code simplicity we simply pass all the arguments in however, each
278 program module can do with them what they want, ignore, complain
279 whatever. We don't establish policy here, as this is a multi-purpose
280 launcher.
281 */
282
283 for( size_t i = 0; i < parser.GetParamCount(); i++ )
284 fileArgs.push_back( parser.GetParam( i ) );
285
286 // special attention to a single argument: argv[1] (==argSet[0])
287 if( fileArgs.size() == 1 )
288 {
289 wxFileName argv1( fileArgs[0] );
290
291#if defined( PGM_DATA_FILE_EXT )
292 // PGM_DATA_FILE_EXT, if present, may be different for each compile,
293 // it may come from CMake on the compiler command line, but often does not.
294 // This facility is mostly useful for those program footprints
295 // supporting a single argv[1].
296 if( !argv1.GetExt() )
297 argv1.SetExt( wxT( PGM_DATA_FILE_EXT ) );
298#endif
299 argv1.MakeAbsolute();
300
301 fileArgs[0] = argv1.GetFullPath();
302 }
303
304 // Use the KIWAY_PLAYER::OpenProjectFiles() API function:
305 if( !playerFrame->OpenProjectFiles( fileArgs ) )
306 {
307 // OpenProjectFiles() API asks that it report failure to the UI.
308 // Nothing further to say here.
309
310 // We've already initialized things at this point, but wx won't call OnExit if
311 // we fail out. Call our own cleanup routine here to ensure the relevant resources
312 // are freed at the right time (if they aren't, segfaults will occur).
313 OnPgmExit();
314
315 // Fail the process startup if the file could not be opened,
316 // although this is an optional choice, one that can be reversed
317 // also in the KIFACE specific OpenProjectFiles() return value.
318 return false;
319 }
320 }
321 else if( managerFrame )
322 {
323 if( parser.GetParamCount() > 0 )
324 {
325 wxFileName tmp = parser.GetParam( 0 );
326
327 if( tmp.GetExt() != FILEEXT::ProjectFileExtension && tmp.GetExt() != FILEEXT::LegacyProjectFileExtension )
328 {
329 DisplayErrorMessage( nullptr, wxString::Format( _( "File '%s'\n"
330 "does not appear to be a KiCad project file." ),
331 tmp.GetFullPath() ) );
332 }
333 else
334 {
335 projToLoad = tmp.GetFullPath();
336 }
337 }
338
339 // If no file was given as an argument, check that there was a file open.
340 if( projToLoad.IsEmpty() && settings->m_OpenProjects.size() && !parser.FoundSwitch( "new" ) )
341 {
342 wxString last_pro = settings->m_OpenProjects.front();
343 settings->m_OpenProjects.erase( settings->m_OpenProjects.begin() );
344
345 if( wxFileExists( last_pro ) )
346 {
347 // Try to open the last opened project,
348 // if a project name is not given when starting Kicad
349 projToLoad = last_pro;
350 }
351 }
352
353 // Do not attempt to load a non-existent project file.
354 if( !projToLoad.empty() )
355 {
356 wxFileName fn( projToLoad );
357
358 if( fn.Exists() && ( fn.GetExt() == FILEEXT::ProjectFileExtension
359 || fn.GetExt() == FILEEXT::LegacyProjectFileExtension ) )
360 {
361 fn.MakeAbsolute();
362
363 if( appType == KICAD_MAIN_FRAME_T )
364 managerFrame->LoadProject( fn );
365 }
366 }
367 }
368
369 frame->Show( true );
370 frame->Raise();
371
372#ifdef KICAD_IPC_API
373 m_api_server->SetReadyToReply();
374#endif
375
376 return true;
377}
378
379
381{
382 return 0;
383}
384
385
387{
389
390#ifdef KICAD_IPC_API
391 m_api_server.reset();
392#endif
393
395 {
397 m_settings_manager->Save();
398 }
399
400 // Destroy everything in PGM_KICAD,
401 // especially wxSingleInstanceCheckerImpl earlier than wxApp and earlier
402 // than static destruction would.
403 Destroy();
404 git_libgit2_shutdown();
405}
406
407
408void PGM_KICAD::MacOpenFile( const wxString& aFileName )
409{
410#if defined(__WXMAC__)
411
412 KICAD_MANAGER_FRAME* frame = (KICAD_MANAGER_FRAME*) App().GetTopWindow();
413
414 if( !aFileName.empty() && wxFileExists( aFileName ) )
415 frame->LoadProject( wxFileName( aFileName ) );
416
417#endif
418}
419
420
422{
423 // unlike a normal destructor, this is designed to be called more
424 // than once safely:
425
426 m_bm.End();
427
429}
430
431
433
434#ifdef NDEBUG
435// Define a custom assertion handler
436void CustomAssertHandler(const wxString& file,
437 int line,
438 const wxString& func,
439 const wxString& cond,
440 const wxString& msg)
441{
442 Pgm().HandleAssert( file, line, func, cond, msg );
443}
444#endif
445
449struct APP_KICAD : public wxApp
450{
451 APP_KICAD() : wxApp()
452 {
453 SetPgm( &program );
454
455 // Init the environment each platform wants
457 }
458
459
460 bool OnInit() override
461 {
462#ifdef NDEBUG
463 // These checks generate extra assert noise
464 wxSizerFlags::DisableConsistencyChecks();
465 wxDISABLE_DEBUG_SUPPORT();
466 wxSetAssertHandler( CustomAssertHandler );
467#endif
468
469 // Perform platform-specific init tasks
470 if( !KIPLATFORM::APP::Init() )
471 return false;
472
473#ifndef DEBUG
474 // Enable logging traces to the console in release build.
475 // This is usually disabled, but it can be useful for users to run to help
476 // debug issues and other problems.
477 if( wxGetEnv( wxS( "KICAD_ENABLE_WXTRACE" ), nullptr ) )
478 {
479 wxLog::EnableLogging( true );
480 wxLog::SetLogLevel( wxLOG_Trace );
481 }
482#endif
483
484 if( !program.OnPgmInit() )
485 {
487 return false;
488 }
489
490 return true;
491 }
492
493 int OnExit() override
494 {
496
497 // Avoid wxLog crashing when used in destructors.
498 wxLog::EnableLogging( false );
499
500 return wxApp::OnExit();
501 }
502
503 int OnRun() override
504 {
505 try
506 {
507 return wxApp::OnRun();
508 }
509 catch(...)
510 {
511 Pgm().HandleException( std::current_exception() );
512 }
513
514 return -1;
515 }
516
517 int FilterEvent( wxEvent& aEvent ) override
518 {
519 if( aEvent.GetEventType() == wxEVT_SHOW )
520 {
521 wxShowEvent& event = static_cast<wxShowEvent&>( aEvent );
522 wxDialog* dialog = dynamic_cast<wxDialog*>( event.GetEventObject() );
523
524 std::vector<void*>& dlgs = Pgm().m_ModalDialogs;
525
526 if( dialog )
527 {
528 if( event.IsShown() && dialog->IsModal() )
529 {
530 dlgs.push_back( dialog );
531 }
532 // Under GTK, sometimes the modal flag is cleared before hiding
533 else if( !event.IsShown() && !dlgs.empty() )
534 {
535 // If we close the expected dialog, remove it from our stack
536 if( dlgs.back() == dialog )
537 dlgs.pop_back();
538 // If an out-of-order, remove all dialogs added after the closed one
539 else if( auto it = std::find( dlgs.begin(), dlgs.end(), dialog ) ; it != dlgs.end() )
540 dlgs.erase( it, dlgs.end() );
541 }
542 }
543 }
544
545 return Event_Skip;
546 }
547
548#if defined( DEBUG )
552 bool ProcessEvent( wxEvent& aEvent ) override
553 {
554 if( aEvent.GetEventType() == wxEVT_CHAR || aEvent.GetEventType() == wxEVT_CHAR_HOOK )
555 {
556 wxKeyEvent* keyEvent = static_cast<wxKeyEvent*>( &aEvent );
557
558 if( keyEvent )
559 {
560 wxLogTrace( kicadTraceKeyEvent, "APP_KICAD::ProcessEvent %s", dump( *keyEvent ) );
561 }
562 }
563
564 aEvent.Skip();
565 return false;
566 }
567
575 bool OnExceptionInMainLoop() override
576 {
577 try
578 {
579 throw;
580 }
581 catch(...)
582 {
583 Pgm().HandleException( std::current_exception() );
584 }
585
586 return false; // continue on. Return false to abort program
587 }
588#endif
589
595#if defined( __WXMAC__ )
596 void MacOpenFile( const wxString& aFileName ) override
597 {
598 Pgm().MacOpenFile( aFileName );
599 }
600#endif
601};
602
603IMPLEMENT_APP( APP_KICAD )
604
605
606// The C++ project manager supports one open PROJECT, so Prj() calls within
607// this link image need this function.
609{
610 return Kiway.Prj();
611}
612
const char * name
Definition: DXF_plotter.cpp:62
const wxString & GetAboutTitle() const
The main KiCad project manager frame.
void LoadProject(const wxFileName &aProjectFileName)
std::vector< wxString > m_OpenProjects
A KIFACE implementation.
Definition: kiface_base.h:39
A wxFrame capable of the OpenProjectFiles function, meaning it can load a portion of a KiCad project.
Definition: kiway_player.h:65
virtual bool OpenProjectFiles(const std::vector< wxString > &aFileList, int aCtl=0)
Open a project or set of files given by aFileList.
Definition: kiway_player.h:113
A minimalistic software bus for communications between various DLLs/DSOs (DSOs) within the same KiCad...
Definition: kiway.h:286
virtual KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=nullptr)
Return the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:395
void SetCtlBits(int aCtlBits)
Overwrites previously set ctl bits, only for use in kicad.cpp to flip between standalone and manager ...
Definition: kiway.h:419
void OnKiwayEnd()
Definition: kiway.cpp:709
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:85
virtual PROJECT & Prj() const
Return the PROJECT associated with this KIWAY.
Definition: kiway.cpp:192
static wxString GetUserTemplatesPath()
Gets the user path for custom templates.
Definition: paths.cpp:70
virtual wxApp & App()
Return a bare naked wxApp which may come from wxPython, SINGLE_TOP, or kicad.exe.
Definition: pgm_base.cpp:183
virtual ENV_VAR_MAP & GetLocalEnvVariables() const
Definition: pgm_base.cpp:811
virtual void MacOpenFile(const wxString &aFileName)=0
Specific to MacOSX (not used under Linux or Windows).
std::unique_ptr< SETTINGS_MANAGER > m_settings_manager
Definition: pgm_base.h:375
void Destroy()
Definition: pgm_base.cpp:173
bool InitPgm(bool aHeadless=false, bool aSkipPyInit=false, bool aIsUnitTest=false)
Initialize this program.
Definition: pgm_base.cpp:337
std::vector< void * > m_ModalDialogs
Definition: pgm_base.h:355
void HandleException(std::exception_ptr aPtr)
A exception handler to be used at the top level if exceptions bubble up that for.
Definition: pgm_base.cpp:826
void HandleAssert(const wxString &aFile, int aLine, const wxString &aFunc, const wxString &aCond, const wxString &aMsg)
A common assert handler to be used between single_top and kicad.
Definition: pgm_base.cpp:851
virtual const wxString & GetExecutablePath() const
Definition: pgm_base.cpp:879
virtual SETTINGS_MANAGER & GetSettingsManager() const
Definition: pgm_base.h:125
void HideSplash()
Definition: pgm_base.cpp:326
void SaveCommonSettings()
Save the program (process) settings subset which are stored .kicad_common.
Definition: pgm_base.cpp:556
PGM_KICAD extends PGM_BASE to bring in FileHistory() and PdfBrowser() which were moved from EDA_APP i...
Definition: pgm_kicad.h:42
bool OnPgmInit()
Definition: kicad.cpp:86
void Destroy()
Definition: kicad.cpp:421
void MacOpenFile(const wxString &aFileName) override
Specific to MacOSX (not used under Linux or Windows).
Definition: kicad.cpp:408
void OnPgmExit()
Definition: kicad.cpp:386
APP_SETTINGS_BASE * PgmSettings()
Definition: pgm_kicad.h:59
int OnPgmRun()
Definition: kicad.cpp:380
BIN_MOD m_bm
Definition: pgm_kicad.h:72
Container for project specific data.
Definition: project.h:65
Look for files in a number of paths.
Definition: search_stack.h:43
void AddPaths(const wxString &aPaths, int aIndex=-1)
Insert or append path(s).
T * RegisterSettings(T *aSettings, bool aLoadNow=true)
Take ownership of the pointer passed in.
void SetKiway(KIWAY *aKiway)
Associate this setting manager with the given Kiway.
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:194
This file is part of the common library.
#define _(s)
Functions related to environment variables, including help functions.
FRAME_T
The set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:33
@ FRAME_PCB_EDITOR
Definition: frame_type.h:42
@ FRAME_CALC
Definition: frame_type.h:63
@ FRAME_BM2CMP
Definition: frame_type.h:61
@ FRAME_SCH
Definition: frame_type.h:34
@ FRAME_T_COUNT
Definition: frame_type.h:70
@ FRAME_PL_EDITOR
Definition: frame_type.h:59
@ FRAME_FOOTPRINT_EDITOR
Definition: frame_type.h:43
@ FRAME_GERBER
Definition: frame_type.h:57
@ KICAD_MAIN_FRAME_T
Definition: frame_type.h:68
static const std::string ProjectFileExtension
static const std::string LegacyProjectFileExtension
const wxChar *const kicadTraceKeyEvent
Flag to enable wxKeyEvent debug tracing.
std::map< wxString, ENV_VAR_ITEM >::const_iterator ENV_VAR_MAP_CITER
PGM_KICAD & PgmTop()
Definition: kicad.cpp:80
PROJECT & Prj()
Definition: kicad.cpp:608
static PGM_KICAD program
Definition: kicad.cpp:78
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
Definition: kicad.cpp:67
KIWAY Kiway(KFCTL_CPP_PROJECT_SUITE)
#define KFCTL_CPP_PROJECT_SUITE
Running under C++ project mgr, possibly with others.
Definition: kiway.h:161
#define KFCTL_STANDALONE
Running as a standalone Top.
Definition: kiway.h:160
This file contains miscellaneous commonly used macros and functions.
KICOMMON_API std::optional< wxString > GetVersionedEnvVarValue(const std::map< wxString, ENV_VAR_ITEM > &aMap, const wxString &aBaseName)
Attempt to retrieve the value of a versioned environment variable, such as KICAD8_TEMPLATE_DIR.
Definition: env_vars.cpp:86
bool Init()
Perform application-specific initialization tasks.
Definition: unix/app.cpp:40
void Init()
Perform environment initialization tasks.
void SetAppDetailsForWindow(wxWindow *aWindow, const wxString &aRelaunchCommand, const wxString &aRelaunchDisplayName)
Sets the relaunch command for taskbar pins, this is intended for Windows.
void SetPgm(PGM_BASE *pgm)
Definition: pgm_base.cpp:916
PGM_BASE & Pgm()
The global program "get" accessor.
Definition: pgm_base.cpp:902
KIWAY Kiway(KFCTL_STANDALONE)
Not publicly visible because most of the action is in PGM_KICAD these days.
Definition: kicad.cpp:450
int OnRun() override
Definition: kicad.cpp:503
APP_KICAD()
Definition: kicad.cpp:451
bool OnInit() override
Definition: kicad.cpp:460
int OnExit() override
Definition: kicad.cpp:493
int FilterEvent(wxEvent &aEvent) override
Definition: kicad.cpp:517
void End()
Definition: bin_mod.cpp:50
void Init()
Definition: bin_mod.cpp:38
SEARCH_STACK m_search
Definition: bin_mod.h:60
void InitSettings(APP_SETTINGS_BASE *aPtr)
Takes ownership of a new application settings object.
Definition: bin_mod.h:53
void SystemDirsAppend(SEARCH_STACK *aSearchStack)
Append system places to aSearchStack in a platform specific way and pertinent to KiCad programs.
System directories search utilities.
VECTOR2I end
wxString dump(const wxArrayString &aArray)
Debug helper for printing wxArrayString contents.
wxLogTrace helper definitions.
Definition of file extensions used in Kicad.