KiCad PCB EDA Suite
PGM_SINGLE_TOP Struct Reference

Struct PGM_SINGLE_TOP implements PGM_BASE with its own OnPgmInit() and OnPgmExit(). More...

Inheritance diagram for PGM_SINGLE_TOP:
PGM_BASE

Public Member Functions

bool OnPgmInit ()
 
void OnPgmExit ()
 
void MacOpenFile (const wxString &aFileName) override
 Function MacOpenFile is specific to MacOSX (not used under Linux or Windows). More...
 
VTBL_ENTRY wxConfigBase * CommonSettings () const
 
VTBL_ENTRY void SetEditorName (const wxString &aFileName)
 
VTBL_ENTRY const wxString & GetEditorName (bool aCanShowFileChooser=true)
 Return the preferred editor name. More...
 
VTBL_ENTRY const wxString AskUserForPreferredEditor (const wxString &aDefaultEditor=wxEmptyString)
 Shows a dialog that instructs the user to select a new preferred editor. More...
 
VTBL_ENTRY bool IsKicadEnvVariableDefined () const
 
VTBL_ENTRY const wxString & GetKicadEnvVariable () const
 
VTBL_ENTRY const wxString & GetExecutablePath () const
 
VTBL_ENTRY wxLocale * GetLocale ()
 
VTBL_ENTRY const wxString & GetPdfBrowserName () const
 
VTBL_ENTRY void SetPdfBrowserName (const wxString &aFileName)
 
VTBL_ENTRY bool UseSystemPdfBrowser () const
 Function UseSystemPdfBrowser returns true if the PDF browser is the default (system) PDF browser and false if the PDF browser is the preferred (selected) browser, else returns false if there is no selected browser. More...
 
VTBL_ENTRY void ForceSystemPdfBrowser (bool aFlg)
 Function ForceSystemPdfBrowser forces the use of system PDF browser, even if a preferred PDF browser is set. More...
 
VTBL_ENTRY bool SetLanguage (bool first_time=false)
 Function SetLanguage sets the dictionary file name for internationalization. More...
 
VTBL_ENTRY void AddMenuLanguageList (wxMenu *MasterMenu)
 Function AddMenuLanguageList creates a menu list for language choice, and add it as submenu to MasterMenu. More...
 
VTBL_ENTRY void SetLanguageIdentifier (int menu_id)
 Function SetLanguageIdentifier sets in .m_language_id member the wxWidgets language identifier Id from the KiCad menu id (internal menu identifier). More...
 
VTBL_ENTRY void SetLanguagePath ()
 
VTBL_ENTRY void ReadPdfBrowserInfos ()
 Function ReadPdfBrowserInfos reads the PDF browser choice from the common configuration. More...
 
VTBL_ENTRY void WritePdfBrowserInfos ()
 Function WritePdfBrowserInfos saves the PDF browser choice to the common configuration. More...
 
VTBL_ENTRY bool SetLocalEnvVariable (const wxString &aName, const wxString &aValue)
 Function SetLocalEnvVariable. More...
 
VTBL_ENTRY void SetLocalEnvVariables (const ENV_VAR_MAP &aEnvVarMap)
 Function SetLocalEnvVariables. More...
 
VTBL_ENTRY const ENV_VAR_MAPGetLocalEnvVariables () const
 
VTBL_ENTRY wxApp & App ()
 Function App returns a bare naked wxApp, which may come from wxPython, SINGLE_TOP, or kicad.exe. More...
 
bool InitPgm ()
 Function initPgm initializes this program (process) in a KiCad standard way, using some generalized techniques. More...
 
void Destroy ()
 
void SaveCommonSettings ()
 Function saveCommonSettings saves the program (process) settings subset which are stored .kicad_common. More...
 

Static Public Attributes

static const wxChar workingDirKey [] = wxT( "WorkingDir" )
 

Protected Member Functions

void loadCommonSettings ()
 Function loadCommonSettings loads the program (process) settings subset which are stored in .kicad_common. More...
 
void setLanguageId (int aId)
 Trap all changes in here, simplifies debugging. More...
 
bool setExecutablePath ()
 Function setExecutablePath finds the path to the executable and stores it in PGM_BASE::m_bin_dir. More...
 

Protected Attributes

wxSingleInstanceChecker * m_pgm_checker
 prevents multiple instances of a program from being run at the same time. More...
 
std::unique_ptr< wxConfigBase > m_common_settings
 Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common. More...
 
wxString m_bin_dir
 full path to this program More...
 
wxString m_kicad_env
 The KICAD system environment variable. More...
 
wxLocale * m_locale
 The current locale. More...
 
int m_language_id
 The current language setting. More...
 
bool m_use_system_pdf_browser
 true to use the selected PDF browser, if exists, or false to use the default More...
 
wxString m_pdf_browser
 The file name of the the program selected for browsing pdf files. More...
 
wxString m_editor_name
 
wxSize m_help_size
 
ENV_VAR_MAP m_local_env_vars
 Local environment variable expansion settings such as KIGITHUB, KISYSMOD, and KISYS3DMOD. More...
 
bool m_show_env_var_dialog
 Flag to indicate if the environment variable overwrite warning dialog should be shown. More...
 

Detailed Description

Struct PGM_SINGLE_TOP implements PGM_BASE with its own OnPgmInit() and OnPgmExit().

Definition at line 62 of file single_top.cpp.

Member Function Documentation

◆ AddMenuLanguageList()

void PGM_BASE::AddMenuLanguageList ( wxMenu *  MasterMenu)
inherited

Function AddMenuLanguageList creates a menu list for language choice, and add it as submenu to MasterMenu.

Parameters
MasterMenuThe main menu. The sub menu list will be accessible from the menu item with id ID_LANGUAGE_CHOICE

Definition at line 815 of file pgm_base.cpp.

816 {
817  wxMenu* menu = NULL;
818  wxMenuItem* item = MasterMenu->FindItem( ID_LANGUAGE_CHOICE );
819 
820  if( item ) // This menu exists, do nothing
821  return;
822 
823  menu = new wxMenu;
824 
825  for( unsigned ii = 0; ii < arrayDim( s_Languages ); ii++ )
826  {
827  wxString label;
828 
829  if( s_Languages[ii].m_DoNotTranslate )
830  label = s_Languages[ii].m_Lang_Label;
831  else
832  label = wxGetTranslation( s_Languages[ii].m_Lang_Label );
833 
834  AddMenuItem( menu, s_Languages[ii].m_KI_Lang_Identifier,
835  label, KiBitmap(s_Languages[ii].m_Lang_Icon ),
836  wxITEM_CHECK );
837  }
838 
839  AddMenuItem( MasterMenu, menu,
841  _( "Set Language" ),
842  _( "Select application language (only for testing)" ),
843  KiBitmap( language_xpm ) );
844 
845  // Set Check mark on current selected language
846  for( unsigned ii = 0; ii < arrayDim( s_Languages ); ii++ )
847  {
848  if( m_language_id == s_Languages[ii].m_WX_Lang_Identifier )
849  menu->Check( s_Languages[ii].m_KI_Lang_Identifier, true );
850  else
851  menu->Check( s_Languages[ii].m_KI_Lang_Identifier, false );
852  }
853 }
wxMenuItem * AddMenuItem(wxMenu *aMenu, int aId, const wxString &aText, const wxBitmap &aImage, wxItemKind aType=wxITEM_NORMAL)
Function AddMenuItem is an inline helper function to create and insert a menu item with an icon into ...
Definition: bitmap.cpp:251
int m_language_id
The current language setting.
Definition: pgm_base.h:380
wxBitmap KiBitmap(BITMAP_DEF aBitmap)
Construct a wxBitmap from a memory record, held in a BITMAP_DEF.
Definition: bitmap.cpp:79
wxString m_Lang_Label
Labels used in menus.
Definition: pgm_base.cpp:110
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:107
static LANGUAGE_DESCR s_Languages[]
Variable s_Languages Note: because this list is not created on the fly, wxTranslation must be called ...
Definition: pgm_base.cpp:123

References AddMenuItem(), arrayDim(), ID_LANGUAGE_CHOICE, KiBitmap(), LANGUAGE_DESCR::m_Lang_Label, PGM_BASE::m_language_id, and s_Languages.

Referenced by preparePreferencesMenu(), CVPCB_MAINFRAME::ReCreateMenuBar(), FOOTPRINT_EDIT_FRAME::ReCreateMenuBar(), PL_EDITOR_FRAME::ReCreateMenuBar(), LIB_EDIT_FRAME::ReCreateMenuBar(), KICAD_MANAGER_FRAME::ReCreateMenuBar(), and GERBVIEW_FRAME::ReCreateMenuBar().

◆ App()

wxApp & PGM_BASE::App ( )
inherited

Function App returns a bare naked wxApp, which may come from wxPython, SINGLE_TOP, or kicad.exe.

Should return what wxGetApp() returns.

Definition at line 185 of file pgm_base.cpp.

