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

729 lines
23 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>
* Copyright (C) 1992-2018 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 <fctsys.h>
#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>
* 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>
Fold 3D Search Paths dialog into Configure Paths. Use in-place editing for both. Fixes: lp:1743823 * https://bugs.launchpad.net/kicad/+bug/1743823 (cherry picked from commit 33622cd)
2018-03-07 13:05:12 +00:00
#include <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>
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>
#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
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
static const wxChar traceEnvVars[] = wxT( "KIENVVARS" );
Unified preferences dialog framework. (cherry picked from commit 8ee3e77)
2018-05-14 17:34:18 +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
/**
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
* 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
* Note: because this list is not created on the fly, wxTranslation
* 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
{
Cleanup struct initialization and formatting
2019-12-17 16:09:32 +00:00
{ wxLANGUAGE_DEFAULT, ID_LANGUAGE_DEFAULT, lang_def_xpm, _( "Default" ), false },
{ wxLANGUAGE_ENGLISH, ID_LANGUAGE_ENGLISH, lang_en_xpm, wxT( "English" ), true },
{ wxLANGUAGE_FRENCH, ID_LANGUAGE_FRENCH, lang_fr_xpm, _( "French" ), false },
{ wxLANGUAGE_FINNISH, ID_LANGUAGE_FINNISH, lang_fi_xpm, _( "Finnish" ), false },
{ wxLANGUAGE_SPANISH, ID_LANGUAGE_SPANISH, lang_es_xpm, _( "Spanish" ), false },
{ wxLANGUAGE_PORTUGUESE, ID_LANGUAGE_PORTUGUESE, lang_pt_xpm, _( "Portuguese" ), false },
{ wxLANGUAGE_ITALIAN, ID_LANGUAGE_ITALIAN, lang_it_xpm, _( "Italian" ), false },
{ wxLANGUAGE_GERMAN, ID_LANGUAGE_GERMAN, lang_de_xpm, _( "German" ), false },
{ wxLANGUAGE_GREEK, ID_LANGUAGE_GREEK, lang_gr_xpm, _( "Greek" ), false },
{ wxLANGUAGE_SLOVENIAN, ID_LANGUAGE_SLOVENIAN, lang_sl_xpm, _( "Slovenian" ), false },
{ wxLANGUAGE_SLOVAK, ID_LANGUAGE_SLOVAK, lang_sk_xpm, _( "Slovak" ), false },
{ wxLANGUAGE_HUNGARIAN, ID_LANGUAGE_HUNGARIAN, lang_hu_xpm, _( "Hungarian" ), false },
{ wxLANGUAGE_POLISH, ID_LANGUAGE_POLISH, lang_pl_xpm, _( "Polish" ), false },
{ wxLANGUAGE_CZECH, ID_LANGUAGE_CZECH, lang_cs_xpm, _( "Czech" ), false },
{ wxLANGUAGE_RUSSIAN, ID_LANGUAGE_RUSSIAN, lang_ru_xpm, _( "Russian" ), false },
{ wxLANGUAGE_KOREAN, ID_LANGUAGE_KOREAN, lang_ko_xpm, _( "Korean" ), false },
Add Chinese traditional in language list.
2018-08-27 15:20:28 +00:00
{ wxLANGUAGE_CHINESE_SIMPLIFIED, ID_LANGUAGE_CHINESE_SIMPLIFIED, lang_zh_xpm,
Cleanup struct initialization and formatting
2019-12-17 16:09:32 +00:00
_( "Chinese simplified" ), false },
Add Chinese traditional in language list.
2018-08-27 15:20:28 +00:00
{ wxLANGUAGE_CHINESE_TRADITIONAL, ID_LANGUAGE_CHINESE_TRADITIONAL, lang_zh_xpm,
Cleanup struct initialization and formatting
2019-12-17 16:09:32 +00:00
_( "Chinese traditional" ), false },
{ wxLANGUAGE_CATALAN, ID_LANGUAGE_CATALAN, lang_ca_xpm, _( "Catalan" ), false },
{ wxLANGUAGE_DUTCH, ID_LANGUAGE_DUTCH, lang_nl_xpm, _( "Dutch" ), false },
{ wxLANGUAGE_JAPANESE, ID_LANGUAGE_JAPANESE, lang_jp_xpm, _( "Japanese" ), false },
{ wxLANGUAGE_BULGARIAN, ID_LANGUAGE_BULGARIAN, lang_bg_xpm, _( "Bulgarian" ), false },
{ wxLANGUAGE_LITHUANIAN, ID_LANGUAGE_LITHUANIAN, lang_lt_xpm, _( "Lithuanian" ), false },
{ 0, 0, lang_def_xpm, "", 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;
* 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
{
DisplayInfoMessage( NULL,
_( "No default editor found, you must choose it" ) );
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).
return EDA_FILE_SELECTOR( _( "Select Preferred Editor" ), path,
name, ext, mask,
NULL, wxFD_OPEN | wxFD_FILE_MUST_EXIST,
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
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();
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() )
{
wxString quiz = wxString::Format(
Fix english grammar
2018-03-08 04:07:33 +00:00
_( "%s is already running. Continue?" ),
* 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
GetChars( pgm_name.GetName() )
);
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +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
if( !IsOK( NULL, quiz ) )
return false;
}
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_settings_manager = std::unique_ptr<SETTINGS_MANAGER>( new 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
// 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
setExecutablePath();
SetLanguagePath();
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
wxString envVarName = wxT( "KIGITHUB" );
ENV_VAR_ITEM envVarItem;
wxString envValue;
wxFileName tmpFileName;
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
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 );
}
else
{
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
envVarItem.SetValue( wxString( wxT( "https://github.com/KiCad" ) ) );
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
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;
wxFileName baseSharePath;
Use paths relative to the executable on Windows Paths based on DEFAULT_INSTALL_PATH do not work on Windows, as in fact there is no default install path, as in case of Unix-based systems. In such case, the initial paths point to mingw subdirectories that normally do not exist on user machines. The patch changes the initial path values to make them relative to the executable and follow the current Windows installer scheme. Fixes: lp:1775796 * https://bugs.launchpad.net/kicad/+bug/1775796
2018-06-27 08:59:06 +00:00
#if defined( __WXMSW__ )
// Make the paths relative to the executable dir as KiCad might be installed anywhere
// It follows the Windows installer paths scheme, where binaries are installed in
// PATH/bin and extra files in PATH/share/kicad
baseSharePath.AssignDir( m_bin_dir + "\\.." );
baseSharePath.Normalize();
#else
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
baseSharePath.AssignDir( wxString( wxT( DEFAULT_INSTALL_PATH ) ) );
Use paths relative to the executable on Windows Paths based on DEFAULT_INSTALL_PATH do not work on Windows, as in fact there is no default install path, as in case of Unix-based systems. In such case, the initial paths point to mingw subdirectories that normally do not exist on user machines. The patch changes the initial path values to make them relative to the executable and follow the current Windows installer scheme. Fixes: lp:1775796 * https://bugs.launchpad.net/kicad/+bug/1775796
2018-06-27 08:59:06 +00:00
#endif
Default KISYSMOD and KISYS3DMOD path fixes. (fixes lp:1455472)
2015-07-21 00:46:58 +00:00
#if !defined( __WXMAC__ )
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
baseSharePath.AppendDir( "share" );
baseSharePath.AppendDir( "kicad" );
Default KISYSMOD and KISYS3DMOD path fixes. (fixes lp:1455472)
2015-07-21 00:46:58 +00:00
#endif
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
// KISYSMOD
envVarName = wxT( "KISYSMOD" );
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 );
}
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() );
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
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
// KISYS3DMOD
envVarName = wxT( "KISYS3DMOD" );
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 );
}
else
{
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( "packages3d" );
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() );
m_local_env_vars[ envVarName ] = envVarItem;
Default KISYSMOD and KISYS3DMOD path fixes. (fixes lp:1455472)
2015-07-21 00:46:58 +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
// KICAD_TEMPLATE_DIR
envVarName = "KICAD_TEMPLATE_DIR";
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 );
}
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() );
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 );
}
else
{
// Default user template path.
Fix default User Template location When we assign a string to the wxFilename, it takes the last section as the filename (unless there is a trailing '/'). So on Linux, we got /home/user for the Documents dir and /home/ was the directory while 'user' was the filename. Appending directories 'kicad/templates' made the final directory '/home/kicad/templates'. Forcing this to be a directory restores correct behavior. (cherry picked from commit 0ee38653f7799d5624fe3a2ec06db0bd2573eb9b)
2019-06-11 02:46:10 +00:00
tmpFileName.AssignDir( wxStandardPaths::Get().GetDocumentsDir() );
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
tmpFileName.AppendDir( "kicad" );
tmpFileName.AppendDir( "template" );
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() );
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
envVarName = wxT( "KICAD_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 );
}
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() );
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)
Removed relic empty if
2014-03-29 17:34:13 +00:00
SetLanguage( 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
* 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 );
wxLogTrace( traceEnvVars, "Enumerating over 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;
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
{
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_System.working_dir = wxGetCwd().ToStdString();
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
// 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;
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( traceEnvVars, "Saving environment variable config entry %s as %s",
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
GetChars( m_local_env_var.first ),
GetChars( 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
{
return GetSettingsManager().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
bool PGM_BASE::SetLanguage( bool first_time )
{
bool retv = true;
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();
retv = false;
}
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",
* 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
GetChars( dictionaryName ), GetChars( m_locale->GetName() ) );
}
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.
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
// Therefore the new prefered language name is stored in common config.
// 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;
}
}
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_System.language = languageSel;
* 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 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
// Test if floating point notation is working (bug encountered in cross compilation)
* 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
// Make a conversion double <=> string
double dtst = 0.5;
wxString msg;
msg << dtst;
double result;
msg.ToDouble( &result );
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
if( result != dtst )
// string to double encode/decode does not work! Bug detected:
* 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
// Disable floating point localization:
Fix a side effect of our LOCALE_IO by using setlocale( LC_NUMERIC, "C" ) instead of setlocale( LC_ALL, "C" ) LC_NUMERIC is the right option to use in LOCALE_IO because only the floating point separator must be modified When using LC_ALL, the Env var expansion wxGetEnv() was not working when the env var contains non ascii7 codes after a call to LOCALE_IO. When using setlocale( LC_NUMERIC, "C" ) in LOCALE_IO, wxGetEnv() works fine. Fixes: lp:1795990 https://bugs.launchpad.net/kicad/+bug/1795990
2018-10-07 14:07:10 +00:00
setlocale( LC_NUMERIC, "C" );
* 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 );
if( !retv )
return retv;
return m_locale->IsOk();
}
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() );
}
}
}
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 ) )
{
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( traceEnvVars, "Environment variable %s already set to %s.",
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
GetChars( aName ), GetChars( env ) );
return env == aValue;
}
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( traceEnvVars, "Setting local environment variable %s to %s.",
Set default footprint library table and 3D model library environment variables.
2015-02-03 20:42:33 +00:00
GetChars( aName ), GetChars( aValue ) );
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
{
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( traceEnvVars, "Setting local environment variable %s to %s.",
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
GetChars( m_local_env_var.first ),
GetChars( m_local_env_var.second.GetValue() ) );
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
}
}