haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/common/pgm_base.cpp

818 lines
26 KiB
C++
Raw Normal View History

* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
Make show/hide icons in menus a run time option, instead of compil option.
2017-03-02 13:46:18 +00:00
* Copyright (C) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
* Copyright (C) 2008 Wayne Stambaugh <stambaughw@gmail.com>
Language selection: do not disallow switching to English language when the English dictionnary is missing. It is not mandatory because all messages are in English, just restricted to ASCII7 chars Fixes #6261 https://gitlab.com/kicad/code/kicad/issues/6261
2020-11-03 10:47:28 +00:00
* Copyright (C) 1992-2020 KiCad Developers, see AUTHORS.txt for contributors.
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, you may find one here:
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
* or you may search the http://www.gnu.org website for the version 2 license,
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
/**
merge tip in, resolve.
2014-03-20 06:24:33 +00:00
* @file pgm_base.cpp
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
*
* @brief For the main application: init functions, and language selection
* (locale handling)
*/
#include <wx/html/htmlwin.h>
#include <wx/fs_zip.h>
#include <wx/dir.h>
#include <wx/filename.h>
#include <wx/snglinst.h>
#include <wx/stdpaths.h>
Enable file extension filters on OSX file dialog.
2015-02-22 22:48:33 +00:00
#include <wx/sysopt.h>
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
#include <wx/richmsgdlg.h>
Avoid include wx/wx.h in many files that do not actually use this include. Including wx.h includes the full set of wxWidgets include files, that is not good, and can create some conflicts with some Windows headers on msys2.
2020-10-18 11:31:07 +00:00
#include <wx/filedlg.h>
Adjust Windows tooltip display time While most platforms keep the tooltips if the mouse doesn't move, MSW will hide the tooltip after 5 seconds (by default). This bumps that up to 10s for all tooltips in the program. Fixes https://gitlab.com/kicad/code/kicad/issues/6836
2021-01-08 18:07:45 +00:00
#include <wx/tooltip.h>
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
#include <build_version.h>
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
#include <config_params.h>
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
#include <confirm.h>
Split out arrayDim and MIRROR templates from macros.h These were not macros
2020-11-18 01:21:04 +00:00
#include <core/arraydim.h>
Move dialog_configure_paths.h and dialog_edit_library_tables.h to dialogs folder
2020-10-25 13:36:19 +00:00
#include <dialogs/dialog_configure_paths.h>
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
#include <eda_base_frame.h>
#include <eda_draw_frame.h>
#include <gal/gal_display_options.h>
#include <gestfich.h>
#include <hotkeys_basic.h>
#include <id.h>
Start trying to shuffle around path management
2021-01-23 02:23:37 +00:00
#include <kiplatform/environment.h>
Move file locking utilities to a separate file The global ::LockFile() function is used in a single place, but it's in common.h, so visible to all files. The GetKicadLockFilePath function is used in only two places, and one of them is LockFile. This commit puts them both in a separate header, so they're only visible to code using them. The implementation of GetKicadLockFilePath is moved to lockfile.cpp, where LockFile already was. Also removed a (large) handful of wxT macros, which aren't needed any more and make code less readable.
2017-02-09 08:09:28 +00:00
#include <lockfile.h>
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
#include <macros.h>
#include <menus_helpers.h>
Start trying to shuffle around path management
2021-01-23 02:23:37 +00:00
#include <paths.h>
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
#include <pgm_base.h>
#include <settings/common_settings.h>
#include <settings/settings_manager.h>
Move SystemDirsAppend to own header This function is called only from three sites, it doesn't need to be in common.h. The implementation was already in systemdirsappend.cpp, so a matching header was created for it. This reduces the visibility of the function to only the files that need it and slightly shrinks common.h.
2017-02-09 08:25:33 +00:00
#include <systemdirsappend.h>
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
#include <trace_helpers.h>
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
/**
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
* Current list of languages supported by KiCad.
*
* @note Because this list is not created on the fly, wxTranslation
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
* must be called when a language name must be displayed after translation.
* Do not change this behavior, because m_Lang_Label is also used as key in config
*/
Implement I18N for ACTIONs. It's a bit of a hack because they're statically initialized and so we can't make use of the _() macro. We do still want it in the code, however, because the string harvesting is based off of it. Fixes: lp:1833000 * https://bugs.launchpad.net/kicad/+bug/1833000
2019-06-17 00:34:21 +00:00
#undef _
#define _(s) s
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
LANGUAGE_DESCR LanguagesList[] =
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Remove flags icons and abandoned languages Flags != language See http://www.flagsarenotlanguages.com We now use local, untranslated language names for all languages. Languages that have not been updated in >5 years and have less than 15% of available strings translated have been removed from the menu options. If a translator steps up to update the .po files, we can re-add them
2020-08-18 12:01:56 +00:00
{ wxLANGUAGE_DEFAULT, ID_LANGUAGE_DEFAULT, _( "Default" ), false },
Update Lanugage list with new contributions
2021-01-06 22:23:59 +00:00
{ wxLANGUAGE_CATALAN, ID_LANGUAGE_CATALAN, wxT( "Català" ), true },
{ wxLANGUAGE_CZECH, ID_LANGUAGE_CZECH, wxT( "Čeština" ), true },
{ wxLANGUAGE_DANISH, ID_LANGUAGE_DANISH, wxT( "Dansk" ), true },
{ wxLANGUAGE_GERMAN, ID_LANGUAGE_GERMAN, wxT( "Deutsch" ), true },
{ wxLANGUAGE_GREEK, ID_LANGUAGE_GREEK, wxT( "Ελληνικά" ), true },
Set launguage selection to be untranslated Users should see their language option presented in their own language, not the current language being used on the system.
2020-08-18 12:30:46 +00:00
{ wxLANGUAGE_ENGLISH, ID_LANGUAGE_ENGLISH, wxT( "English" ), true },
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
{ wxLANGUAGE_SPANISH, ID_LANGUAGE_SPANISH, wxT( "Español" ), true },
Update Lanugage list with new contributions
2021-01-06 22:23:59 +00:00
{ wxLANGUAGE_FRENCH, ID_LANGUAGE_FRENCH, wxT( "Français" ), true },
{ wxLANGUAGE_INDONESIAN, ID_LANGUAGE_INDONESIAN, wxT( "Indonesia" ), true },
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
{ wxLANGUAGE_ITALIAN, ID_LANGUAGE_ITALIAN, wxT( "Italiano" ), true },
Update Lanugage list with new contributions
2021-01-06 22:23:59 +00:00
{ wxLANGUAGE_LITHUANIAN, ID_LANGUAGE_LITHUANIAN, wxT( "Lietuvių" ), true },
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
{ wxLANGUAGE_HUNGARIAN, ID_LANGUAGE_HUNGARIAN, wxT( "Magyar" ), true },
Update Lanugage list with new contributions
2021-01-06 22:23:59 +00:00
{ wxLANGUAGE_JAPANESE, ID_LANGUAGE_JAPANESE, wxT( "日本語" ), true },
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
{ wxLANGUAGE_POLISH, ID_LANGUAGE_POLISH, wxT( "Polski" ), true },
Update Lanugage list with new contributions
2021-01-06 22:23:59 +00:00
{ wxLANGUAGE_PORTUGUESE, ID_LANGUAGE_PORTUGUESE, wxT( "Português" ),true },
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
{ wxLANGUAGE_RUSSIAN, ID_LANGUAGE_RUSSIAN, wxT( "Русский" ), true },
Move Serbian po Updates the Serbian language code from sr_RS to sr. This appears to work as intended under Debian whereas the full code, despite existing in the i18n directory was not recognized by wxWidgets or Weblate.
2021-03-05 17:19:58 +00:00
{ wxLANGUAGE_SERBIAN, ID_LANGUAGE_SERBIAN, wxT( "Српски"), true },
Update Lanugage list with new contributions
2021-01-06 22:23:59 +00:00
{ wxLANGUAGE_FINNISH, ID_LANGUAGE_FINNISH, wxT( "Suomalainen" ), true },
{ wxLANGUAGE_VIETNAMESE, ID_LANGUAGE_VIETNAMESE, wxT( "Tiếng việt" ), true },
{ wxLANGUAGE_TURKISH, ID_LANGUAGE_TURKISH, wxT( "Türk" ), true },
Remove flags icons and abandoned languages Flags != language See http://www.flagsarenotlanguages.com We now use local, untranslated language names for all languages. Languages that have not been updated in >5 years and have less than 15% of available strings translated have been removed from the menu options. If a translator steps up to update the .po files, we can re-add them
2020-08-18 12:01:56 +00:00
{ wxLANGUAGE_CHINESE_SIMPLIFIED, ID_LANGUAGE_CHINESE_SIMPLIFIED,
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
wxT( "简体中文" ), true },
Remove flags icons and abandoned languages Flags != language See http://www.flagsarenotlanguages.com We now use local, untranslated language names for all languages. Languages that have not been updated in >5 years and have less than 15% of available strings translated have been removed from the menu options. If a translator steps up to update the .po files, we can re-add them
2020-08-18 12:01:56 +00:00
{ wxLANGUAGE_CHINESE_TRADITIONAL, ID_LANGUAGE_CHINESE_TRADITIONAL,
Set launguage selection to be untranslated Users should see their language option presented in their own language, not the current language being used on the system.
2020-08-18 12:30:46 +00:00
wxT( "繁體中文" ), false },
Remove flags icons and abandoned languages Flags != language See http://www.flagsarenotlanguages.com We now use local, untranslated language names for all languages. Languages that have not been updated in >5 years and have less than 15% of available strings translated have been removed from the menu options. If a translator steps up to update the .po files, we can re-add them
2020-08-18 12:01:56 +00:00
{ 0, 0, "", false } // Sentinel
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
};
Implement I18N for ACTIONs. It's a bit of a hack because they're statically initialized and so we can't make use of the _() macro. We do still want it in the code, however, because the string harvesting is based off of it. Fixes: lp:1833000 * https://bugs.launchpad.net/kicad/+bug/1833000
2019-06-17 00:34:21 +00:00
#undef _
#define _(s) wxGetTranslation((s))
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
PGM_BASE::PGM_BASE()
{
m_pgm_checker = NULL;
m_locale = NULL;
Add some defensive code to prevent re-entrant printing. Fixes: lp:1765965 * https://bugs.launchpad.net/kicad/+bug/1765965
2019-08-13 16:59:43 +00:00
m_Printing = false;
Once more into the depths of hell... er, I mean fix a focus issue. So the new steals-focus protection stuff works well when there's a focused control, but not as well when there's a modal dialog up which happens not to have a focused control (or worse, a focusable control). This adds a second mechanism for also checking to see if a modal dialog is up (something that wxWidgets, true to form, makes very difficult). Fixes https://gitlab.com/kicad/code/kicad/issues/6520
2020-11-26 15:43:48 +00:00
m_ModalDialogCount = 0;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
m_show_env_var_dialog = true;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
setLanguageId( wxLANGUAGE_DEFAULT );
merge tip in, resolve.
2014-03-20 06:24:33 +00:00
ForceSystemPdfBrowser( false );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
PGM_BASE::~PGM_BASE()
{
SWIG Improvements *) Extend SWIG support deeper into the BOARD class. *) Move swig *.i files into a directory identified for SWIG, in preparation for a parallel universe involving Phoenix's SIP. *) Move swig files which will be common to both eeschema and pcbnew into common/swig. *) Sketch out a "common" python module, and plan on dovetailing that into a libkicad_shared.{dll,so} *) Add common/swig/ki_exceptions.i and define a macro HANDLE_EXCEPTIONS() which is to be applied to any function which needs C++ to python exception translation. *) Move the test for SWIG tool into top level CMakeLists.txt file for use in all python modules beyond pcbnew, i.e. eeschema and common. *) Add SWIG_MODULE_pcbnew_EXTRA_DEPS which generates a better Makefile, one which rebuilds the swig generated *.cxx file when one of its dependencies change. *) Re-architect the board.i file so that it can be split into multiple *.i files easily. *) Make some KIWAY from python progress, in preparation for Modular KiCad phase III.
2016-09-20 15:59:43 +00:00
Destroy();
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
SWIG Improvements *) Extend SWIG support deeper into the BOARD class. *) Move swig *.i files into a directory identified for SWIG, in preparation for a parallel universe involving Phoenix's SIP. *) Move swig files which will be common to both eeschema and pcbnew into common/swig. *) Sketch out a "common" python module, and plan on dovetailing that into a libkicad_shared.{dll,so} *) Add common/swig/ki_exceptions.i and define a macro HANDLE_EXCEPTIONS() which is to be applied to any function which needs C++ to python exception translation. *) Move the test for SWIG tool into top level CMakeLists.txt file for use in all python modules beyond pcbnew, i.e. eeschema and common. *) Add SWIG_MODULE_pcbnew_EXTRA_DEPS which generates a better Makefile, one which rebuilds the swig generated *.cxx file when one of its dependencies change. *) Re-architect the board.i file so that it can be split into multiple *.i files easily. *) Make some KIWAY from python progress, in preparation for Modular KiCad phase III.
2016-09-20 15:59:43 +00:00
void PGM_BASE::Destroy()
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
// unlike a normal destructor, this is designed to be called more than once safely:
delete m_pgm_checker;
m_pgm_checker = 0;
delete m_locale;
m_locale = 0;
}
SWIG Improvements *) Extend SWIG support deeper into the BOARD class. *) Move swig *.i files into a directory identified for SWIG, in preparation for a parallel universe involving Phoenix's SIP. *) Move swig files which will be common to both eeschema and pcbnew into common/swig. *) Sketch out a "common" python module, and plan on dovetailing that into a libkicad_shared.{dll,so} *) Add common/swig/ki_exceptions.i and define a macro HANDLE_EXCEPTIONS() which is to be applied to any function which needs C++ to python exception translation. *) Move the test for SWIG tool into top level CMakeLists.txt file for use in all python modules beyond pcbnew, i.e. eeschema and common. *) Add SWIG_MODULE_pcbnew_EXTRA_DEPS which generates a better Makefile, one which rebuilds the swig generated *.cxx file when one of its dependencies change. *) Re-architect the board.i file so that it can be split into multiple *.i files easily. *) Make some KIWAY from python progress, in preparation for Modular KiCad phase III.
2016-09-20 15:59:43 +00:00
wxApp& PGM_BASE::App()
{
wxASSERT( wxTheApp );
return *wxTheApp;
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
void PGM_BASE::SetEditorName( const wxString& aFileName )
{
m_editor_name = aFileName;
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
wxASSERT( GetCommonSettings() );
GetCommonSettings()->m_System.editor_name = aFileName;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
const wxString& PGM_BASE::GetEditorName( bool aCanShowFileChooser )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
wxString editorname = m_editor_name;
if( !editorname )
{
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
if( !wxGetEnv( "EDITOR", &editorname ) )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
// If there is no EDITOR variable set, try the desktop default
#ifdef __WXMAC__
editorname = "/usr/bin/open";
#elif __WXX11__
editorname = "/usr/bin/xdg-open";
#endif
}
}
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
// If we still don't have an editor name show a dialog asking the user to select one
if( !editorname && aCanShowFileChooser )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Use app display name in messages to user. Fixes https://gitlab.com/kicad/code/kicad/issues/8038
2021-03-28 12:04:25 +00:00
DisplayInfoMessage( NULL, _( "No default editor found, you must choose it" ) );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
editorname = AskUserForPreferredEditor();
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
// If we finally have a new editor name request it to be copied to m_editor_name and
// saved to the preferences file.
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
if( !editorname.IsEmpty() )
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
SetEditorName( editorname );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
// m_editor_name already has the same value that editorname, or empty if no editor was
// found/chosen.
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
return m_editor_name;
}
Fix an issue in LOCALE_IO class, used to switch to/back locale "C" when reading/writing files: the back to locale was broken, and created issues in countries using the ',' as fp separator, especially when the non default language was used. It was reported in many bugs.
2016-05-10 07:11:09 +00:00
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
const wxString PGM_BASE::AskUserForPreferredEditor( const wxString& aDefaultEditor )
{
// Create a mask representing the executable files in the current platform
#ifdef __WINDOWS__
wxString mask( _( "Executable file (*.exe)|*.exe" ) );
#else
wxString mask( _( "Executable file (*)|*" ) );
#endif
// Extract the path, name and extension from the default editor (even if the editor's
// name was empty, this method will succeed and return empty strings).
wxString path, name, ext;
wxFileName::SplitPath( aDefaultEditor, &path, &name, &ext );
// Show the modal editor and return the file chosen (may be empty if the user cancels
// the dialog).
Use app display name in messages to user. Fixes https://gitlab.com/kicad/code/kicad/issues/8038
2021-03-28 12:04:25 +00:00
return EDA_FILE_SELECTOR( _( "Select Preferred Editor" ), path, name, ext, mask, NULL,
wxFD_OPEN | wxFD_FILE_MUST_EXIST, true );
Fix Preferred Editor dialog (lp: 1558353) The functions involved in the problem were PGM_BASE::GetEditorName and EDA_BASE_FRAME::OnSelectPreferredEditor: 1) OnSelectPreferredEditor showed a dialog to allow the user selecting the editor, but before that called GetEditorName to get the name of the current editor (to show as a default in the choose file dialog). 2) The problem was when there was no editor, GetEditorName showed its own dialog. 3) So the user was seeing first the dialog from (2) and then the dialog from (1). 4) As GetEditorName is used in many other places the solution I did was to add to it an optional parameter that tells it what to do if no editor is set. To avoid modifying other code that relies on the current behaviour, this parameter has a default value that causes to show the dialog. But now when OnSelectPreferredEditor calls it, it passes the parameter that causes it to return an empty string if no editor was set. 5) Also, I found a second bug while doing it which allowed in the first dialog to select an unexistent file (the dialog was missing the wxFD_FILE_MUST_EXIST flag). 6) Lastly, to avoid having duplicated code (the one that showed the same dialog and that configured the wildcard was in two methods) I created a single function that now both functions call: PGM_BASE::AskUserForPreferredEditor. This way we also will have consistency in the behaviour of both dialogs and there is a single place where it needs to be modified.
2016-03-17 20:59:35 +00:00
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
SWIG Improvements *) Extend SWIG support deeper into the BOARD class. *) Move swig *.i files into a directory identified for SWIG, in preparation for a parallel universe involving Phoenix's SIP. *) Move swig files which will be common to both eeschema and pcbnew into common/swig. *) Sketch out a "common" python module, and plan on dovetailing that into a libkicad_shared.{dll,so} *) Add common/swig/ki_exceptions.i and define a macro HANDLE_EXCEPTIONS() which is to be applied to any function which needs C++ to python exception translation. *) Move the test for SWIG tool into top level CMakeLists.txt file for use in all python modules beyond pcbnew, i.e. eeschema and common. *) Add SWIG_MODULE_pcbnew_EXTRA_DEPS which generates a better Makefile, one which rebuilds the swig generated *.cxx file when one of its dependencies change. *) Re-architect the board.i file so that it can be split into multiple *.i files easily. *) Make some KIWAY from python progress, in preparation for Modular KiCad phase III.
2016-09-20 15:59:43 +00:00
bool PGM_BASE::InitPgm()
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
wxFileName pgm_name( App().argv[0] );
wxInitAllImageHandlers();
Protect against invalid HOME variable Fixes https://gitlab.com/kicad/code/kicad/issues/6990
2021-01-07 23:13:34 +00:00
#ifndef __WINDOWS__
if( wxString( wxGetenv( "HOME" ) ).IsEmpty() )
{
Use app display name in messages to user. Fixes https://gitlab.com/kicad/code/kicad/issues/8038
2021-03-28 12:04:25 +00:00
DisplayErrorMessage( nullptr, _( "Environment variable HOME is empty. "
"Unable to continue." ) );
Protect against invalid HOME variable Fixes https://gitlab.com/kicad/code/kicad/issues/6990
2021-01-07 23:13:34 +00:00
return false;
}
#endif
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
m_pgm_checker = new wxSingleInstanceChecker( pgm_name.GetName().Lower() + wxT( "-" ) +
wxGetUserId(), GetKicadLockFilePath() );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
if( m_pgm_checker->IsAnotherRunning() )
{
Use app display name in messages to user. Fixes https://gitlab.com/kicad/code/kicad/issues/8038
2021-03-28 12:04:25 +00:00
if( !IsOK( NULL, wxString::Format( _( "%s is already running. Continue?" ),
App().GetAppDisplayName() ) ) )
{
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
return false;
Use app display name in messages to user. Fixes https://gitlab.com/kicad/code/kicad/issues/8038
2021-03-28 12:04:25 +00:00
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
// Init KiCad environment
// the environment variable KICAD (if exists) gives the kicad path:
// something like set KICAD=d:\kicad
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
bool isDefined = wxGetEnv( "KICAD", &m_kicad_env );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
if( isDefined ) // ensure m_kicad_env ends by "/"
{
m_kicad_env.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
if( !m_kicad_env.IsEmpty() && m_kicad_env.Last() != '/' )
m_kicad_env += UNIX_STRING_DIR_SEP;
}
// Init parameters for configuration
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
App().SetVendorName( "KiCad" );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
App().SetAppName( pgm_name.GetName().Lower() );
// Install some image handlers, mainly for help
Minor fixes and code cleaning. * Check to see if image handler is already initialized to prevent warning on debug builds. * Change LIB_PART destructor message output to use wxLogDebug for debugging on windows builds. * Minor code cleaning and coding policy fixes.
2015-01-27 18:40:52 +00:00
if( wxImage::FindHandler( wxBITMAP_TYPE_PNG ) == NULL )
wxImage::AddHandler( new wxPNGHandler );
if( wxImage::FindHandler( wxBITMAP_TYPE_GIF ) == NULL )
wxImage::AddHandler( new wxGIFHandler );
if( wxImage::FindHandler( wxBITMAP_TYPE_JPEG ) == NULL )
wxImage::AddHandler( new wxJPEGHandler );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
wxFileSystem::AddHandler( new wxZipFSHandler );
// Analyze the command line & initialize the binary path
Initialize translation dictionary to default Initializes the dictionary before potential messages are shown on the screen. Fixes https://gitlab.com/kicad/code/kicad/issues/7076
2021-01-12 21:03:17 +00:00
wxString tmp;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
setExecutablePath();
SetLanguagePath();
Initialize translation dictionary to default Initializes the dictionary before potential messages are shown on the screen. Fixes https://gitlab.com/kicad/code/kicad/issues/7076
2021-01-12 21:03:17 +00:00
SetDefaultLanguage( tmp );
m_settings_manager = std::make_unique<SETTINGS_MANAGER>();
// Something got in the way of settings load: can't continue
if( !m_settings_manager->IsOK() )
return false;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
wxFileName baseSharePath;
Allow to relocate EDA libraries out of KICAD_DATA Introduce a new advanced config variable `KICAD_LIBRARY_DATA` which can be used to move templates, symbols, footprints, and 3dmodels out of `KICAD_DATA`. If not defined, everything is kept as before. To facilitate this, PATHS::GetStockEDALibraryPath() is added. This allows to differentiate code paths looking for EDA library data vs. code paths looking for plugins, demos, and the like. Thanks to Aimylios for the hints and suggestions with regards to the stock EDA library data path handling on Windows and MacOS.
2021-03-29 13:37:11 +00:00
baseSharePath.AssignDir( PATHS::GetStockEDALibraryPath() );
Default KISYSMOD and KISYS3DMOD path fixes. (fixes lp:1455472)
2015-07-21 00:46:58 +00:00
Change environmental variables to human-readable Versions specific variables that may point to objects that change through versions, allowing multiple KiCad versions to operate correctly (even on MSW) on the same machine.
2020-12-31 21:22:44 +00:00
// KICAD6_FOOTPRINT_DIR
wxString envVarName = wxT( "KICAD6_FOOTPRINT_DIR" );
Remove GITHUB plugins KiCad github downloads are no longer supported Fixes https://gitlab.com/kicad/code/kicad/issues/6182
2020-10-29 23:43:34 +00:00
ENV_VAR_ITEM envVarItem;
wxString envValue;
wxFileName tmpFileName;
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
{
tmpFileName.AssignDir( envValue );
envVarItem.SetDefinedExternally( true );
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Found entry %s externally", envVarName );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
}
else
{
tmpFileName = baseSharePath;
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
tmpFileName.AppendDir( "modules" );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
envVarItem.SetDefinedExternally( false );
}
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
Symbol library table remapping fixes. Use GetPath() instead of GetFullPath() when initializing environment variable table entries KICAD_SYMBOL_DIR and KICAD_PTEMPALTE due to unexpected trailing path separator which was causing find libraries by URI to fail. Don't create a project symbol library table when there are no libraries not found in the global symbol library table. Don't add non-existent libraries to project symbol library table. Clear symbol library table when loading a new schematic. Minor remapping status message improvements.
2017-09-06 13:21:50 +00:00
envVarItem.SetValue( tmpFileName.GetPath() );
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Setting entry %s = %s",
envVarName, envVarItem.GetValue() );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
m_local_env_vars[ envVarName ] = envVarItem;
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
Change environmental variables to human-readable Versions specific variables that may point to objects that change through versions, allowing multiple KiCad versions to operate correctly (even on MSW) on the same machine.
2020-12-31 21:22:44 +00:00
// KICAD6_3DMODEL_DIR
envVarName = wxT( "KICAD6_3DMODEL_DIR" );
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
{
tmpFileName.AssignDir( envValue );
envVarItem.SetDefinedExternally( true );
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Found entry %s externally", envVarName );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
}
else
{
Move default model location to 3dmodels
2020-10-14 18:01:02 +00:00
tmpFileName = baseSharePath;
tmpFileName.AppendDir( "3dmodels" );
Fix external check for KISYS3DMOD environment variable. Fixes lp:1782708 https://bugs.launchpad.net/kicad/+bug/1782708
2018-07-23 16:47:13 +00:00
envVarItem.SetDefinedExternally( false );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
}
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
envVarItem.SetValue( tmpFileName.GetFullPath() );
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Setting entry %s = %s",
envVarName, envVarItem.GetValue() );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
m_local_env_vars[ envVarName ] = envVarItem;
Default KISYSMOD and KISYS3DMOD path fixes. (fixes lp:1455472)
2015-07-21 00:46:58 +00:00
Change environmental variables to human-readable Versions specific variables that may point to objects that change through versions, allowing multiple KiCad versions to operate correctly (even on MSW) on the same machine.
2020-12-31 21:22:44 +00:00
// KICAD6_TEMPLATE_DIR
envVarName = "KICAD6_TEMPLATE_DIR";
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
{
tmpFileName.AssignDir( envValue );
envVarItem.SetDefinedExternally( true );
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Found entry %s externally", envVarName );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
}
else
{
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
// Attempt to find the best default template path.
SEARCH_STACK bases;
SEARCH_STACK templatePaths;
SystemDirsAppend( &bases );
for( unsigned i = 0; i < bases.GetCount(); ++i )
{
wxFileName fn( bases[i], wxEmptyString );
// Add KiCad template file path to search path list.
fn.AppendDir( "template" );
// Only add path if exists and can be read by the user.
if( fn.DirExists() && fn.IsDirReadable() )
{
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
wxLogTrace( tracePathsAndFiles, "Checking template path '%s' exists",
fn.GetPath() );
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
templatePaths.AddPaths( fn.GetPath() );
}
}
if( templatePaths.IsEmpty() )
{
tmpFileName = baseSharePath;
tmpFileName.AppendDir( "template" );
}
else
{
// Take the first one. There may be more but this will likely be the best option.
tmpFileName.AssignDir( templatePaths[0] );
}
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
envVarItem.SetDefinedExternally( false );
}
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
envVarItem.SetValue( tmpFileName.GetPath() );
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Setting entry %s = %s", envVarName,
envVarItem.GetValue() );
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
m_local_env_vars[ envVarName ] = envVarItem;
// KICAD_USER_TEMPLATE_DIR
envVarName = "KICAD_USER_TEMPLATE_DIR";
if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
{
tmpFileName.AssignDir( envValue );
envVarItem.SetDefinedExternally( true );
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Found entry %s externally", envVarName );
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
}
else
{
// Default user template path.
Start trying to shuffle around path management
2021-01-23 02:23:37 +00:00
tmpFileName.AssignDir( PATHS::GetUserTemplatesPath() );
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
envVarItem.SetDefinedExternally( false );
}
Symbol library table remapping fixes. Use GetPath() instead of GetFullPath() when initializing environment variable table entries KICAD_SYMBOL_DIR and KICAD_PTEMPALTE due to unexpected trailing path separator which was causing find libraries by URI to fail. Don't create a project symbol library table when there are no libraries not found in the global symbol library table. Don't add non-existent libraries to project symbol library table. Clear symbol library table when loading a new schematic. Minor remapping status message improvements.
2017-09-06 13:21:50 +00:00
envVarItem.SetValue( tmpFileName.GetPath() );
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Setting entry %s = %s",
envVarName, envVarItem.GetValue() );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
m_local_env_vars[ envVarName ] = envVarItem;
Initial symbol library table implementation prep work. Add loading symbol library table code to schematic PROJECT object. Fix minor issues with loading global symbol library table. Add default symbol library path environment variable to the environment variable list and change the variable name to KICAD_SYMBOL_DIR. Add code to SCH_SCREENS to test if all library nicknames of the symbol library IDs are empty. Remove unnecessary KICAD_USE_SCH_IO_MANAGER build option.
2017-03-05 22:31:31 +00:00
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
// KICAD_SYMBOLS
Change environmental variables to human-readable Versions specific variables that may point to objects that change through versions, allowing multiple KiCad versions to operate correctly (even on MSW) on the same machine.
2020-12-31 21:22:44 +00:00
envVarName = wxT( "KICAD6_SYMBOL_DIR" );
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
if( wxGetEnv( envVarName, &envValue ) == true && !envValue.IsEmpty() )
{
tmpFileName.AssignDir( envValue );
envVarItem.SetDefinedExternally( true );
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Found entry %s externally", envVarName );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
}
else
{
tmpFileName = baseSharePath;
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
tmpFileName.AppendDir( "library" );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
envVarItem.SetDefinedExternally( false );
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
}
Fix template path bugs. Remove KICAD_PTEMPLATE environment variable as it's purpose was not clear and was often poorly defined as the path to the KiCad installed templates. Add a new KICAD_TEMPLATE_DIR environment variable which clearly should be the path of the KiCad installed templates. Make this environment variable available in the user settings in case the default is wrong which has been the case in some instances. Use the standard search stack to set the default system template path which has a much greater chance of being correct. Add a new KICAD_USER_TEMPLATE_DIR environment variable which clearly should be the path of the user defined templates. Users most likely were not even aware of the old default user path unless they read the fine manual. Set template path search stack priority as follows: * KICAD_USER_TEMPLATE_DIR * KICAD_TEMPLATE_DIR * Search stack template paths Reverse template selection dialog and project path dialog for improved user experience. Fixes lp:1543443 https://bugs.launchpad.net/kicad/+bug/1543443
2018-05-19 16:10:08 +00:00
Symbol library table remapping fixes. Use GetPath() instead of GetFullPath() when initializing environment variable table entries KICAD_SYMBOL_DIR and KICAD_PTEMPALTE due to unexpected trailing path separator which was causing find libraries by URI to fail. Don't create a project symbol library table when there are no libraries not found in the global symbol library table. Don't add non-existent libraries to project symbol library table. Clear symbol library table when loading a new schematic. Minor remapping status message improvements.
2017-09-06 13:21:50 +00:00
envVarItem.SetValue( tmpFileName.GetPath() );
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::InitPgm: Setting entry %s = %s",
envVarName, envVarItem.GetValue() );
Eeschema: add symbol library table editor dialog. Create a new dialog to edit global and project specific symbol library tables. Add menu entries for new symbol library table editor in schematic editor and symbol library editor main frame menus. Add command event handler for symbol library table editor dialog to SCH_BASE_FRAME so it is accessible from derived frames. Fix bug in default environment variables initialization. A test for existing user defined environment variables was preventing any new default environment variables added to the list from being initialized.
2017-08-12 12:09:39 +00:00
m_local_env_vars[ envVarName ] = envVarItem;
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
GetSettingsManager().Load( GetCommonSettings() );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
// Init user language *before* calling loadCommonSettings, because
// env vars could be incorrectly initialized on Linux
// (if the value contains some non ASCII7 chars, the env var is not initialized)
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
SetLanguage( tmp, true );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
loadCommonSettings();
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
ReadPdfBrowserInfos(); // needs GetCommonSettings()
Enable file extension filters on OSX file dialog.
2015-02-22 22:48:33 +00:00
#ifdef __WXMAC__
// Always show filters on Open dialog to be able to choose plugin
wxSystemOptions::SetOption( wxOSX_FILEDIALOG_ALWAYS_SHOW_TYPES, 1 );
#endif
Move PROJECT storage to SETTINGS_MANAGER
2020-05-25 17:38:09 +00:00
// TODO(JE): Remove this if apps are refactored to not assume Prj() always works
// Need to create a project early for now (it can have an empty path for the moment)
GetSettingsManager().LoadProject( "" );
Adjust Windows tooltip display time While most platforms keep the tooltips if the mouse doesn't move, MSW will hide the tooltip after 5 seconds (by default). This bumps that up to 10s for all tooltips in the program. Fixes https://gitlab.com/kicad/code/kicad/issues/6836
2021-01-08 18:07:45 +00:00
// TODO: Move tooltips into KIPLATFORM
// This sets the maximum tooltip display duration to 10s (up from 5) but only affects
// Windows as other platforms display tooltips while the mouse is not moving
Forgot a '0' in tool tip commit
2021-01-08 18:27:27 +00:00
wxToolTip::SetAutoPop( 10000 );
Adjust Windows tooltip display time While most platforms keep the tooltips if the mouse doesn't move, MSW will hide the tooltip after 5 seconds (by default). This bumps that up to 10s for all tooltips in the program. Fixes https://gitlab.com/kicad/code/kicad/issues/6836
2021-01-08 18:07:45 +00:00
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
return true;
}
bool PGM_BASE::setExecutablePath()
{
m_bin_dir = wxStandardPaths::Get().GetExecutablePath();
Commit the rest of the OSX build fixes missed in the previous commit.
2014-10-17 17:45:33 +00:00
#ifdef __WXMAC__
// On OSX Pgm().GetExecutablePath() will always point to main
// bundle directory, e.g., /Applications/kicad.app/
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Commit the rest of the OSX build fixes missed in the previous commit.
2014-10-17 17:45:33 +00:00
wxFileName fn( m_bin_dir );
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
Commit the rest of the OSX build fixes missed in the previous commit.
2014-10-17 17:45:33 +00:00
if( fn.GetName() == wxT( "kicad" ) )
{
// kicad launcher, so just remove the Contents/MacOS part
fn.RemoveLastDir();
fn.RemoveLastDir();
}
else
{
// standalone binaries live in Contents/Applications/<standalone>.app/Contents/MacOS
fn.RemoveLastDir();
fn.RemoveLastDir();
fn.RemoveLastDir();
fn.RemoveLastDir();
fn.RemoveLastDir();
}
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
Commit the rest of the OSX build fixes missed in the previous commit.
2014-10-17 17:45:33 +00:00
m_bin_dir = fn.GetPath() + wxT( "/" );
#else
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
// Use unix notation for paths. I am not sure this is a good idea,
// but it simplifies compatibility between Windows and Unices.
// However it is a potential problem in path handling under Windows.
m_bin_dir.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
// Remove file name form command line:
while( m_bin_dir.Last() != '/' && !m_bin_dir.IsEmpty() )
m_bin_dir.RemoveLast();
Commit the rest of the OSX build fixes missed in the previous commit.
2014-10-17 17:45:33 +00:00
#endif
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
return true;
}
void PGM_BASE::loadCommonSettings()
{
m_help_size.x = 500;
m_help_size.y = 400;
Disable icons in menus by default on osx
2017-04-08 10:42:34 +00:00
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
m_show_env_var_dialog = GetCommonSettings()->m_Env.show_warning_dialog;
m_editor_name = GetCommonSettings()->m_System.editor_name;
Unified preferences dialog framework. (cherry picked from commit 8ee3e77)
2018-05-14 17:34:18 +00:00
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
for( const auto& it : GetCommonSettings()->m_Env.vars )
Unified preferences dialog framework. (cherry picked from commit 8ee3e77)
2018-05-14 17:34:18 +00:00
{
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
wxString key( it.first.c_str(), wxConvUTF8 );
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::loadCommonSettings: Found entry %s = %s",
key, it.second );
DIALOG_CONFIGURE_PATHS: do not allow users to define the env var KIPRJMOD It always defines the project path, and should never be defined by users. Fixes: lp:1824912 https://bugs.launchpad.net/kicad/+bug/1824912
2019-04-16 09:41:30 +00:00
// Do not store the env var PROJECT_VAR_NAME ("KIPRJMOD") definition if for some reason
// it is found in config. (It is reserved and defined as project path)
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
if( key == PROJECT_VAR_NAME )
DIALOG_CONFIGURE_PATHS: do not allow users to define the env var KIPRJMOD It always defines the project path, and should never be defined by users. Fixes: lp:1824912 https://bugs.launchpad.net/kicad/+bug/1824912
2019-04-16 09:41:30 +00:00
continue;
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
if( m_local_env_vars[ key ].GetDefinedExternally() )
Don't overwite env vars with settings. Fixes: lp:1740022 * https://bugs.launchpad.net/kicad/+bug/1740022
2018-03-08 19:16:51 +00:00
continue;
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
wxLogTrace( traceEnvVars, "PGM_BASE::loadCommonSettings: Updating entry %s = %s",
key, it.second );
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
m_local_env_vars[ key ] = ENV_VAR_ITEM( it.second, wxGetEnv( it.first, nullptr ) );
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
}
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
for( auto& m_local_env_var : m_local_env_vars )
SetLocalEnvVariable( m_local_env_var.first, m_local_env_var.second.GetValue() );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
SWIG Improvements *) Extend SWIG support deeper into the BOARD class. *) Move swig *.i files into a directory identified for SWIG, in preparation for a parallel universe involving Phoenix's SIP. *) Move swig files which will be common to both eeschema and pcbnew into common/swig. *) Sketch out a "common" python module, and plan on dovetailing that into a libkicad_shared.{dll,so} *) Add common/swig/ki_exceptions.i and define a macro HANDLE_EXCEPTIONS() which is to be applied to any function which needs C++ to python exception translation. *) Move the test for SWIG tool into top level CMakeLists.txt file for use in all python modules beyond pcbnew, i.e. eeschema and common. *) Add SWIG_MODULE_pcbnew_EXTRA_DEPS which generates a better Makefile, one which rebuilds the swig generated *.cxx file when one of its dependencies change. *) Re-architect the board.i file so that it can be split into multiple *.i files easily. *) Make some KIWAY from python progress, in preparation for Modular KiCad phase III.
2016-09-20 15:59:43 +00:00
void PGM_BASE::SaveCommonSettings()
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
// GetCommonSettings() is not initialized until fairly late in the
SWIG Improvements *) Extend SWIG support deeper into the BOARD class. *) Move swig *.i files into a directory identified for SWIG, in preparation for a parallel universe involving Phoenix's SIP. *) Move swig files which will be common to both eeschema and pcbnew into common/swig. *) Sketch out a "common" python module, and plan on dovetailing that into a libkicad_shared.{dll,so} *) Add common/swig/ki_exceptions.i and define a macro HANDLE_EXCEPTIONS() which is to be applied to any function which needs C++ to python exception translation. *) Move the test for SWIG tool into top level CMakeLists.txt file for use in all python modules beyond pcbnew, i.e. eeschema and common. *) Add SWIG_MODULE_pcbnew_EXTRA_DEPS which generates a better Makefile, one which rebuilds the swig generated *.cxx file when one of its dependencies change. *) Re-architect the board.i file so that it can be split into multiple *.i files easily. *) Make some KIWAY from python progress, in preparation for Modular KiCad phase III.
2016-09-20 15:59:43 +00:00
// process startup: InitPgm(), so test before using:
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
if( GetCommonSettings() )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
GetCommonSettings()->m_System.working_dir = wxGetCwd();
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
GetCommonSettings()->m_Env.show_warning_dialog = m_show_env_var_dialog;
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
// remove only the old env vars that do not exist in list.
// We do not clear the full list because some are defined externally,
// and we cannot modify or delete them
std::map<std::string, wxString>& curr_vars = GetCommonSettings()->m_Env.vars;
Common settings: fix: common environment vars: deleted vars were still in list. When updating common environment variables list, the initial list was never deleted. Therefore one could not remove an existing var. The common environment variables list is now deleted before updating.
2020-09-14 12:44:54 +00:00
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
for( auto it = curr_vars.begin(); it != curr_vars.end(); )
{
const std::string& key = it->first;
if( m_local_env_vars.find( key ) == m_local_env_vars.end() )
it = curr_vars.erase( it ); // This entry no longer exists in new list
else
it++;
}
// Save the local environment variables.
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
for( auto& m_local_env_var : m_local_env_vars )
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
{
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
if( m_local_env_var.second.GetDefinedExternally() )
Don't overwite env vars with settings. Fixes: lp:1740022 * https://bugs.launchpad.net/kicad/+bug/1740022
2018-03-08 19:16:51 +00:00
continue;
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars,
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
"PGM_BASE::SaveCommonSettings: Saving environment variable config "
"entry %s as %s",
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
m_local_env_var.first, m_local_env_var.second.GetValue() );
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
std::string key( m_local_env_var.first.ToUTF8() );
GetCommonSettings()->m_Env.vars[ key ] = m_local_env_var.second.GetValue();
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
}
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
COMMON_SETTINGS* PGM_BASE::GetCommonSettings() const
{
Don't crash when loading bitmaps before settings exist Fixes https://gitlab.com/kicad/code/kicad/-/issues/7900
2021-03-13 14:54:07 +00:00
return m_settings_manager ? GetSettingsManager().GetCommonSettings() : nullptr;
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
}
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
bool PGM_BASE::SetLanguage( wxString& aErrMsg, bool first_time )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
if( first_time )
{
setLanguageId( wxLANGUAGE_DEFAULT );
// First time SetLanguage is called, the user selected language id is set
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
// from common user config settings
wxString languageSel = GetCommonSettings()->m_System.language;
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
// Search for the current selection
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
for( unsigned ii = 0; LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
{
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
if( LanguagesList[ii].m_Lang_Label == languageSel )
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
{
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
setLanguageId( LanguagesList[ii].m_WX_Lang_Identifier );
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
break;
}
}
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
// dictionary file name without extend (full name is kicad.mo)
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
wxString dictionaryName( "kicad" );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
delete m_locale;
m_locale = new wxLocale;
if( !m_locale->Init( m_language_id ) )
{
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
wxLogTrace( traceLocale, "This language is not supported by the system." );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
setLanguageId( wxLANGUAGE_DEFAULT );
delete m_locale;
m_locale = new wxLocale;
m_locale->Init();
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
aErrMsg = _( "This language is not supported by the operating system." );
return false;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
else if( !first_time )
{
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
wxLogTrace( traceLocale, "Search for dictionary %s.mo in %s",
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
dictionaryName, m_locale->GetName() );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
if( !first_time )
{
fix misspelled 'an other' -> 'another'
2018-04-08 10:28:59 +00:00
// If we are here, the user has selected another language.
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
// Therefore the new preferred language name is stored in common config.
Fix an issue relative to the env vars initializations on Linux: they are not initialized if the value contains any non ASCII7 char, and if the locale is not set. The locale is now set before reading the env vars configuration.
2016-03-01 13:37:15 +00:00
// Do NOT store the wxWidgets language Id, it can change between wxWidgets
// versions, for a given language
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
wxString languageSel;
Remove a old useless font file (the Cyrillic fonte is, since a long time, in the current font file)
2016-03-03 17:51:38 +00:00
// Search for the current selection language name
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
for( unsigned ii = 0; LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
if( LanguagesList[ii].m_WX_Lang_Identifier == m_language_id )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
languageSel = LanguagesList[ii].m_Lang_Label;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
break;
}
}
Save language changes to file so they're picked up by other apps. Fixes https://gitlab.com/kicad/code/kicad/issues/1939
2020-07-31 21:27:37 +00:00
COMMON_SETTINGS* cfg = GetCommonSettings();
cfg->m_System.language = languageSel;
cfg->SaveToFile( GetSettingsManager().GetPathForSettingsFile( cfg ) );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
Initialize translation dictionary to default Initializes the dictionary before potential messages are shown on the screen. Fixes https://gitlab.com/kicad/code/kicad/issues/7076
2021-01-12 21:03:17 +00:00
// Try adding the dictionary if it is not currently loaded
if( !m_locale->IsLoaded( dictionaryName ) )
m_locale->AddCatalog( dictionaryName );
// Verify the Kicad dictionary was loaded properly
// However, for the English language, the dictionary is not mandatory, as
// all messages are already in English, just restricted to ASCII7 chars,
// the verification is skipped.
if( !m_locale->IsLoaded( dictionaryName ) && m_language_id != wxLANGUAGE_ENGLISH )
{
wxLogTrace( traceLocale, "Unable to load dictionary %s.mo in %s",
dictionaryName, m_locale->GetName() );
setLanguageId( wxLANGUAGE_DEFAULT );
delete m_locale;
m_locale = new wxLocale;
m_locale->Init();
aErrMsg = _( "The KiCad language file for this language is not installed." );
return false;
}
return true;
}
bool PGM_BASE::SetDefaultLanguage( wxString& aErrMsg )
{
setLanguageId( wxLANGUAGE_DEFAULT );
// dictionary file name without extend (full name is kicad.mo)
wxString dictionaryName( "kicad" );
delete m_locale;
m_locale = new wxLocale;
m_locale->Init();
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
// Try adding the dictionary if it is not currently loaded
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
if( !m_locale->IsLoaded( dictionaryName ) )
m_locale->AddCatalog( dictionaryName );
Language selection: do not disallow switching to English language when the English dictionnary is missing. It is not mandatory because all messages are in English, just restricted to ASCII7 chars Fixes #6261 https://gitlab.com/kicad/code/kicad/issues/6261
2020-11-03 10:47:28 +00:00
// Verify the Kicad dictionary was loaded properly
Remove unnecessary decimal point notation test on application start.
2020-12-09 18:53:50 +00:00
// However, for the English language, the dictionary is not mandatory, as
Language selection: do not disallow switching to English language when the English dictionnary is missing. It is not mandatory because all messages are in English, just restricted to ASCII7 chars Fixes #6261 https://gitlab.com/kicad/code/kicad/issues/6261
2020-11-03 10:47:28 +00:00
// all messages are already in English, just restricted to ASCII7 chars,
// the verification is skipped.
if( !m_locale->IsLoaded( dictionaryName ) && m_language_id != wxLANGUAGE_ENGLISH )
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
{
wxLogTrace( traceLocale, "Unable to load dictionary %s.mo in %s",
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
dictionaryName, m_locale->GetName() );
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
setLanguageId( wxLANGUAGE_DEFAULT );
delete m_locale;
m_locale = new wxLocale;
m_locale->Init();
aErrMsg = _( "The KiCad language file for this language is not installed." );
return false;
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Show an error message when switching to a language that isn't installed Also, ensure that the language names are not translated in the menus and messages, since they are already translated in the code. Fixes https://gitlab.com/kicad/code/kicad/issues/5324
2020-09-01 22:41:06 +00:00
return true;
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
void PGM_BASE::SetLanguageIdentifier( int menu_id )
{
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
wxLogTrace( traceLocale, "Select language ID %d from %d possible languages.",
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
menu_id, (int)arrayDim( LanguagesList )-1 );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
for( unsigned ii = 0; LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
if( menu_id == LanguagesList[ii].m_KI_Lang_Identifier )
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
{
Partial fix for missing language selection menu. The fix is partial because in the list of languages the menuitem corresponding to the selected language is not checked.
2019-06-16 18:35:32 +00:00
setLanguageId( LanguagesList[ii].m_WX_Lang_Identifier );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
break;
}
}
}
void PGM_BASE::SetLanguagePath()
{
SEARCH_STACK guesses;
SystemDirsAppend( &guesses );
// Add our internat dir to the wxLocale catalog of paths
for( unsigned i = 0; i < guesses.GetCount(); i++ )
{
wxFileName fn( guesses[i], wxEmptyString );
// Append path for Windows and unix KiCad package install
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
fn.AppendDir( "share" );
fn.AppendDir( "internat" );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
if( fn.IsDirReadable() )
{
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
wxLogTrace( traceLocale, "Adding locale lookup path: " + fn.GetPath() );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
}
// Append path for unix standard install
fn.RemoveLastDir();
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
fn.AppendDir( "kicad" );
fn.AppendDir( "internat" );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
if( fn.IsDirReadable() )
{
Replace log debugging output with tracing. Replace all instances of wxLogDebug with wxLogTrace in the common and kicad folders to prevent unwanted debugging output. Add new trace flags for locale and screen object tracing. The usual smattering of code policy fixes.
2018-10-17 19:03:33 +00:00
wxLogTrace( traceLocale, "Adding locale lookup path: " + fn.GetPath() );
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
}
Install translations into macOS bundle.
2021-02-20 23:54:40 +00:00
// Append path for macOS install
fn.RemoveLastDir();
fn.RemoveLastDir();
fn.RemoveLastDir();
fn.AppendDir( "internat" );
if( fn.IsDirReadable() )
{
wxLogTrace( traceLocale, "Adding locale lookup path: " + fn.GetPath() );
wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
Allow translations to load from build dir
2021-02-13 03:38:02 +00:00
if( wxGetEnv( wxT( "KICAD_RUN_FROM_BUILD_DIR" ), nullptr ) )
{
wxFileName fn( Pgm().GetExecutablePath() );
fn.RemoveLastDir();
fn.AppendDir( "translation" );
wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
}
* KIWAY Milestone A): Make major modules into DLL/DSOs. ! The initial testing of this commit should be done using a Debug build so that all the wxASSERT()s are enabled. Also, be sure and keep enabled the USE_KIWAY_DLLs option. The tree won't likely build without it. Turning it off is senseless anyways. If you want stable code, go back to a prior version, the one tagged with "stable". * Relocate all functionality out of the wxApp derivative into more finely targeted purposes: a) DLL/DSO specific b) PROJECT specific c) EXE or process specific d) configuration file specific data e) configuration file manipulations functions. All of this functionality was blended into an extremely large wxApp derivative and that was incompatible with the desire to support multiple concurrently loaded DLL/DSO's ("KIFACE")s and multiple concurrently open projects. An amazing amount of organization come from simply sorting each bit of functionality into the proper box. * Switch to wxConfigBase from wxConfig everywhere except instantiation. * Add classes KIWAY, KIFACE, KIFACE_I, SEARCH_STACK, PGM_BASE, PGM_KICAD, PGM_SINGLE_TOP, * Remove "Return" prefix on many function names. * Remove obvious comments from CMakeLists.txt files, and from else() and endif()s. * Fix building boost for use in a DSO on linux. * Remove some of the assumptions in the CMakeLists.txt files that windows had to be the host platform when building windows binaries. * Reduce the number of wxStrings being constructed at program load time via static construction. * Pass wxConfigBase* to all SaveSettings() and LoadSettings() functions so that these functions are useful even when the wxConfigBase comes from another source, as is the case in the KICAD_MANAGER_FRAME. * Move the setting of the KIPRJMOD environment variable into class PROJECT, so that it can be moved into a project variable soon, and out of FP_LIB_TABLE. * Add the KIWAY_PLAYER which is associated with a particular PROJECT, and all its child wxFrames and wxDialogs now have a Kiway() member function which returns a KIWAY& that that window tree branch is in support of. This is like wxWindows DNA in that child windows get this member with proper value at time of construction. * Anticipate some of the needs for milestones B) and C) and make code adjustments now in an effort to reduce work in those milestones. * No testing has been done for python scripting, since milestone C) has that being largely reworked and re-thought-out.
2014-03-20 00:42:08 +00:00
}
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
bool PGM_BASE::SetLocalEnvVariable( const wxString& aName, const wxString& aValue )
{
wxString env;
// Check to see if the environment variable is already set.
if( wxGetEnv( aName, &env ) )
{
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars,
"PGM_BASE::SetLocalEnvVariable: Environment variable %s already set to %s",
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
aName, env );
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
return env == aValue;
}
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars,
"PGM_BASE::SetLocalEnvVariable: Setting local environment variable %s to %s",
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
aName, aValue );
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
return wxSetEnv( aName, aValue );
}
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
void PGM_BASE::SetLocalEnvVariables( const ENV_VAR_MAP& aEnvVarMap )
{
m_local_env_vars.clear();
m_local_env_vars = aEnvVarMap;
SWIG Improvements *) Extend SWIG support deeper into the BOARD class. *) Move swig *.i files into a directory identified for SWIG, in preparation for a parallel universe involving Phoenix's SIP. *) Move swig files which will be common to both eeschema and pcbnew into common/swig. *) Sketch out a "common" python module, and plan on dovetailing that into a libkicad_shared.{dll,so} *) Add common/swig/ki_exceptions.i and define a macro HANDLE_EXCEPTIONS() which is to be applied to any function which needs C++ to python exception translation. *) Move the test for SWIG tool into top level CMakeLists.txt file for use in all python modules beyond pcbnew, i.e. eeschema and common. *) Add SWIG_MODULE_pcbnew_EXTRA_DEPS which generates a better Makefile, one which rebuilds the swig generated *.cxx file when one of its dependencies change. *) Re-architect the board.i file so that it can be split into multiple *.i files easily. *) Make some KIWAY from python progress, in preparation for Modular KiCad phase III.
2016-09-20 15:59:43 +00:00
SaveCommonSettings();
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
// Overwrites externally defined environment variable until the next time the application
// is run.
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
for( auto& m_local_env_var : m_local_env_vars )
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
{
Fix Python environment variable handling The variables in the common settings struct are only updated on save, so Python must use the ones from Pgm to get its values. This does lead to the observation that Python's changes to the variables do affect KiCad (they can break resolvers). So apparently it can mess with us but we can't mess with it easily. Also, improve the environment variable tracing infrastructure to capture more changes.
2020-08-11 23:11:48 +00:00
wxLogTrace( traceEnvVars,
"PGM_BASE::SetLocalEnvVariables: Setting local environment variable %s to %s",
Common settings: better fix for common environment vars deletion. The previous fix (d4461f6) removed all vars before re-add them. Clear all vars created issues with externally defined variables (the internal initial value was lost) Now only old, no longer existing, vars are deleted. Fix also a potential issue related to non ASCII7 in last stored path.
2020-09-14 14:46:56 +00:00
m_local_env_var.first,
m_local_env_var.second.GetValue() );
Implement a new settings framework across all of KiCad CHANGED: Settings are now stored in versioned sub-directories ADDED: First-run dialog for migrating settings from a previous version CHANGED: Settings are now stored as JSON files instead of wxConfig-style INI files CHANGED: Color settings are now all stored in a separate settings file CHANGED: The symbol editor and footprint editor now have their own settings files CHANGED: Color settings are no longer exposed through BOARD object CHANGED: Page layout editor now uses Eeschema's color scheme Settings are now managed through a central SETTINGS_MANAGER held by PGM_BASE. Existing settings will be migrated from the wxConfig format on first run of each application. Per-application settings are now stored in one class for each application.
2020-01-13 01:44:19 +00:00
wxSetEnv( m_local_env_var.first, m_local_env_var.second.GetValue() );
Add path (environment variable) configuration dialog. * Create new dialog to edit environment variables. * Add helper class ENV_VAR_ITEM to manage environment variable values and if they were defined externally. * A path configuration dialog access to KiCad, CvPcb, Pcbnew, and Footprint Editor window menus. * Add validator for environment variables.
2015-03-29 21:22:53 +00:00
}
}