186 {
187  wxASSERT( wxTheApp );
188  return *wxTheApp;
189 }

Referenced by WS_DRAW_ITEM_LIST::BuildFullText(), DIALOG_SHIM::DIALOG_SHIM(), PCB_EDIT_FRAME::DoGenFootprintsPositionFile(), PCB_EDIT_FRAME::DoGenFootprintsReport(), PGM_BASE::InitPgm(), PGM_KICAD::MacOpenFile(), MacOpenFile(), and PGM_KICAD::OnPgmInit().

◆ AskUserForPreferredEditor()

const wxString PGM_BASE::AskUserForPreferredEditor ( const wxString &  aDefaultEditor = wxEmptyString)
inherited

Shows a dialog that instructs the user to select a new preferred editor.

Parameters
aDefaultEditorDefault full path for the default editor this dialog should show by default.
Returns
Returns the full path of the editor, or an empty string if no editor was chosen.

Definition at line 237 of file pgm_base.cpp.

238 {
239  // Create a mask representing the executable files in the current platform
240 #ifdef __WINDOWS__
241  wxString mask( _( "Executable file (*.exe)|*.exe" ) );
242 #else
243  wxString mask( _( "Executable file (*)|*" ) );
244 #endif
245 
246  // Extract the path, name and extension from the default editor (even if the editor's
247  // name was empty, this method will succeed and return empty strings).
248  wxString path, name, ext;
249  wxFileName::SplitPath( aDefaultEditor, &path, &name, &ext );
250 
251  // Show the modal editor and return the file chosen (may be empty if the user cancels
252  // the dialog).
253  return EDA_FILE_SELECTOR( _( "Select Preferred Editor" ), path,
254  name, ext, mask,
255  NULL, wxFD_OPEN | wxFD_FILE_MUST_EXIST,
256  true );
257 }
wxString EDA_FILE_SELECTOR(const wxString &aTitle, const wxString &aPath, const wxString &aFileName, const wxString &aExtension, const wxString &aWildcard, wxWindow *aParent, int aStyle, const bool aKeepWorkingDirectory, const wxPoint &aPosition, wxString *aMruPath)
Function EDA_FILE_SELECTOR.
Definition: gestfich.cpp:82
const char * name
Definition: DXF_plotter.cpp:61

References EDA_FILE_SELECTOR(), and name.

Referenced by PGM_BASE::GetEditorName(), and PANEL_COMMON_SETTINGS::OnTextEditorClick().

◆ CommonSettings()

◆ Destroy()

void PGM_BASE::Destroy ( )
inherited

Definition at line 172 of file pgm_base.cpp.

173 {
174  // unlike a normal destructor, this is designed to be called more than once safely:
175  m_common_settings.reset();
176 
177  delete m_pgm_checker;
178  m_pgm_checker = 0;
179 
180  delete m_locale;
181  m_locale = 0;
182 }
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
wxLocale * m_locale
The current locale.
Definition: pgm_base.h:377
wxSingleInstanceChecker * m_pgm_checker
prevents multiple instances of a program from being run at the same time.
Definition: pgm_base.h:364

References PGM_BASE::m_common_settings, PGM_BASE::m_locale, and PGM_BASE::m_pgm_checker.

Referenced by PGM_KICAD::Destroy(), OnPgmExit(), and PGM_BASE::~PGM_BASE().

◆ ForceSystemPdfBrowser()

VTBL_ENTRY void PGM_BASE::ForceSystemPdfBrowser ( bool  aFlg)
inlineinherited

Function ForceSystemPdfBrowser forces the use of system PDF browser, even if a preferred PDF browser is set.

Definition at line 241 of file pgm_base.h.

241 { m_use_system_pdf_browser = aFlg; }
bool m_use_system_pdf_browser
true to use the selected PDF browser, if exists, or false to use the default
Definition: pgm_base.h:383

References PGM_BASE::m_use_system_pdf_browser.

Referenced by PGM_BASE::PGM_BASE(), and PANEL_COMMON_SETTINGS::TransferDataFromWindow().

◆ GetEditorName()

const wxString & PGM_BASE::GetEditorName ( bool  aCanShowFileChooser = true)
inherited

Return the preferred editor name.

Parameters
aCanShowFileChooserIf no editor is currently set and this argument is 'true' then this method will show a file chooser dialog asking for the editor's executable.
Returns
Returns the full path of the editor, or an empty string if no editor has been set.

Definition at line 200 of file pgm_base.cpp.

201 {
202  wxString editorname = m_editor_name;
203 
204  if( !editorname )
205  {
206  if( !wxGetEnv( "EDITOR", &editorname ) )
207  {
208  // If there is no EDITOR variable set, try the desktop default
209 #ifdef __WXMAC__
210  editorname = "/usr/bin/open";
211 #elif __WXX11__
212  editorname = "/usr/bin/xdg-open";
213 #endif
214  }
215  }
216 
217  // If we still don't have an editor name show a dialog asking the user to select one
218  if( !editorname && aCanShowFileChooser )
219  {
220  DisplayInfoMessage( NULL,
221  _( "No default editor found, you must choose it" ) );
222 
223  editorname = AskUserForPreferredEditor();
224  }
225 
226  // If we finally have a new editor name request it to be copied to m_editor_name and
227  // saved to the preferences file.
228  if( !editorname.IsEmpty() )
229  SetEditorName( editorname );
230 
231  // m_editor_name already has the same value that editorname, or empty if no editor was
232  // found/chosen.
233  return m_editor_name;
234 }
VTBL_ENTRY void SetEditorName(const wxString &aFileName)
Definition: pgm_base.cpp:192
VTBL_ENTRY const wxString AskUserForPreferredEditor(const wxString &aDefaultEditor=wxEmptyString)
Shows a dialog that instructs the user to select a new preferred editor.
Definition: pgm_base.cpp:237
wxString m_editor_name
Definition: pgm_base.h:397
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Function DisplayInfoMessage displays an informational message box with aMessage.
Definition: confirm.cpp:276

References PGM_BASE::AskUserForPreferredEditor(), DisplayInfoMessage(), PGM_BASE::m_editor_name, and PGM_BASE::SetEditorName().

Referenced by TREEPROJECT_ITEM::Activate(), DIALOG_CONFIG_EQUFILES::OnEditEquFile(), DIALOG_BOM::OnEditPlugin(), KICAD_MANAGER_FRAME::OnOpenFileInTextEditor(), TREE_PROJECT_FRAME::OnOpenSelectedFileWithTextEditor(), KICAD_MANAGER_FRAME::OnOpenTextEditor(), and GERBVIEW_FRAME::OnShowGerberSourceFile().

◆ GetExecutablePath()

VTBL_ENTRY const wxString& PGM_BASE::GetExecutablePath ( ) const
inlineinherited

◆ GetKicadEnvVariable()

VTBL_ENTRY const wxString& PGM_BASE::GetKicadEnvVariable ( ) const
inlineinherited

Definition at line 216 of file pgm_base.h.

216 { return m_kicad_env; }
wxString m_kicad_env
The KICAD system environment variable.
Definition: pgm_base.h:374

References PGM_BASE::m_kicad_env.

Referenced by FindKicadFile(), and KicadDatasPath().

◆ GetLocale()

VTBL_ENTRY wxLocale* PGM_BASE::GetLocale ( )
inlineinherited

Definition at line 220 of file pgm_base.h.

220 { return m_locale; }
wxLocale * m_locale
The current locale.
Definition: pgm_base.h:377

References PGM_BASE::m_locale.

Referenced by TEMPLATE_FIELDNAME::GetDefaultFieldName(), LIB_TREE_NODE_UNIT::LIB_TREE_NODE_UNIT(), and SearchHelpFileFullPath().

◆ GetLocalEnvVariables()

◆ GetPdfBrowserName()

VTBL_ENTRY const wxString& PGM_BASE::GetPdfBrowserName ( ) const
inlineinherited

Definition at line 222 of file pgm_base.h.

222 { return m_pdf_browser; }
wxString m_pdf_browser
The file name of the the program selected for browsing pdf files.
Definition: pgm_base.h:396

References PGM_BASE::m_pdf_browser.

Referenced by PANEL_COMMON_SETTINGS::OnPDFViewerClick(), OpenPDF(), and PGM_BASE::WritePdfBrowserInfos().

◆ InitPgm()

bool PGM_BASE::InitPgm ( )
inherited

Function initPgm initializes this program (process) in a KiCad standard way, using some generalized techniques.

  • Default paths (help, libs, bin) and configuration file names
  • Language and locale
  • fonts

But nothing relating to DSOs or projects.

Returns
bool - true if success, false if failure and program is to terminate.

Definition at line 260 of file pgm_base.cpp.

261 {
262  wxFileName pgm_name( App().argv[0] );
263 
264  wxConfigBase::DontCreateOnDemand();
265 
266  wxInitAllImageHandlers();
267 
268  m_pgm_checker = new wxSingleInstanceChecker( pgm_name.GetName().Lower() + wxT( "-" ) +
269  wxGetUserId(), GetKicadLockFilePath() );
270 
271  if( m_pgm_checker->IsAnotherRunning() )
272  {
273  wxString quiz = wxString::Format(
274  _( "%s is already running. Continue?" ),
275  GetChars( pgm_name.GetName() )
276  );
277 
278  if( !IsOK( NULL, quiz ) )
279  return false;
280  }
281 
282  // Init KiCad environment
283  // the environment variable KICAD (if exists) gives the kicad path:
284  // something like set KICAD=d:\kicad
285  bool isDefined = wxGetEnv( "KICAD", &m_kicad_env );
286 
287  if( isDefined ) // ensure m_kicad_env ends by "/"
288  {
290 
291  if( !m_kicad_env.IsEmpty() && m_kicad_env.Last() != '/' )
293  }
294 
295  // Init parameters for configuration
296  App().SetVendorName( "KiCad" );
297  App().SetAppName( pgm_name.GetName().Lower() );
298 
299  // Install some image handlers, mainly for help
300  if( wxImage::FindHandler( wxBITMAP_TYPE_PNG ) == NULL )
301  wxImage::AddHandler( new wxPNGHandler );
302 
303  if( wxImage::FindHandler( wxBITMAP_TYPE_GIF ) == NULL )
304  wxImage::AddHandler( new wxGIFHandler );
305 
306  if( wxImage::FindHandler( wxBITMAP_TYPE_JPEG ) == NULL )
307  wxImage::AddHandler( new wxJPEGHandler );
308 
309  wxFileSystem::AddHandler( new wxZipFSHandler );
310 
311  // Analyze the command line & initialize the binary path
313 
314  SetLanguagePath();
315 
316  // OS specific instantiation of wxConfigBase derivative:
318 
319  wxString envVarName = wxT( "KIGITHUB" );
320  ENV_VAR_ITEM envVarItem;
321  wxString envValue;
322  wxFileName tmpFileName;
323 
324  if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
325  {
326  tmpFileName.AssignDir( envValue );
327  envVarItem.SetDefinedExternally( true );
328  }
329  else
330  {
331  envVarItem.SetValue( wxString( wxT( "https://github.com/KiCad" ) ) );
332  envVarItem.SetDefinedExternally( false );
333  }
334 
335  m_local_env_vars[ envVarName ] = envVarItem;
336 
337  wxFileName baseSharePath;
338 #if defined( __WXMSW__ )
339  // Make the paths relative to the executable dir as KiCad might be installed anywhere
340  // It follows the Windows installer paths scheme, where binaries are installed in
341  // PATH/bin and extra files in PATH/share/kicad
342  baseSharePath.AssignDir( m_bin_dir + "\\.." );
343  baseSharePath.Normalize();
344 #else
345  baseSharePath.AssignDir( wxString( wxT( DEFAULT_INSTALL_PATH ) ) );
346 #endif
347 
348 #if !defined( __WXMAC__ )
349  baseSharePath.AppendDir( "share" );
350  baseSharePath.AppendDir( "kicad" );
351 #endif
352 
353  // KISYSMOD
354  envVarName = wxT( "KISYSMOD" );
355 
356  if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
357  {
358  tmpFileName.AssignDir( envValue );
359  envVarItem.SetDefinedExternally( true );
360  }
361  else
362  {
363  tmpFileName = baseSharePath;
364  tmpFileName.AppendDir( "modules" );
365  envVarItem.SetDefinedExternally( false );
366  }
367 
368  envVarItem.SetValue( tmpFileName.GetPath() );
369  m_local_env_vars[ envVarName ] = envVarItem;
370 
371  // KISYS3DMOD
372  envVarName = wxT( "KISYS3DMOD" );
373 
374  if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
375  {
376  tmpFileName.AssignDir( envValue );
377  envVarItem.SetDefinedExternally( true );
378  }
379  else
380  {
381  tmpFileName.AppendDir( "packages3d" );
382  envVarItem.SetDefinedExternally( false );
383  }
384 
385  envVarItem.SetValue( tmpFileName.GetFullPath() );
386  m_local_env_vars[ envVarName ] = envVarItem;
387 
388  // KICAD_TEMPLATE_DIR
389  envVarName = "KICAD_TEMPLATE_DIR";
390 
391  if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
392  {
393  tmpFileName.AssignDir( envValue );
394  envVarItem.SetDefinedExternally( true );
395  }
396  else
397  {
398  // Attempt to find the best default template path.
399  SEARCH_STACK bases;
400  SEARCH_STACK templatePaths;
401 
402  SystemDirsAppend( &bases );
403 
404  for( unsigned i = 0; i < bases.GetCount(); ++i )
405  {
406  wxFileName fn( bases[i], wxEmptyString );
407 
408  // Add KiCad template file path to search path list.
409  fn.AppendDir( "template" );
410 
411  // Only add path if exists and can be read by the user.
412  if( fn.DirExists() && fn.IsDirReadable() )
413  {
414  wxLogTrace( tracePathsAndFiles, "Checking template path '%s' exists",
415  fn.GetPath() );
416  templatePaths.AddPaths( fn.GetPath() );
417  }
418  }
419 
420  if( templatePaths.IsEmpty() )
421  {
422  tmpFileName = baseSharePath;
423  tmpFileName.AppendDir( "template" );
424  }
425  else
426  {
427  // Take the first one. There may be more but this will likely be the best option.
428  tmpFileName.AssignDir( templatePaths[0] );
429  }
430 
431  envVarItem.SetDefinedExternally( false );
432  }
433 
434  envVarItem.SetValue( tmpFileName.GetPath() );
435  m_local_env_vars[ envVarName ] = envVarItem;
436 
437  // KICAD_USER_TEMPLATE_DIR
438  envVarName = "KICAD_USER_TEMPLATE_DIR";
439 
440  if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
441  {
442  tmpFileName.AssignDir( envValue );
443  envVarItem.SetDefinedExternally( true );
444  }
445  else
446  {
447  // Default user template path.
448  tmpFileName = wxStandardPaths::Get().GetDocumentsDir();
449  tmpFileName.AppendDir( "kicad" );
450  tmpFileName.AppendDir( "template" );
451  envVarItem.SetDefinedExternally( false );
452  }
453 
454  envVarItem.SetValue( tmpFileName.GetPath() );
455  m_local_env_vars[ envVarName ] = envVarItem;
456 
457  // KICAD_SYMBOLS
458  envVarName = wxT( "KICAD_SYMBOL_DIR" );
459 
460  if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
461  {
462  tmpFileName.AssignDir( envValue );
463  envVarItem.SetDefinedExternally( true );
464  }
465  else
466  {
467  tmpFileName = baseSharePath;
468  tmpFileName.AppendDir( "library" );
469  envVarItem.SetDefinedExternally( false );
470  }
471 
472  envVarItem.SetValue( tmpFileName.GetPath() );
473  m_local_env_vars[ envVarName ] = envVarItem;
474 
475  ReadPdfBrowserInfos(); // needs m_common_settings
476 
477  // Init user language *before* calling loadCommonSettings, because
478  // env vars could be incorrectly initialized on Linux
479  // (if the value contains some non ASCII7 chars, the env var is not initialized)
480  SetLanguage( true );
481 
483 
484 #ifdef __WXMAC__
485  // Always show filters on Open dialog to be able to choose plugin
486  wxSystemOptions::SetOption( wxOSX_FILEDIALOG_ALWAYS_SHOW_TYPES, 1 );
487 #endif
488 
489  return true;
490 }
void loadCommonSettings()
Function loadCommonSettings loads the program (process) settings subset which are stored in ....
Definition: pgm_base.cpp:535
wxString GetKicadLockFilePath()
Function GetKicadLockFilePath.
Definition: lockfile.cpp:59
#define WIN_STRING_DIR_SEP
Definition: gestfich.h:44
ENV_VAR_MAP m_local_env_vars
Local environment variable expansion settings such as KIGITHUB, KISYSMOD, and KISYS3DMOD.
Definition: pgm_base.h:401
std::unique_ptr< wxConfigBase > GetNewConfig(const wxString &aProgName)
Create a new wxConfig so we can put configuration files in a more proper place for each platform.
Definition: common.cpp:256
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
#define UNIX_STRING_DIR_SEP
Definition: gestfich.h:43
Class ENV_VAR_ITEM.
Definition: pgm_base.h:103
VTBL_ENTRY wxApp & App()
Function App returns a bare naked wxApp, which may come from wxPython, SINGLE_TOP,...
Definition: pgm_base.cpp:185
const wxChar *const tracePathsAndFiles
Flag to enable path and file name debug output.
bool setExecutablePath()
Function setExecutablePath finds the path to the executable and stores it in PGM_BASE::m_bin_dir.
Definition: pgm_base.cpp:493
wxSingleInstanceChecker * m_pgm_checker
prevents multiple instances of a program from being run at the same time.
Definition: pgm_base.h:364
Class SEARCH_STACK looks for files in a number of places.
Definition: search_stack.h:41
#define KICAD_COMMON
Definition: pgm_base.cpp:60
wxString m_kicad_env
The KICAD system environment variable.
Definition: pgm_base.h:374
void SetDefinedExternally(bool aIsDefinedExternally)
Definition: pgm_base.h:115
void SystemDirsAppend(SEARCH_STACK *aSearchStack)
Function SystemDirsAppend appends system places to aSearchStack in a platform specific way,...
VTBL_ENTRY void SetLanguagePath()
Definition: pgm_base.cpp:780
VTBL_ENTRY bool SetLanguage(bool first_time=false)
Function SetLanguage sets the dictionary file name for internationalization.
Definition: pgm_base.cpp:672
wxString m_bin_dir
full path to this program
Definition: pgm_base.h:371
VTBL_ENTRY void ReadPdfBrowserInfos()
Function ReadPdfBrowserInfos reads the PDF browser choice from the common configuration.
Definition: eda_doc.cpp:42
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:100
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
void SetValue(const wxString &aValue)
Definition: pgm_base.h:121
size_t i
Definition: json11.cpp:597
bool IsOK(wxWindow *aParent, const wxString &aMessage)
Function IsOK displays a yes/no dialog with aMessage and returns the user response.
Definition: confirm.cpp:294
void AddPaths(const wxString &aPaths, int aIndex=-1)
Function AddPaths insert or append path(s)

References SEARCH_STACK::AddPaths(), PGM_BASE::App(), Format(), GetChars(), GetKicadLockFilePath(), GetNewConfig(), i, IsOK(), KICAD_COMMON, PGM_BASE::loadCommonSettings(), PGM_BASE::m_bin_dir, PGM_BASE::m_common_settings, PGM_BASE::m_kicad_env, PGM_BASE::m_local_env_vars, PGM_BASE::m_pgm_checker, PGM_BASE::ReadPdfBrowserInfos(), ENV_VAR_ITEM::SetDefinedExternally(), PGM_BASE::setExecutablePath(), PGM_BASE::SetLanguage(), PGM_BASE::SetLanguagePath(), ENV_VAR_ITEM::SetValue(), SystemDirsAppend(), tracePathsAndFiles, UNIX_STRING_DIR_SEP, and WIN_STRING_DIR_SEP.

Referenced by PGM_KICAD::OnPgmInit().

◆ IsKicadEnvVariableDefined()

VTBL_ENTRY bool PGM_BASE::IsKicadEnvVariableDefined ( ) const
inlineinherited

Definition at line 214 of file pgm_base.h.

214 { return !m_kicad_env.IsEmpty(); }
wxString m_kicad_env
The KICAD system environment variable.
Definition: pgm_base.h:374

References PGM_BASE::m_kicad_env.

◆ loadCommonSettings()

void PGM_BASE::loadCommonSettings ( )
protectedinherited

Function loadCommonSettings loads the program (process) settings subset which are stored in .kicad_common.

Definition at line 535 of file pgm_base.cpp.

536 {
537  wxASSERT( m_common_settings );
538 
539  m_help_size.x = 500;
540  m_help_size.y = 400;
541 
542  // This only effect the first time KiCad is run. The user's setting will be used for all
543  // subsequent runs. Menu icons are off by default on OSX and on for all other platforms.
544 #if defined( __WXMAC__ )
545  bool defaultUseIconsInMenus = false;
546 #else
547  bool defaultUseIconsInMenus = true;
548 #endif
549 
551 
552  if( !m_common_settings->HasEntry( USE_ICONS_IN_MENUS_KEY ) )
553  m_common_settings->Write( USE_ICONS_IN_MENUS_KEY, defaultUseIconsInMenus );
554 
555  if( !m_common_settings->HasEntry( ICON_SCALE_KEY )
558  {
559  // 5.0 and earlier saved common settings in each app, and saved hardware antialiasing
560  // options only in pcbnew (which was the only canvas to support them). Since there's
561  // no single right answer to where to pull the common settings from, we might as well
562  // get them along with the hardware antialiasing option from pcbnew.
563  auto pcbnewConfig = GetNewConfig( wxString::FromUTF8( "pcbnew" ) );
564  wxString pcbFrameKey( PCB_EDIT_FRAME_NAME );
565 
566  if( !m_common_settings->HasEntry( ICON_SCALE_KEY ) )
567  {
568  int temp;
569  wxString msg;
570  bool option;
571 
572  pcbnewConfig->Read( "PcbIconScale", &temp, 0 );
573  m_common_settings->Write( ICON_SCALE_KEY, temp );
574 
575  pcbnewConfig->Read( ENBL_MOUSEWHEEL_PAN_KEY, &option, false );
576  m_common_settings->Write( ENBL_MOUSEWHEEL_PAN_KEY, option );
577 
578  pcbnewConfig->Read( ENBL_ZOOM_NO_CENTER_KEY, &option, false );
579  m_common_settings->Write( ENBL_ZOOM_NO_CENTER_KEY, option );
580 
581  pcbnewConfig->Read( ENBL_AUTO_PAN_KEY, &option, true );
582  m_common_settings->Write( ENBL_AUTO_PAN_KEY, option );
583  }
584 
585  if( !m_common_settings->HasEntry( GAL_ANTIALIASING_MODE_KEY ) )
586  {
587  int temp;
588  pcbnewConfig->Read( pcbFrameKey + GAL_DISPLAY_OPTIONS_KEY + GAL_ANTIALIASING_MODE_KEY,
591  }
592 
594  {
595  int temp;
596  pcbnewConfig->Read( pcbFrameKey + GAL_DISPLAY_OPTIONS_KEY + CAIRO_ANTIALIASING_MODE_KEY,
599  }
600  }
601 
602  m_editor_name = m_common_settings->Read( "Editor" );
603 
604  wxString entry, oldPath;
605  wxArrayString entries;
606  long index = 0L;
607 
608  oldPath = m_common_settings->GetPath();
610 
611  while( m_common_settings->GetNextEntry( entry, index ) )
612  {
613  wxLogTrace( traceEnvVars,
614  "Enumerating over entry %s, %ld.", GetChars( entry ), index );
615 
616  // Do not store the env var PROJECT_VAR_NAME ("KIPRJMOD") definition if for some reason
617  // it is found in config. (It is reserved and defined as project path)
618  if( entry == PROJECT_VAR_NAME )
619  continue;
620 
621  entries.Add( entry );
622  }
623 
624  for( unsigned i = 0; i < entries.GetCount(); i++ )
625  {
626  wxString val = m_common_settings->Read( entries[i], wxEmptyString );
627 
628  if( m_local_env_vars[ entries[i] ].GetDefinedExternally() )
629  continue;
630 
631  m_local_env_vars[ entries[i] ] = ENV_VAR_ITEM( val, wxGetEnv( entries[i], NULL ) );
632  }
633 
634  for( ENV_VAR_MAP_ITER it = m_local_env_vars.begin(); it != m_local_env_vars.end(); ++it )
635  {
636  SetLocalEnvVariable( it->first, it->second.GetValue() );
637  }
638 
639  m_common_settings->SetPath( oldPath );
640 }
static const wxChar pathEnvVariables[]
Definition: pgm_base.cpp:67
ENV_VAR_MAP m_local_env_vars
Local environment variable expansion settings such as KIGITHUB, KISYSMOD, and KISYS3DMOD.
Definition: pgm_base.h:401
std::unique_ptr< wxConfigBase > GetNewConfig(const wxString &aProgName)
Create a new wxConfig so we can put configuration files in a more proper place for each platform.
Definition: common.cpp:256
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
Class ENV_VAR_ITEM.
Definition: pgm_base.h:103
static const wxChar showEnvVarWarningDialog[]
Definition: pgm_base.cpp:68
#define PROJECT_VAR_NAME
A variable name whose value holds the current project directory.
Definition: project.h:37
static const wxChar traceEnvVars[]
Definition: pgm_base.cpp:69
bool m_show_env_var_dialog
Flag to indicate if the environment variable overwrite warning dialog should be shown.
Definition: pgm_base.h:404
#define ENBL_ZOOM_NO_CENTER_KEY
Definition: pgm_base.h:49
#define PCB_EDIT_FRAME_NAME
Definition: draw_frame.h:57
#define GAL_DISPLAY_OPTIONS_KEY
Definition: pgm_base.h:54
#define ENBL_AUTO_PAN_KEY
Definition: pgm_base.h:52
VTBL_ENTRY bool SetLocalEnvVariable(const wxString &aName, const wxString &aValue)
Function SetLocalEnvVariable.
Definition: pgm_base.cpp:856
#define ENBL_MOUSEWHEEL_PAN_KEY
Definition: pgm_base.h:50
#define ICON_SCALE_KEY
Definition: pgm_base.h:46
#define GAL_ANTIALIASING_MODE_KEY
Definition: pgm_base.h:55
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:100
wxSize m_help_size
Definition: pgm_base.h:398
size_t i
Definition: json11.cpp:597
#define USE_ICONS_IN_MENUS_KEY
Definition: pgm_base.h:45
#define CAIRO_ANTIALIASING_MODE_KEY
Definition: pgm_base.h:56
wxString m_editor_name
Definition: pgm_base.h:397
std::map< wxString, ENV_VAR_ITEM >::iterator ENV_VAR_MAP_ITER
Definition: pgm_base.h:133

References CAIRO_ANTIALIASING_MODE_KEY, ENBL_AUTO_PAN_KEY, ENBL_MOUSEWHEEL_PAN_KEY, ENBL_ZOOM_NO_CENTER_KEY, GAL_ANTIALIASING_MODE_KEY, GAL_DISPLAY_OPTIONS_KEY, GetChars(), GetNewConfig(), i, ICON_SCALE_KEY, PGM_BASE::m_common_settings, PGM_BASE::m_editor_name, PGM_BASE::m_help_size, PGM_BASE::m_local_env_vars, PGM_BASE::m_show_env_var_dialog, KIGFX::NONE, pathEnvVariables, PCB_EDIT_FRAME_NAME, PROJECT_VAR_NAME, PGM_BASE::SetLocalEnvVariable(), showEnvVarWarningDialog, traceEnvVars, and USE_ICONS_IN_MENUS_KEY.

Referenced by PGM_BASE::InitPgm().

◆ MacOpenFile()

void PGM_SINGLE_TOP::MacOpenFile ( const wxString &  aFileName)
inlineoverridevirtual

Function MacOpenFile is specific to MacOSX (not used under Linux or Windows).

MacOSX requires it for file association.

See also
http://wiki.wxwidgets.org/WxMac-specific_topics

Implements PGM_BASE.

Definition at line 77 of file single_top.cpp.

78  {
79  wxFileName filename( aFileName );
80 
81  if( filename.FileExists() )
82  {
83  #if 0
84  // this pulls in EDA_DRAW_FRAME type info, which we don't want in
85  // the single_top link image.
86  KIWAY_PLAYER* frame = dynamic_cast<KIWAY_PLAYER*>( App().GetTopWindow() );
87  #else
88  KIWAY_PLAYER* frame = (KIWAY_PLAYER*) App().GetTopWindow();
89  #endif
90  if( frame )
91  frame->OpenProjectFiles( std::vector<wxString>( 1, aFileName ) );
92  }
93  }
Class KIWAY_PLAYER is a wxFrame capable of the OpenProjectFiles function, meaning it can load a porti...
Definition: kiway_player.h:127
VTBL_ENTRY wxApp & App()
Function App returns a bare naked wxApp, which may come from wxPython, SINGLE_TOP,...
Definition: pgm_base.cpp:185
VTBL_ENTRY bool OpenProjectFiles(const std::vector< wxString > &aFileList, int aCtl=0)
Function OpenProjectFiles is abstract, and opens a project or set of files given by aFileList.
Definition: kiway_player.h:186

References PGM_BASE::App(), and KIWAY_PLAYER::OpenProjectFiles().

◆ OnPgmExit()

void PGM_SINGLE_TOP::OnPgmExit ( )
inline

Definition at line 66 of file single_top.cpp.

67  {
68  Kiway.OnKiwayEnd();
69 
71 
72  // Destroy everything in PGM_BASE, especially wxSingleInstanceCheckerImpl
73  // earlier than wxApp and earlier than static destruction would.
75  }
void SaveCommonSettings()
Function saveCommonSettings saves the program (process) settings subset which are stored ....
Definition: pgm_base.cpp:643
void Destroy()
Definition: pgm_base.cpp:172
void OnKiwayEnd()
Definition: kiway.cpp:502
KIWAY Kiway

References PGM_BASE::Destroy(), Kiway, KIWAY::OnKiwayEnd(), and PGM_BASE::SaveCommonSettings().

Referenced by APP_SINGLE_TOP::OnExit(), APP_SINGLE_TOP::OnInit(), and APP_SINGLE_TOP::OnRun().

◆ OnPgmInit()

bool PGM_SINGLE_TOP::OnPgmInit ( )

Definition at line 274 of file single_top.cpp.

275 {
276 #if defined(DEBUG)
277  wxString absoluteArgv0 = wxStandardPaths::Get().GetExecutablePath();
278 
279  if( !wxIsAbsolutePath( absoluteArgv0 ) )
280  {
281  wxLogError( wxT( "No meaningful argv[0]" ) );
282  return false;
283  }
284 #endif
285 
286  if( !InitPgm() )
287  return false;
288 
289 #if !defined(BUILD_KIWAY_DLL)
290 
291  // Only bitmap2component and pcb_calculator use this code currently, as they
292  // are not split to use single_top as a link image separate from a *.kiface.
293  // i.e. they are single part link images so don't need to load a *.kiface.
294 
295  // Get the getter, it is statically linked into this binary image.
297 
298  int kiface_version;
299 
300  // Get the KIFACE.
301  KIFACE* kiface = getter( &kiface_version, KIFACE_VERSION, this );
302 
303  // Trick the KIWAY into thinking it loaded a KIFACE, by recording the KIFACE
304  // in the KIWAY. It needs to be there for KIWAY::OnKiwayEnd() anyways.
305  Kiway.set_kiface( KIWAY::KifaceType( TOP_FRAME ), kiface );
306 #endif
307 
308  // Open project or file specified on the command line:
309  int argc = App().argc;
310 
311  int args_offset = 1;
312 
313  FRAME_T appType = TOP_FRAME;
314 
315  const struct
316  {
317  wxString name;
318  FRAME_T type;
319  } frameTypes[] = {
320  { wxT( "pcb" ), FRAME_PCB },
321  { wxT( "fpedit" ), FRAME_PCB_MODULE_EDITOR },
322  { wxT( "" ), FRAME_T_COUNT }
323  };
324 
325  if( argc > 2 )
326  {
327  if( App().argv[1] == "--frame" )
328  {
329  wxString appName = App().argv[2];
330  appType = FRAME_T_COUNT;
331 
332  for( int i = 0; frameTypes[i].type != FRAME_T_COUNT; i++ )
333  {
334  const auto& frame = frameTypes[i];
335  if(frame.name == appName)
336  {
337  appType = frame.type;
338  }
339  }
340  args_offset += 2;
341 
342  if( appType == FRAME_T_COUNT )
343  {
344  wxLogError( wxT( "Unknown frame: %s" ), appName );
345  return false;
346  }
347  }
348  }
349 
350 
351  // Use KIWAY to create a top window, which registers its existence also.
352  // "TOP_FRAME" is a macro that is passed on compiler command line from CMake,
353  // and is one of the types in FRAME_T.
354  KIWAY_PLAYER* frame = Kiway.Player( appType, true );
355 
356  Kiway.SetTop( frame );
357 
358  App().SetTopWindow( frame ); // wxApp gets a face.
359 
360 
361  if( argc > args_offset )
362  {
363  /*
364  gerbview handles multiple project data files, i.e. gerber files on
365  cmd line. Others currently do not, they handle only one. For common
366  code simplicity we simply pass all the arguments in however, each
367  program module can do with them what they want, ignore, complain
368  whatever. We don't establish policy here, as this is a multi-purpose
369  launcher.
370  */
371 
372  std::vector<wxString> argSet;
373 
374  for( int i = args_offset; i < argc; ++i )
375  {
376  argSet.push_back( App().argv[i] );
377  }
378 
379  // special attention to a single argument: argv[1] (==argSet[0])
380  if( argc == args_offset + 1 )
381  {
382  wxFileName argv1( argSet[0] );
383 
384 #if defined(PGM_DATA_FILE_EXT)
385  // PGM_DATA_FILE_EXT, if present, may be different for each compile,
386  // it may come from CMake on the compiler command line, but often does not.
387  // This facillity is mostly useful for those program modules
388  // supporting a single argv[1].
389  if( !argv1.GetExt() )
390  argv1.SetExt( wxT( PGM_DATA_FILE_EXT ) );
391 #endif
392  argv1.MakeAbsolute();
393 
394  argSet[0] = argv1.GetFullPath();
395  }
396 
397  // Use the KIWAY_PLAYER::OpenProjectFiles() API function:
398  if( !frame->OpenProjectFiles( argSet ) )
399  {
400  // OpenProjectFiles() API asks that it report failure to the UI.
401  // Nothing further to say here.
402 
403  // We've already initialized things at this point, but wx won't call OnExit if
404  // we fail out. Call our own cleanup routine here to ensure the relevant resources
405  // are freed at the right time (if they aren't, segfaults will occur).
406  OnPgmExit();
407 
408  // Fail the process startup if the file could not be opened,
409  // although this is an optional choice, one that can be reversed
410  // also in the KIFACE specific OpenProjectFiles() return value.
411  return false;
412  }
413  }
414 
415  frame->Show();
416 
417  return true;
418 }
Class KIWAY_PLAYER is a wxFrame capable of the OpenProjectFiles function, meaning it can load a porti...
Definition: kiway_player.h:127
static FACE_T KifaceType(FRAME_T aFrameType)
Function KifaceType is a simple mapping function which returns the FACE_T which is known to implement...
Definition: kiway.cpp:271
void OnPgmExit()
Definition: single_top.cpp:66
#define KIFACE_VERSION
Definition: kiway.h:111
FRAME_T
Enum FRAME_T is the set of EDA_BASE_FRAME derivatives, typically stored in EDA_BASE_FRAME::m_Ident.
Definition: frame_type.h:34
VTBL_ENTRY wxApp & App()
Function App returns a bare naked wxApp, which may come from wxPython, SINGLE_TOP,...
Definition: pgm_base.cpp:185
VTBL_ENTRY bool OpenProjectFiles(const std::vector< wxString > &aFileList, int aCtl=0)
Function OpenProjectFiles is abstract, and opens a project or set of files given by aFileList.
Definition: kiway_player.h:186
bool set_kiface(FACE_T aFaceType, KIFACE *aKiface)
Definition: kiway.h:396
VTBL_ENTRY KIWAY_PLAYER * Player(FRAME_T aFrameType, bool doCreate=true, wxTopLevelWindow *aParent=NULL)
Function Player returns the KIWAY_PLAYER* given a FRAME_T.
Definition: kiway.cpp:321
KIFACE * KIFACE_GETTER(int *aKIFACEversion, int aKIWAYversion, PGM_BASE *aProgram)
No name mangling. Each KIFACE (DSO/DLL) will implement this once.
KIFACE * KIFACE_GETTER_FUNC(int *aKIFACEversion, int aKIWAYversion, PGM_BASE *aProgram)
Function Pointer KIFACE_GETTER_FUNC points to the one and only KIFACE export.
Definition: kiway.h:452
void SetTop(wxFrame *aTop)
Function SetTop tells this KIWAY about the top most frame in the program and optionally allows it to ...
Definition: kiway.cpp:77
const char * name
Definition: DXF_plotter.cpp:61
size_t i
Definition: json11.cpp:597
Class KIFACE is used by a participant in the KIWAY alchemy.
Definition: kiway.h:151
bool InitPgm()
Function initPgm initializes this program (process) in a KiCad standard way, using some generalized t...
Definition: pgm_base.cpp:260
return & kiface
Definition: pcbnew.cpp:212
KIWAY Kiway

References FRAME_PCB, FRAME_PCB_MODULE_EDITOR, FRAME_T_COUNT, PGM_BASE::GetExecutablePath(), i, kiface, KIFACE_GETTER(), KIFACE_VERSION, KIWAY::KifaceType(), Kiway, name, KIWAY_PLAYER::OpenProjectFiles(), KIWAY::Player(), KIWAY::set_kiface(), and KIWAY::SetTop().

Referenced by APP_SINGLE_TOP::OnInit().

◆ ReadPdfBrowserInfos()

void PGM_BASE::ReadPdfBrowserInfos ( )
inherited

Function ReadPdfBrowserInfos reads the PDF browser choice from the common configuration.

Definition at line 42 of file eda_doc.cpp.

43 {
44  wxASSERT( m_common_settings );
45 
46  wxString browser = m_common_settings->Read( wxT( "PdfBrowserName" ), wxEmptyString );
47  SetPdfBrowserName( browser );
48 
49  int tmp;
50  m_common_settings->Read( wxT( "UseSystemBrowser" ), &tmp, 0 );
51  m_use_system_pdf_browser = bool( tmp );
52 }
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
bool m_use_system_pdf_browser
true to use the selected PDF browser, if exists, or false to use the default
Definition: pgm_base.h:383
VTBL_ENTRY void SetPdfBrowserName(const wxString &aFileName)
Definition: pgm_base.h:224

References PGM_BASE::m_common_settings, PGM_BASE::m_use_system_pdf_browser, and PGM_BASE::SetPdfBrowserName().

Referenced by PGM_BASE::InitPgm(), PANEL_COMMON_SETTINGS::OnPDFViewerClick(), and OpenPDF().

◆ SaveCommonSettings()

void PGM_BASE::SaveCommonSettings ( )
inherited

Function saveCommonSettings saves the program (process) settings subset which are stored .kicad_common.

Definition at line 643 of file pgm_base.cpp.

644 {
645  // m_common_settings is not initialized until fairly late in the
646  // process startup: InitPgm(), so test before using:
647  if( m_common_settings )
648  {
649  wxString cur_dir = wxGetCwd();
650 
651  m_common_settings->Write( workingDirKey, cur_dir );
653 
654  // Save the local environment variables.
656 
657  for( ENV_VAR_MAP_ITER it = m_local_env_vars.begin(); it != m_local_env_vars.end(); ++it )
658  {
659  if( it->second.GetDefinedExternally() )
660  continue;
661 
662  wxLogTrace( traceEnvVars, "Saving environment variable config entry %s as %s",
663  GetChars( it->first ), GetChars( it->second.GetValue() ) );
664  m_common_settings->Write( it->first, it->second.GetValue() );
665  }
666 
667  m_common_settings->SetPath( ".." );
668  }
669 }
static const wxChar pathEnvVariables[]
Definition: pgm_base.cpp:67
ENV_VAR_MAP m_local_env_vars
Local environment variable expansion settings such as KIGITHUB, KISYSMOD, and KISYS3DMOD.
Definition: pgm_base.h:401
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
static const wxChar workingDirKey[]
Definition: pgm_base.h:329
static const wxChar showEnvVarWarningDialog[]
Definition: pgm_base.cpp:68
static const wxChar traceEnvVars[]
Definition: pgm_base.cpp:69
bool m_show_env_var_dialog
Flag to indicate if the environment variable overwrite warning dialog should be shown.
Definition: pgm_base.h:404
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:100
std::map< wxString, ENV_VAR_ITEM >::iterator ENV_VAR_MAP_ITER
Definition: pgm_base.h:133

References GetChars(), PGM_BASE::m_common_settings, PGM_BASE::m_local_env_vars, PGM_BASE::m_show_env_var_dialog, pathEnvVariables, showEnvVarWarningDialog, traceEnvVars, and PGM_BASE::workingDirKey.

Referenced by PGM_KICAD::OnPgmExit(), OnPgmExit(), and PGM_BASE::SetLocalEnvVariables().

◆ SetEditorName()

void PGM_BASE::SetEditorName ( const wxString &  aFileName)
inherited

Definition at line 192 of file pgm_base.cpp.

193 {
194  m_editor_name = aFileName;
195  wxASSERT( m_common_settings );
196  m_common_settings->Write( "Editor", aFileName );
197 }
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
wxString m_editor_name
Definition: pgm_base.h:397

References PGM_BASE::m_common_settings, and PGM_BASE::m_editor_name.

Referenced by PGM_BASE::GetEditorName(), and PANEL_COMMON_SETTINGS::TransferDataFromWindow().

◆ setExecutablePath()

bool PGM_BASE::setExecutablePath ( )
protectedinherited

Function setExecutablePath finds the path to the executable and stores it in PGM_BASE::m_bin_dir.

Returns
bool - true if success, else false.

Definition at line 493 of file pgm_base.cpp.

494 {
495  m_bin_dir = wxStandardPaths::Get().GetExecutablePath();
496 
497 #ifdef __WXMAC__
498  // On OSX Pgm().GetExecutablePath() will always point to main
499  // bundle directory, e.g., /Applications/kicad.app/
500 
501  wxFileName fn( m_bin_dir );
502 
503  if( fn.GetName() == wxT( "kicad" ) )
504  {
505  // kicad launcher, so just remove the Contents/MacOS part
506  fn.RemoveLastDir();
507  fn.RemoveLastDir();
508  }
509  else
510  {
511  // standalone binaries live in Contents/Applications/<standalone>.app/Contents/MacOS
512  fn.RemoveLastDir();
513  fn.RemoveLastDir();
514  fn.RemoveLastDir();
515  fn.RemoveLastDir();
516  fn.RemoveLastDir();
517  }
518 
519  m_bin_dir = fn.GetPath() + wxT( "/" );
520 #else
521  // Use unix notation for paths. I am not sure this is a good idea,
522  // but it simplifies compatibility between Windows and Unices.
523  // However it is a potential problem in path handling under Windows.
525 
526  // Remove file name form command line:
527  while( m_bin_dir.Last() != '/' && !m_bin_dir.IsEmpty() )
528  m_bin_dir.RemoveLast();
529 #endif
530 
531  return true;
532 }
#define WIN_STRING_DIR_SEP
Definition: gestfich.h:44
#define UNIX_STRING_DIR_SEP
Definition: gestfich.h:43
wxString m_bin_dir
full path to this program
Definition: pgm_base.h:371

References PGM_BASE::m_bin_dir, UNIX_STRING_DIR_SEP, and WIN_STRING_DIR_SEP.

Referenced by PGM_BASE::InitPgm().

◆ SetLanguage()

bool PGM_BASE::SetLanguage ( bool  first_time = false)
inherited

Function SetLanguage sets the dictionary file name for internationalization.

The files are in kicad/internat/xx or kicad/internat/xx_XX and are named kicad.mo

Parameters
first_timemust be set to true the first time this funct is called, false otherwise
Returns
true if the language can be set (i.e. if the locale is available)

Definition at line 672 of file pgm_base.cpp.

673 {
674  bool retv = true;
675 
676  if( first_time )
677  {
678  setLanguageId( wxLANGUAGE_DEFAULT );
679  // First time SetLanguage is called, the user selected language id is set
680  // from commun user config settings
681  wxString languageSel;
682 
683  m_common_settings->Read( languageCfgKey, &languageSel );
684 
685  // Search for the current selection
686  for( unsigned ii = 0; ii < arrayDim( s_Languages ); ii++ )
687  {
688  if( s_Languages[ii].m_Lang_Label == languageSel )
689  {
690  setLanguageId( s_Languages[ii].m_WX_Lang_Identifier );
691  break;
692  }
693  }
694  }
695 
696  // dictionary file name without extend (full name is kicad.mo)
697  wxString dictionaryName( "kicad" );
698 
699  delete m_locale;
700  m_locale = new wxLocale;
701 
702  if( !m_locale->Init( m_language_id ) )
703  {
704  wxLogTrace( traceLocale, "This language is not supported by the system." );
705 
706  setLanguageId( wxLANGUAGE_DEFAULT );
707  delete m_locale;
708 
709  m_locale = new wxLocale;
710  m_locale->Init();
711  retv = false;
712  }
713  else if( !first_time )
714  {
715  wxLogTrace( traceLocale, "Search for dictionary %s.mo in %s",
716  GetChars( dictionaryName ), GetChars( m_locale->GetName() ) );
717  }
718 
719  if( !first_time )
720  {
721  // If we are here, the user has selected another language.
722  // Therefore the new prefered language name is stored in common config.
723  // Do NOT store the wxWidgets language Id, it can change between wxWidgets
724  // versions, for a given language
725  wxString languageSel;
726 
727  // Search for the current selection language name
728  for( unsigned ii = 0; ii < arrayDim( s_Languages ); ii++ )
729  {
730  if( s_Languages[ii].m_WX_Lang_Identifier == m_language_id )
731  {
732  languageSel = s_Languages[ii].m_Lang_Label;
733  break;
734  }
735  }
736 
737  m_common_settings->Write( languageCfgKey, languageSel );
738  }
739 
740  // Test if floating point notation is working (bug encountered in cross compilation)
741  // Make a conversion double <=> string
742  double dtst = 0.5;
743  wxString msg;
744 
745  msg << dtst;
746  double result;
747  msg.ToDouble( &result );
748 
749  if( result != dtst )
750  // string to double encode/decode does not work! Bug detected:
751  // Disable floating point localization:
752  setlocale( LC_NUMERIC, "C" );
753 
754  if( !m_locale->IsLoaded( dictionaryName ) )
755  m_locale->AddCatalog( dictionaryName );
756 
757  if( !retv )
758  return retv;
759 
760  return m_locale->IsOk();
761 }
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
wxLocale * m_locale
The current locale.
Definition: pgm_base.h:377
int m_language_id
The current language setting.
Definition: pgm_base.h:380
void setLanguageId(int aId)
Trap all changes in here, simplifies debugging.
Definition: pgm_base.h:386
const wxChar *const traceLocale
Flag to enable locale debug output.
wxString m_Lang_Label
Labels used in menus.
Definition: pgm_base.cpp:110
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:107
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:100
static const wxChar languageCfgKey[]
Definition: pgm_base.cpp:66
static LANGUAGE_DESCR s_Languages[]
Variable s_Languages Note: because this list is not created on the fly, wxTranslation must be called ...
Definition: pgm_base.cpp:123

References arrayDim(), GetChars(), languageCfgKey, PGM_BASE::m_common_settings, LANGUAGE_DESCR::m_Lang_Label, PGM_BASE::m_language_id, PGM_BASE::m_locale, s_Languages, PGM_BASE::setLanguageId(), and traceLocale.

Referenced by PGM_BASE::InitPgm(), and KIWAY::SetLanguage().

◆ setLanguageId()

void PGM_BASE::setLanguageId ( int  aId)
inlineprotectedinherited

Trap all changes in here, simplifies debugging.

Definition at line 386 of file pgm_base.h.

386 { m_language_id = aId; }
int m_language_id
The current language setting.
Definition: pgm_base.h:380

References PGM_BASE::m_language_id.

Referenced by PGM_BASE::PGM_BASE(), PGM_BASE::SetLanguage(), and PGM_BASE::SetLanguageIdentifier().

◆ SetLanguageIdentifier()

void PGM_BASE::SetLanguageIdentifier ( int  menu_id)
inherited

Function SetLanguageIdentifier sets in .m_language_id member the wxWidgets language identifier Id from the KiCad menu id (internal menu identifier).

Parameters
menu_idThe KiCad menuitem id (returned by Menu Event, when clicking on a menu item)

Definition at line 764 of file pgm_base.cpp.

765 {
766  wxLogTrace( traceLocale, "Select language ID %d from %d possible languages.",
767  menu_id, (int)arrayDim( s_Languages ) );
768 
769  for( unsigned ii = 0; ii < arrayDim( s_Languages ); ii++ )
770  {
771  if( menu_id == s_Languages[ii].m_KI_Lang_Identifier )
772  {
773  setLanguageId( s_Languages[ii].m_WX_Lang_Identifier );
774  break;
775  }
776  }
777 }
void setLanguageId(int aId)
Trap all changes in here, simplifies debugging.
Definition: pgm_base.h:386
const wxChar *const traceLocale
Flag to enable locale debug output.
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:107
static LANGUAGE_DESCR s_Languages[]
Variable s_Languages Note: because this list is not created on the fly, wxTranslation must be called ...
Definition: pgm_base.cpp:123

References arrayDim(), s_Languages, PGM_BASE::setLanguageId(), and traceLocale.

Referenced by KIWAY::SetLanguage().

◆ SetLanguagePath()

void PGM_BASE::SetLanguagePath ( )
inherited

Definition at line 780 of file pgm_base.cpp.

781 {
782  SEARCH_STACK guesses;
783 
784  SystemDirsAppend( &guesses );
785 
786  // Add our internat dir to the wxLocale catalog of paths
787  for( unsigned i = 0; i < guesses.GetCount(); i++ )
788  {
789  wxFileName fn( guesses[i], wxEmptyString );
790 
791  // Append path for Windows and unix KiCad package install
792  fn.AppendDir( "share" );
793  fn.AppendDir( "internat" );
794 
795  if( fn.IsDirReadable() )
796  {
797  wxLogTrace( traceLocale, "Adding locale lookup path: " + fn.GetPath() );
798  wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
799  }
800 
801  // Append path for unix standard install
802  fn.RemoveLastDir();
803  fn.AppendDir( "kicad" );
804  fn.AppendDir( "internat" );
805 
806  if( fn.IsDirReadable() )
807  {
808  wxLogTrace( traceLocale, "Adding locale lookup path: " + fn.GetPath() );
809  wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
810  }
811  }
812 }
Class SEARCH_STACK looks for files in a number of places.
Definition: search_stack.h:41
void SystemDirsAppend(SEARCH_STACK *aSearchStack)
Function SystemDirsAppend appends system places to aSearchStack in a platform specific way,...
const wxChar *const traceLocale
Flag to enable locale debug output.
size_t i
Definition: json11.cpp:597

References i, SystemDirsAppend(), and traceLocale.

Referenced by PGM_BASE::InitPgm().

◆ SetLocalEnvVariable()

bool PGM_BASE::SetLocalEnvVariable ( const wxString &  aName,
const wxString &  aValue 
)
inherited

Function SetLocalEnvVariable.

Sets the environment variable aName to aValue.

This function first checks to see if the environment variable aName is already defined. If it is not defined, then the environment variable aName is set to a value. Otherwise, the environment variable is left unchanged. This allows the user to override environment variables for testing purposes.

Parameters
aNameis a wxString containing the environment variable name.
aValueis a wxString containing the environment variable value.
Returns
true if the environment variable Name was set to aValue.

Definition at line 856 of file pgm_base.cpp.

857 {
858  wxString env;
859 
860  // Check to see if the environment variable is already set.
861  if( wxGetEnv( aName, &env ) )
862  {
863  wxLogTrace( traceEnvVars, "Environment variable %s already set to %s.",
864  GetChars( aName ), GetChars( env ) );
865  return env == aValue;
866  }
867 
868  wxLogTrace( traceEnvVars, "Setting local environment variable %s to %s.",
869  GetChars( aName ), GetChars( aValue ) );
870 
871  return wxSetEnv( aName, aValue );
872 }
static const wxChar traceEnvVars[]
Definition: pgm_base.cpp:69
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:100

References GetChars(), and traceEnvVars.

Referenced by PGM_BASE::loadCommonSettings().

◆ SetLocalEnvVariables()

void PGM_BASE::SetLocalEnvVariables ( const ENV_VAR_MAP aEnvVarMap)
inherited

Function SetLocalEnvVariables.

sets the internal local environment variable map to aEnvVarMap, updates the entries in the .kicad_common configuration file, and sets the environment variable to the new settings.

Parameters
aEnvVarMapis a ENV_VAR_MAP object containing the new environment variables.

Definition at line 875 of file pgm_base.cpp.

876 {
877  m_local_env_vars.clear();
878  m_local_env_vars = aEnvVarMap;
879 
880  if( m_common_settings )
881  m_common_settings->DeleteGroup( pathEnvVariables );
882 
884 
885  // Overwrites externally defined environment variable until the next time the application
886  // is run.
887  for( ENV_VAR_MAP_ITER it = m_local_env_vars.begin(); it != m_local_env_vars.end(); ++it )
888  {
889  wxLogTrace( traceEnvVars, "Setting local environment variable %s to %s.",
890  GetChars( it->first ), GetChars( it->second.GetValue() ) );
891  wxSetEnv( it->first, it->second.GetValue() );
892  }
893 }
static const wxChar pathEnvVariables[]
Definition: pgm_base.cpp:67
ENV_VAR_MAP m_local_env_vars
Local environment variable expansion settings such as KIGITHUB, KISYSMOD, and KISYS3DMOD.
Definition: pgm_base.h:401
void SaveCommonSettings()
Function saveCommonSettings saves the program (process) settings subset which are stored ....
Definition: pgm_base.cpp:643
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
static const wxChar traceEnvVars[]
Definition: pgm_base.cpp:69
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:100
std::map< wxString, ENV_VAR_ITEM >::iterator ENV_VAR_MAP_ITER
Definition: pgm_base.h:133

References GetChars(), PGM_BASE::m_common_settings, PGM_BASE::m_local_env_vars, pathEnvVariables, PGM_BASE::SaveCommonSettings(), and traceEnvVars.

Referenced by DIALOG_CONFIGURE_PATHS::TransferDataFromWindow().

◆ SetPdfBrowserName()

VTBL_ENTRY void PGM_BASE::SetPdfBrowserName ( const wxString &  aFileName)
inlineinherited

Definition at line 224 of file pgm_base.h.

224 { m_pdf_browser = aFileName; }
wxString m_pdf_browser
The file name of the the program selected for browsing pdf files.
Definition: pgm_base.h:396

References PGM_BASE::m_pdf_browser.

Referenced by PGM_BASE::ReadPdfBrowserInfos(), and PANEL_COMMON_SETTINGS::TransferDataFromWindow().

◆ UseSystemPdfBrowser()

VTBL_ENTRY bool PGM_BASE::UseSystemPdfBrowser ( ) const
inlineinherited

Function UseSystemPdfBrowser returns true if the PDF browser is the default (system) PDF browser and false if the PDF browser is the preferred (selected) browser, else returns false if there is no selected browser.

Definition at line 232 of file pgm_base.h.

233  {
234  return m_use_system_pdf_browser || m_pdf_browser.IsEmpty();
235  }
bool m_use_system_pdf_browser
true to use the selected PDF browser, if exists, or false to use the default
Definition: pgm_base.h:383
wxString m_pdf_browser
The file name of the the program selected for browsing pdf files.
Definition: pgm_base.h:396

References PGM_BASE::m_pdf_browser, and PGM_BASE::m_use_system_pdf_browser.

◆ WritePdfBrowserInfos()

void PGM_BASE::WritePdfBrowserInfos ( )
inherited

Function WritePdfBrowserInfos saves the PDF browser choice to the common configuration.

Definition at line 55 of file eda_doc.cpp.

56 {
57  wxASSERT( m_common_settings );
58 
59  m_common_settings->Write( wxT( "PdfBrowserName" ), GetPdfBrowserName() );
60  m_common_settings->Write( wxT( "UseSystemBrowser" ), m_use_system_pdf_browser );
61 }
std::unique_ptr< wxConfigBase > m_common_settings
Configuration settings common to all KiCad program modules, like as in $HOME/.kicad_common.
Definition: pgm_base.h:368
bool m_use_system_pdf_browser
true to use the selected PDF browser, if exists, or false to use the default
Definition: pgm_base.h:383
VTBL_ENTRY const wxString & GetPdfBrowserName() const
Definition: pgm_base.h:222

References PGM_BASE::GetPdfBrowserName(), PGM_BASE::m_common_settings, and PGM_BASE::m_use_system_pdf_browser.

Referenced by PANEL_COMMON_SETTINGS::TransferDataFromWindow().

Member Data Documentation

◆ m_bin_dir

wxString PGM_BASE::m_bin_dir
protectedinherited

full path to this program

Definition at line 371 of file pgm_base.h.

Referenced by PGM_BASE::GetExecutablePath(), PGM_BASE::InitPgm(), and PGM_BASE::setExecutablePath().

◆ m_common_settings

std::unique_ptr<wxConfigBase> PGM_BASE::m_common_settings
protectedinherited

◆ m_editor_name

wxString PGM_BASE::m_editor_name
protectedinherited

◆ m_help_size

wxSize PGM_BASE::m_help_size
protectedinherited

Definition at line 398 of file pgm_base.h.

Referenced by PGM_BASE::loadCommonSettings().

◆ m_kicad_env

wxString PGM_BASE::m_kicad_env
protectedinherited

The KICAD system environment variable.

Definition at line 374 of file pgm_base.h.

Referenced by PGM_BASE::GetKicadEnvVariable(), PGM_BASE::InitPgm(), and PGM_BASE::IsKicadEnvVariableDefined().

◆ m_language_id

int PGM_BASE::m_language_id
protectedinherited

The current language setting.

Definition at line 380 of file pgm_base.h.

Referenced by PGM_BASE::AddMenuLanguageList(), PGM_BASE::SetLanguage(), and PGM_BASE::setLanguageId().

◆ m_local_env_vars

ENV_VAR_MAP PGM_BASE::m_local_env_vars
protectedinherited

Local environment variable expansion settings such as KIGITHUB, KISYSMOD, and KISYS3DMOD.

Definition at line 401 of file pgm_base.h.

Referenced by PGM_BASE::GetLocalEnvVariables(), PGM_BASE::InitPgm(), PGM_BASE::loadCommonSettings(), PGM_BASE::SaveCommonSettings(), and PGM_BASE::SetLocalEnvVariables().

◆ m_locale

wxLocale* PGM_BASE::m_locale
protectedinherited

The current locale.

Definition at line 377 of file pgm_base.h.

Referenced by PGM_BASE::Destroy(), PGM_BASE::GetLocale(), PGM_BASE::PGM_BASE(), and PGM_BASE::SetLanguage().

◆ m_pdf_browser

wxString PGM_BASE::m_pdf_browser
protectedinherited

The file name of the the program selected for browsing pdf files.

Definition at line 396 of file pgm_base.h.

Referenced by PGM_BASE::GetPdfBrowserName(), PGM_BASE::SetPdfBrowserName(), and PGM_BASE::UseSystemPdfBrowser().

◆ m_pgm_checker

wxSingleInstanceChecker* PGM_BASE::m_pgm_checker
protectedinherited

prevents multiple instances of a program from being run at the same time.

Definition at line 364 of file pgm_base.h.

Referenced by PGM_BASE::Destroy(), PGM_BASE::InitPgm(), and PGM_BASE::PGM_BASE().

◆ m_show_env_var_dialog

bool PGM_BASE::m_show_env_var_dialog
protectedinherited

Flag to indicate if the environment variable overwrite warning dialog should be shown.

Definition at line 404 of file pgm_base.h.

Referenced by PGM_BASE::loadCommonSettings(), PGM_BASE::PGM_BASE(), and PGM_BASE::SaveCommonSettings().

◆ m_use_system_pdf_browser

bool PGM_BASE::m_use_system_pdf_browser
protectedinherited

true to use the selected PDF browser, if exists, or false to use the default

Definition at line 383 of file pgm_base.h.

Referenced by PGM_BASE::ForceSystemPdfBrowser(), PGM_BASE::ReadPdfBrowserInfos(), PGM_BASE::UseSystemPdfBrowser(), and PGM_BASE::WritePdfBrowserInfos().

◆ workingDirKey

const wxChar PGM_BASE::workingDirKey = wxT( "WorkingDir" )
staticinherited

Definition at line 329 of file pgm_base.h.

Referenced by PGM_BASE::SaveCommonSettings().


The documentation for this struct was generated from the following file: