KiCad PCB EDA Suite
SETTINGS_MANAGER Class Reference

#include <settings_manager.h>

Public Member Functions

 SETTINGS_MANAGER (bool aHeadless=false)
 
 ~SETTINGS_MANAGER ()
 
bool IsOK ()
 
void SetKiway (KIWAY *aKiway)
 Associate this setting manager with the given Kiway. More...
 
JSON_SETTINGSRegisterSettings (JSON_SETTINGS *aSettings, bool aLoadNow=true)
 Takes ownership of the pointer passed in. More...
 
void Load ()
 
void Load (JSON_SETTINGS *aSettings)
 
void Save ()
 
void Save (JSON_SETTINGS *aSettings)
 
void FlushAndRelease (JSON_SETTINGS *aSettings, bool aSave=true)
 If the given settings object is registered, save it to disk and unregister it. More...
 
template<typename AppSettings >
AppSettings * GetAppSettings (bool aLoadNow=true)
 Returns a handle to the a given settings by type If the settings have already been loaded, returns the existing pointer. More...
 
COLOR_SETTINGSGetColorSettings (const wxString &aName="user")
 Retrieves a color settings object that applications can read colors from. More...
 
std::vector< COLOR_SETTINGS * > GetColorSettingsList ()
 
void SaveColorSettings (COLOR_SETTINGS *aSettings, const std::string &aNamespace="")
 Safely saves a COLOR_SETTINGS to disk, preserving any changes outside the given namespace. More...
 
COLOR_SETTINGSAddNewColorSettings (const wxString &aFilename)
 Registers a new color settings object with the given filename. More...
 
COLOR_SETTINGSGetMigratedColorSettings ()
 Returns a color theme for storing colors migrated from legacy (5.x and earlier) settings, creating the theme if necessary. More...
 
COMMON_SETTINGSGetCommonSettings () const
 Retrieves the common settings shared by all applications. More...
 
wxString GetPathForSettingsFile (JSON_SETTINGS *aSettings)
 Returns the path a given settings file should be loaded from / stored to. More...
 
bool MigrateIfNeeded ()
 Handles the initialization of the user settings directory and migration from previous KiCad versions as needed. More...
 
void SetMigrationSource (const wxString &aSource)
 Helper for DIALOG_MIGRATE_SETTINGS to specify a source for migration. More...
 
void SetMigrateLibraryTables (bool aMigrate=true)
 
bool GetPreviousVersionPaths (std::vector< wxString > *aName=nullptr)
 Retreives the name of the most recent previous KiCad version that can be found in the user settings directory. More...
 
void ReloadColorSettings ()
 Re-scans the color themes directory, reloading any changes it finds. More...
 
bool LoadProject (const wxString &aFullPath, bool aSetActive=true)
 Loads a project or sets up a new project with a specified path. More...
 
bool UnloadProject (PROJECT *aProject, bool aSave=true)
 Saves, unloads and unregisters the given PROJECT. More...
 
bool IsProjectOpen () const
 Helper for checking if we have a project open TODO: This should be deprecated along with Prj() once we support multiple projects fully. More...
 
PROJECTPrj () const
 A helper while we are not MDI-capable – return the one and only project. More...
 
PROJECTGetProject (const wxString &aFullPath) const
 Retrieves a loaded project by name. More...
 
std::vector< wxString > GetOpenProjects () const
 
bool SaveProject (const wxString &aFullPath=wxEmptyString)
 Saves a loaded project. More...
 
void SaveProjectAs (const wxString &aFullPath)
 Sets the currently loaded project path and saves it (pointers remain valid) More...
 
wxString GetProjectBackupsPath () const
 
bool BackupProject (REPORTER &aReporter) const
 Creates a backup archive of the current project. More...
 
bool TriggerBackupIfNeeded (REPORTER &aReporter) const
 Calls BackupProject if a new backup is needed according to the current backup policy. More...
 

Static Public Member Functions

static bool IsSettingsPathValid (const wxString &aPath)
 Checks if a given path is probably a valid KiCad configuration directory. More...
 
static wxString GetColorSettingsPath ()
 Returns the path where color scheme files are stored; creating it if missing (normally . More...
 
static wxString GetUserSettingsPath ()
 Return the user configuration path used to store KiCad's configuration files. More...
 
static std::string GetSettingsVersion ()
 Parses the current KiCad build version and extracts the major and minor revision to use as the name of the settings directory for this KiCad version. More...
 

Private Member Functions

COLOR_SETTINGSloadColorSettingsByName (const wxString &aName)
 Attempts to load a color theme by name (the color theme directory and .json ext are assumed) More...
 
void registerColorSettings (const wxString &aFilename)
 
void loadAllColorSettings ()
 
bool loadProjectFile (PROJECT &aProject)
 Registers a PROJECT_FILE and attempts to load it from disk. More...
 
bool unloadProjectFile (PROJECT *aProject, bool aSave)
 Optionally saves, and then unloads and unregisters the given PROJECT_FILE. More...
 

Static Private Member Functions

static wxString calculateUserSettingsPath (bool aIncludeVer=true, bool aUseEnv=true)
 Determines the base path for user settings files. More...
 
static int compareVersions (const std::string &aFirst, const std::string &aSecond)
 Compares two settings versions, like "5.99" and "6.0". More...
 
static bool extractVersion (const std::string &aVersionString, int *aMajor, int *aMinor)
 Extracts the numeric version from a given settings string. More...
 

Private Attributes

bool m_headless
 True if running outside a UI context. More...
 
KIWAYm_kiway
 The kiway this settings manager interacts with. More...
 
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
 
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
 
COMMON_SETTINGSm_common_settings
 
wxString m_migration_source
 
bool m_migrateLibraryTables
 If true, the symbol and footprint library tables will be migrated from the previous version. More...
 
bool m_ok
 True if settings loaded successfully at construction. More...
 
std::vector< std::unique_ptr< PROJECT > > m_projects_list
 Loaded projects (ownership here) More...
 
std::map< wxString, PROJECT * > m_projects
 Loaded projects, mapped according to project full name. More...
 
std::map< wxString, PROJECT_FILE * > m_project_files
 Loaded project files, mapped according to project full name. More...
 

Static Private Attributes

static wxString backupDateTimeFormat = wxT( "%Y-%m-%d_%H%M%S" )
 

Detailed Description

Definition at line 35 of file settings_manager.h.

Constructor & Destructor Documentation

◆ SETTINGS_MANAGER()

SETTINGS_MANAGER::SETTINGS_MANAGER ( bool  aHeadless = false)

Definition at line 49 of file settings_manager.cpp.

49  :
50  m_headless( aHeadless ),
51  m_kiway( nullptr ),
52  m_common_settings( nullptr ),
55 {
56  // Check if the settings directory already exists, and if not, perform a migration if possible
57  if( !MigrateIfNeeded() )
58  {
59  m_ok = false;
60  return;
61  }
62 
63  m_ok = true;
64 
65  // create the common settings shared by all applications. Not loaded immediately
67  static_cast<COMMON_SETTINGS*>( RegisterSettings( new COMMON_SETTINGS, false ) );
68 
70 }
KIWAY * m_kiway
The kiway this settings manager interacts with.
bool m_migrateLibraryTables
If true, the symbol and footprint library tables will be migrated from the previous version.
bool MigrateIfNeeded()
Handles the initialization of the user settings directory and migration from previous KiCad versions ...
wxString m_migration_source
bool m_ok
True if settings loaded successfully at construction.
bool m_headless
True if running outside a UI context.
JSON_SETTINGS * RegisterSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.
COMMON_SETTINGS * m_common_settings

References loadAllColorSettings(), m_common_settings, m_ok, MigrateIfNeeded(), and RegisterSettings().

◆ ~SETTINGS_MANAGER()

SETTINGS_MANAGER::~SETTINGS_MANAGER ( )

Definition at line 72 of file settings_manager.cpp.

73 {
74  m_settings.clear();
75  m_color_settings.clear();
76  m_projects.clear();
77 }
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings

References m_color_settings, m_projects, and m_settings.

Member Function Documentation

◆ AddNewColorSettings()

COLOR_SETTINGS * SETTINGS_MANAGER::AddNewColorSettings ( const wxString &  aFilename)

Registers a new color settings object with the given filename.

Parameters
aFilenameis the location to store the new settings object
Returns
a pointer to the new object

Definition at line 252 of file settings_manager.cpp.

253 {
254  wxString filename = aFilename;
255 
256  if( filename.EndsWith( wxT( ".json" ) ) )
257  filename = filename.BeforeLast( '.' );
258 
259  registerColorSettings( filename );
260  return m_color_settings[filename];
261 }
void registerColorSettings(const wxString &aFilename)
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings

References m_color_settings, and registerColorSettings().

Referenced by FOOTPRINT_EDITOR_SETTINGS::MigrateFromLegacy(), COLOR_SETTINGS::migrateSchema0to1(), and PANEL_COLOR_SETTINGS::OnThemeChanged().

◆ BackupProject()

bool SETTINGS_MANAGER::BackupProject ( REPORTER aReporter) const

Creates a backup archive of the current project.

Parameters
aReporteris used for progress reporting
Returns
true if everything succeeded

Definition at line 946 of file settings_manager.cpp.

947 {
948  wxDateTime timestamp = wxDateTime::Now();
949 
950  wxString fileName = wxString::Format( wxT( "%s-%s" ), Prj().GetProjectName(),
951  timestamp.Format( backupDateTimeFormat ) );
952 
953  wxFileName target;
954  target.SetPath( GetProjectBackupsPath() );
955  target.SetName( fileName );
956  target.SetExt( ArchiveFileExtension );
957 
958  wxDir dir( target.GetPath() );
959 
960  if( !target.DirExists() && !wxMkdir( target.GetPath() ) )
961  {
962  wxLogTrace( traceSettings, "Could not create project backup path %s", target.GetPath() );
963  return false;
964  }
965 
966  if( !target.IsDirWritable() )
967  {
968  wxLogTrace( traceSettings, "Backup directory %s is not writeable", target.GetPath() );
969  return false;
970  }
971 
972  wxLogTrace( traceSettings, "Backing up project to %s", target.GetPath() );
973 
974  PROJECT_ARCHIVER archiver;
975 
976  return archiver.Archive( Prj().GetProjectPath(), target.GetFullPath(), aReporter );
977 }
static wxString backupDateTimeFormat
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
bool Archive(const wxString &aSrcDir, const wxString &aDestFile, REPORTER &aReporter, bool aVerbose=true)
Creates an archive of the project.
wxString GetProjectBackupsPath() const
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
const std::string ArchiveFileExtension

References PROJECT_ARCHIVER::Archive(), ArchiveFileExtension, backupDateTimeFormat, Format(), GetProjectBackupsPath(), Prj(), and traceSettings.

Referenced by TriggerBackupIfNeeded().

◆ calculateUserSettingsPath()

wxString SETTINGS_MANAGER::calculateUserSettingsPath ( bool  aIncludeVer = true,
bool  aUseEnv = true 
)
staticprivate

Determines the base path for user settings files.

The configuration path order of precedence is determined by the following criteria:

  • The value of the KICAD_CONFIG_HOME environment variable
  • The value of the XDG_CONFIG_HOME environment variable.
  • The result of the call to wxStandardPaths::GetUserConfigDir() with ".config" appended as required on Linux builds.
Parameters
aIncludeVerwill append the current KiCad version if true (default)
aUseEnvwill prefer the base path found in the KICAD_CONFIG_DIR if found (default)
Returns
A string containing the config path for Kicad

Definition at line 601 of file settings_manager.cpp.

602 {
603  wxFileName cfgpath;
604 
605  // http://docs.wxwidgets.org/3.0/classwx_standard_paths.html#a7c7cf595d94d29147360d031647476b0
606  cfgpath.AssignDir( wxStandardPaths::Get().GetUserConfigDir() );
607 
608  // GetUserConfigDir() does not default to ~/.config which is the current standard
609  // configuration file location on Linux. This has been fixed in later versions of wxWidgets.
610 #if !defined( __WXMSW__ ) && !defined( __WXMAC__ )
611  wxArrayString dirs = cfgpath.GetDirs();
612 
613  if( dirs.Last() != ".config" )
614  cfgpath.AppendDir( ".config" );
615 #endif
616 
617  wxString envstr;
618 
619  // This shouldn't cause any issues on Windows or MacOS.
620  if( wxGetEnv( wxT( "XDG_CONFIG_HOME" ), &envstr ) && !envstr.IsEmpty() )
621  {
622  // Override the assignment above with XDG_CONFIG_HOME
623  cfgpath.AssignDir( envstr );
624  }
625 
626  cfgpath.AppendDir( TO_STR( KICAD_CONFIG_DIR ) );
627 
628  // Use KICAD_CONFIG_HOME to allow the user to force a specific configuration path.
629  if( aUseEnv && wxGetEnv( wxT( "KICAD_CONFIG_HOME" ), &envstr ) && !envstr.IsEmpty() )
630  {
631  // Override the assignment above with KICAD_CONFIG_HOME
632  cfgpath.AssignDir( envstr );
633  }
634 
635  if( aIncludeVer )
636  cfgpath.AppendDir( GetSettingsVersion() );
637 
638  return cfgpath.GetPath();
639 }
#define TO_STR(x)
Definition: macros.h:103
static std::string GetSettingsVersion()
Parses the current KiCad build version and extracts the major and minor revision to use as the name o...

References GetSettingsVersion(), and TO_STR.

Referenced by GetPreviousVersionPaths(), and GetUserSettingsPath().

◆ compareVersions()

int SETTINGS_MANAGER::compareVersions ( const std::string &  aFirst,
const std::string &  aSecond 
)
staticprivate

Compares two settings versions, like "5.99" and "6.0".

Returns
-1 if aFirst is older than aSecond, 1 if aFirst is newer than aSecond, 0 otherwise

Definition at line 649 of file settings_manager.cpp.

650 {
651  int a_maj = 0;
652  int a_min = 0;
653  int b_maj = 0;
654  int b_min = 0;
655 
656  if( !extractVersion( aFirst, &a_maj, &a_min ) || !extractVersion( aSecond, &b_maj, &b_min ) )
657  {
658  wxLogTrace( traceSettings, "compareSettingsVersions: bad input (%s, %s)", aFirst, aSecond );
659  return -1;
660  }
661 
662  if( a_maj < b_maj )
663  {
664  return -1;
665  }
666  else if( a_maj > b_maj )
667  {
668  return 1;
669  }
670  else
671  {
672  if( a_min < b_min )
673  {
674  return -1;
675  }
676  else if( a_min > b_min )
677  {
678  return 1;
679  }
680  else
681  {
682  return 0;
683  }
684  }
685 }
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
static bool extractVersion(const std::string &aVersionString, int *aMajor, int *aMinor)
Extracts the numeric version from a given settings string.

References extractVersion(), and traceSettings.

Referenced by GetPreviousVersionPaths().

◆ extractVersion()

bool SETTINGS_MANAGER::extractVersion ( const std::string &  aVersionString,
int *  aMajor,
int *  aMinor 
)
staticprivate

Extracts the numeric version from a given settings string.

Parameters
aVersionStringis the string to split at the "."
aMajorwill store the first part
aMinorwill store the second part
Returns
true if extraction succeeded

Definition at line 688 of file settings_manager.cpp.

689 {
690  std::regex re_version( "(\\d+)\\.(\\d+)" );
691  std::smatch match;
692 
693  if( std::regex_match( aVersionString, match, re_version ) )
694  {
695  try
696  {
697  *aMajor = std::stoi( match[1].str() );
698  *aMinor = std::stoi( match[2].str() );
699  }
700  catch( ... )
701  {
702  return false;
703  }
704 
705  return true;
706  }
707 
708  return false;
709 }

Referenced by compareVersions().

◆ FlushAndRelease()

void SETTINGS_MANAGER::FlushAndRelease ( JSON_SETTINGS aSettings,
bool  aSave = true 
)

If the given settings object is registered, save it to disk and unregister it.

Parameters
aSettingsis the object to release

Definition at line 148 of file settings_manager.cpp.

149 {
150  auto it = std::find_if( m_settings.begin(), m_settings.end(),
151  [&aSettings]( const std::unique_ptr<JSON_SETTINGS>& aPtr )
152  {
153  return aPtr.get() == aSettings;
154  } );
155 
156  if( it != m_settings.end() )
157  {
158  wxLogTrace( traceSettings, "Flush and release %s", ( *it )->GetFullFilename() );
159 
160  if( aSave )
161  ( *it )->SaveToFile( GetPathForSettingsFile( it->get() ) );
162 
163  m_settings.erase( it );
164  }
165 }
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References GetPathForSettingsFile(), m_settings, and traceSettings.

Referenced by unloadProjectFile().

◆ GetAppSettings()

template<typename AppSettings >
AppSettings* SETTINGS_MANAGER::GetAppSettings ( bool  aLoadNow = true)
inline

Returns a handle to the a given settings by type If the settings have already been loaded, returns the existing pointer.

If the settings have not been loaded, creates a new object owned by the settings manager and returns a pointer to it.

Template Parameters
AppSettingsis a type derived from APP_SETTINGS_BASE
Parameters
aLoadNowis true to load the registered file from disk immediately
Returns
a pointer to a loaded settings object

Definition at line 86 of file settings_manager.h.

87  {
88  AppSettings* ret = nullptr;
89 
90  auto it = std::find_if( m_settings.begin(), m_settings.end(),
91  []( const std::unique_ptr<JSON_SETTINGS>& aSettings )
92  {
93  return dynamic_cast<AppSettings*>( aSettings.get() );
94  } );
95 
96  if( it != m_settings.end() )
97  {
98  ret = dynamic_cast<AppSettings*>( it->get() );
99  }
100  else
101  {
102  try
103  {
104  ret = static_cast<AppSettings*>( RegisterSettings( new AppSettings, aLoadNow ) );
105  }
106  catch( ... )
107  {
108  wxLogTrace( traceSettings, "Unable to create application settings object" );
109  }
110 
111  }
112 
113  return ret;
114  }
JSON_SETTINGS * RegisterSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.

References m_settings, RegisterSettings(), and traceSettings.

Referenced by PL_EDITOR_FRAME::CommonSettingsChanged(), DIALOG_EXPORT_SVG::CreateSVGFile(), SYMBOL_EDIT_FRAME::GetColorSettings(), LIB_PIN::LIB_PIN(), PANEL_EESCHEMA_COLOR_SETTINGS::PANEL_EESCHEMA_COLOR_SETTINGS(), PANEL_FP_EDITOR_COLOR_SETTINGS::PANEL_FP_EDITOR_COLOR_SETTINGS(), PANEL_PCBNEW_COLOR_SETTINGS::PANEL_PCBNEW_COLOR_SETTINGS(), PL_DRAW_PANEL_GAL::PL_DRAW_PANEL_GAL(), DIALOG_PLOT::Plot(), PANEL_PL_EDITOR_COLOR_SETTINGS::TransferDataFromWindow(), PANEL_SYM_COLOR_SETTINGS::TransferDataFromWindow(), PANEL_FP_EDITOR_COLOR_SETTINGS::TransferDataFromWindow(), PANEL_PCBNEW_COLOR_SETTINGS::TransferDataFromWindow(), and PANEL_EESCHEMA_COLOR_SETTINGS::TransferDataFromWindow().

◆ GetColorSettings()

COLOR_SETTINGS * SETTINGS_MANAGER::GetColorSettings ( const wxString &  aName = "user")

Retrieves a color settings object that applications can read colors from.

If the given settings file cannot be found, returns the default settings.

Parameters
aNameis the name of the color scheme to load
Returns
a loaded COLOR_SETTINGS object

Definition at line 168 of file settings_manager.cpp.

169 {
170  if( m_color_settings.count( aName ) )
171  return m_color_settings.at( aName );
172 
173  COLOR_SETTINGS* ret = nullptr;
174 
175  if( !aName.empty() )
176  ret = loadColorSettingsByName( aName );
177 
178  // This had better work
179  if( !ret )
180  ret = m_color_settings.at( "_builtin_default" );
181 
182  return ret;
183 }
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
COLOR_SETTINGS * loadColorSettingsByName(const wxString &aName)
Attempts to load a color theme by name (the color theme directory and .json ext are assumed)
Color settings are a bit different than most of the settings objects in that there can be more than o...

References loadColorSettingsByName(), and m_color_settings.

Referenced by PL_EDITOR_FRAME::CommonSettingsChanged(), DIALOG_EXPORT_SVG::CreateSVGFile(), SYMBOL_EDIT_FRAME::GetColorSettings(), PANEL_EESCHEMA_COLOR_SETTINGS::PANEL_EESCHEMA_COLOR_SETTINGS(), PANEL_FP_EDITOR_COLOR_SETTINGS::PANEL_FP_EDITOR_COLOR_SETTINGS(), PANEL_PCBNEW_COLOR_SETTINGS::PANEL_PCBNEW_COLOR_SETTINGS(), PL_DRAW_PANEL_GAL::PL_DRAW_PANEL_GAL(), DIALOG_PLOT::Plot(), SCH_PRINTOUT::PrintPage(), PANEL_COLOR_SETTINGS::saveCurrentTheme(), and PANEL_SYM_COLOR_SETTINGS::TransferDataFromWindow().

◆ GetColorSettingsList()

std::vector<COLOR_SETTINGS*> SETTINGS_MANAGER::GetColorSettingsList ( )
inline

Definition at line 125 of file settings_manager.h.

126  {
127  std::vector<COLOR_SETTINGS*> ret;
128 
129  for( const std::pair<const wxString, COLOR_SETTINGS*>& entry : m_color_settings )
130  ret.push_back( entry.second );
131 
132  std::sort( ret.begin(), ret.end(), []( COLOR_SETTINGS* a, COLOR_SETTINGS* b )
133  {
134  return a->GetName() < b->GetName();
135  } );
136 
137  return ret;
138  }
const wxString & GetName() const
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
Color settings are a bit different than most of the settings objects in that there can be more than o...

References COLOR_SETTINGS::GetName(), and m_color_settings.

◆ GetColorSettingsPath()

wxString SETTINGS_MANAGER::GetColorSettingsPath ( )
static

Returns the path where color scheme files are stored; creating it if missing (normally .

/colors/ under the user settings path)

Definition at line 569 of file settings_manager.cpp.

570 {
571  wxFileName path;
572 
573  path.AssignDir( GetUserSettingsPath() );
574  path.AppendDir( "colors" );
575 
576  if( !path.DirExists() )
577  {
578  if( !wxMkdir( path.GetPath() ) )
579  {
580  wxLogTrace( traceSettings,
581  "GetColorSettingsPath(): Path %s missing and could not be created!",
582  path.GetPath() );
583  }
584  }
585 
586  return path.GetPath();
587 }
static wxString GetUserSettingsPath()
Return the user configuration path used to store KiCad's configuration files.
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.

References GetUserSettingsPath(), and traceSettings.

Referenced by GetPathForSettingsFile(), loadAllColorSettings(), loadColorSettingsByName(), PANEL_COLOR_SETTINGS::OnBtnOpenThemeFolderClicked(), PANEL_COLOR_SETTINGS::OnThemeChanged(), and SaveColorSettings().

◆ GetCommonSettings()

COMMON_SETTINGS* SETTINGS_MANAGER::GetCommonSettings ( ) const
inline

Retrieves the common settings shared by all applications.

Returns
a pointer to a loaded COMMON_SETTINGS

Definition at line 169 of file settings_manager.h.

169 { return m_common_settings; }
COMMON_SETTINGS * m_common_settings

References m_common_settings.

Referenced by SCH_EDIT_FRAME::doAutoSave(), PGM_BASE::GetCommonSettings(), and TriggerBackupIfNeeded().

◆ GetMigratedColorSettings()

COLOR_SETTINGS * SETTINGS_MANAGER::GetMigratedColorSettings ( )

Returns a color theme for storing colors migrated from legacy (5.x and earlier) settings, creating the theme if necessary.

This theme will be called "user.json" / "User".

Returns
the color settings to be used for migrating legacy settings

Definition at line 264 of file settings_manager.cpp.

265 {
266  if( !m_color_settings.count( "user" ) )
267  {
268  registerColorSettings( wxT( "user" ) );
269  m_color_settings.at( "user" )->SetName( wxT( "User" ) );
270  Save( m_color_settings.at( "user" ) );
271  }
272 
273  return m_color_settings.at( "user" );
274 }
void registerColorSettings(const wxString &aFilename)
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings

References m_color_settings, registerColorSettings(), and Save().

◆ GetOpenProjects()

std::vector< wxString > SETTINGS_MANAGER::GetOpenProjects ( ) const
Returns
a list of open projects

Definition at line 823 of file settings_manager.cpp.

824 {
825  std::vector<wxString> ret;
826 
827  for( const std::pair<const wxString, PROJECT*>& pair : m_projects )
828  ret.emplace_back( pair.first );
829 
830  return ret;
831 }
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.

References m_projects.

Referenced by KICAD_MANAGER_FRAME::canCloseWindow().

◆ GetPathForSettingsFile()

wxString SETTINGS_MANAGER::GetPathForSettingsFile ( JSON_SETTINGS aSettings)

Returns the path a given settings file should be loaded from / stored to.

Parameters
aSettingsis the settings object
Returns
a path based on aSettings->m_location

Definition at line 342 of file settings_manager.cpp.

343 {
344  wxASSERT( aSettings );
345 
346  switch( aSettings->GetLocation() )
347  {
348  case SETTINGS_LOC::USER:
349  return GetUserSettingsPath();
350 
352  return Prj().GetProjectPath();
353 
355  return GetColorSettingsPath();
356 
357  case SETTINGS_LOC::NONE:
358  return "";
359 
360  default:
361  wxASSERT_MSG( false, "Unknown settings location!" );
362  }
363 
364  return "";
365 }
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
VTBL_ENTRY const wxString GetProjectPath() const
Function GetProjectPath returns the full path of the project.
Definition: project.cpp:122
The color scheme directory (e.g. ~/.config/kicad/colors/)
The settings directory inside a project folder.
SETTINGS_LOC GetLocation() const
Definition: json_settings.h:70
No directory prepended, full path in filename (used for PROJECT_FILE)
static wxString GetColorSettingsPath()
Returns the path where color scheme files are stored; creating it if missing (normally .
static wxString GetUserSettingsPath()
Return the user configuration path used to store KiCad's configuration files.
The main config directory (e.g. ~/.config/kicad/)

References COLORS, GetColorSettingsPath(), JSON_SETTINGS::GetLocation(), PROJECT::GetProjectPath(), GetUserSettingsPath(), NONE, Prj(), PROJECT, and USER.

Referenced by FlushAndRelease(), Load(), PANEL_COLOR_SETTINGS::OnThemeChanged(), RegisterSettings(), Save(), SaveProject(), and unloadProjectFile().

◆ GetPreviousVersionPaths()

bool SETTINGS_MANAGER::GetPreviousVersionPaths ( std::vector< wxString > *  aName = nullptr)

Retreives the name of the most recent previous KiCad version that can be found in the user settings directory.

For legacy versions (5.x, and 5.99 builds before this code was written), this will return "5.x"

Parameters
aNameis filled with the name of the previous version, if one exists
Returns
true if a previous version to migrate from exists

Definition at line 492 of file settings_manager.cpp.

493 {
494  wxASSERT( aPaths );
495 
496  aPaths->clear();
497 
498  wxDir dir;
499  std::vector<wxFileName> base_paths;
500 
501  base_paths.emplace_back( wxFileName( calculateUserSettingsPath( false ), "" ) );
502 
503  // If the env override is set, also check the default paths
504  if( wxGetEnv( wxT( "KICAD_CONFIG_HOME" ), nullptr ) )
505  base_paths.emplace_back( wxFileName( calculateUserSettingsPath( false, false ), "" ) );
506 
507  wxString subdir;
508  std::string mine = GetSettingsVersion();
509 
510  auto check_dir = [&] ( const wxString& aSubDir )
511  {
512  // Only older versions are valid for migration
513  if( compareVersions( aSubDir.ToStdString(), mine ) <= 0 )
514  {
515  wxString sub_path = dir.GetNameWithSep() + aSubDir;
516 
517  if( IsSettingsPathValid( sub_path ) )
518  {
519  aPaths->push_back( sub_path );
520  wxLogTrace( traceSettings, "GetPreviousVersionName: %s is valid", sub_path );
521  }
522  }
523  };
524 
525  for( auto base_path : base_paths )
526  {
527  if( !dir.Open( base_path.GetFullPath() ) )
528  {
529  wxLogTrace( traceSettings, "GetPreviousVersionName: could not open base path %s",
530  base_path.GetFullPath() );
531  continue;
532  }
533 
534  wxLogTrace( traceSettings, "GetPreviousVersionName: checking base path %s",
535  base_path.GetFullPath() );
536 
537  if( dir.GetFirst( &subdir, wxEmptyString, wxDIR_DIRS ) )
538  {
539  if( subdir != mine )
540  check_dir( subdir );
541 
542  while( dir.GetNext( &subdir ) )
543  {
544  if( subdir != mine )
545  check_dir( subdir );
546  }
547  }
548 
549  // If we didn't find one yet, check for legacy settings without a version directory
550  if( IsSettingsPathValid( dir.GetNameWithSep() ) )
551  {
552  wxLogTrace( traceSettings,
553  "GetPreviousVersionName: root path %s is valid", dir.GetName() );
554  aPaths->push_back( dir.GetName() );
555  }
556  }
557 
558  return aPaths->size() > 0;
559 }
static bool IsSettingsPathValid(const wxString &aPath)
Checks if a given path is probably a valid KiCad configuration directory.
static int compareVersions(const std::string &aFirst, const std::string &aSecond)
Compares two settings versions, like "5.99" and "6.0".
static wxString calculateUserSettingsPath(bool aIncludeVer=true, bool aUseEnv=true)
Determines the base path for user settings files.
static std::string GetSettingsVersion()
Parses the current KiCad build version and extracts the major and minor revision to use as the name o...
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.

References calculateUserSettingsPath(), compareVersions(), GetSettingsVersion(), IsSettingsPathValid(), and traceSettings.

Referenced by DIALOG_MIGRATE_SETTINGS::TransferDataToWindow().

◆ GetProject()

PROJECT * SETTINGS_MANAGER::GetProject ( const wxString &  aFullPath) const

Retrieves a loaded project by name.

Parameters
aFullPathis the full path including name and extension to the project file
Returns
a pointer to the project if loaded, or nullptr

Definition at line 814 of file settings_manager.cpp.

815 {
816  if( m_projects.count( aFullPath ) )
817  return m_projects.at( aFullPath );
818 
819  return nullptr;
820 }
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.

References m_projects.

Referenced by GetDefaultProject(), LoadBoard(), DIALOG_SCHEMATIC_SETUP::OnAuxiliaryAction(), and DIALOG_BOARD_SETUP::OnAuxiliaryAction().

◆ GetProjectBackupsPath()

wxString SETTINGS_MANAGER::GetProjectBackupsPath ( ) const
Returns
the full path to where project backups should be stored

Definition at line 937 of file settings_manager.cpp.

938 {
940 }
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
#define PROJECT_BACKUPS_DIR_SUFFIX
Project settings path will be <projectname> + this.
VTBL_ENTRY const wxString GetProjectPath() const
Function GetProjectPath returns the full path of the project.
Definition: project.cpp:122
VTBL_ENTRY const wxString GetProjectName() const
Function GetProjectName returns the short name of the project.
Definition: project.cpp:128

References PROJECT::GetProjectName(), PROJECT::GetProjectPath(), Prj(), and PROJECT_BACKUPS_DIR_SUFFIX.

Referenced by BackupProject(), and TriggerBackupIfNeeded().

◆ GetSettingsVersion()

std::string SETTINGS_MANAGER::GetSettingsVersion ( )
static

Parses the current KiCad build version and extracts the major and minor revision to use as the name of the settings directory for this KiCad version.

Returns
a string such as "5.1"

Definition at line 642 of file settings_manager.cpp.

643 {
644  // CMake computes the major.minor string for us.
645  return GetMajorMinorVersion().ToStdString();
646 }
wxString GetMajorMinorVersion()
Get only the major and minor version in a string major.minor.

References GetMajorMinorVersion().

Referenced by calculateUserSettingsPath(), GetPreviousVersionPaths(), and DIALOG_MIGRATE_SETTINGS::TransferDataToWindow().

◆ GetUserSettingsPath()

wxString SETTINGS_MANAGER::GetUserSettingsPath ( )
static

Return the user configuration path used to store KiCad's configuration files.

See also
calculateUserSettingsPath

NOTE: The path is cached at startup, it will never change during program lifetime!

Returns
A string containing the config path for Kicad

Definition at line 590 of file settings_manager.cpp.

591 {
592  static wxString user_settings_path;
593 
594  if( user_settings_path.empty() )
595  user_settings_path = calculateUserSettingsPath();
596 
597  return user_settings_path;
598 }
static wxString calculateUserSettingsPath(bool aIncludeVer=true, bool aUseEnv=true)
Determines the base path for user settings files.

References calculateUserSettingsPath().

Referenced by getAdvancedCfgFilename(), GetColorSettingsPath(), SYMBOL_LIB_TABLE::GetGlobalTableFileName(), FP_LIB_TABLE::GetGlobalTableFileName(), GetPathForSettingsFile(), MigrateIfNeeded(), PyScriptingPath(), ReadHotKeyConfig(), ReadLegacyHotkeyConfigFile(), and WriteHotKeyConfig().

◆ IsOK()

bool SETTINGS_MANAGER::IsOK ( )
inline
Returns
true if settings load was successful

Definition at line 45 of file settings_manager.h.

45 { return m_ok; }
bool m_ok
True if settings loaded successfully at construction.

References m_ok.

◆ IsProjectOpen()

bool SETTINGS_MANAGER::IsProjectOpen ( ) const

Helper for checking if we have a project open TODO: This should be deprecated along with Prj() once we support multiple projects fully.

Returns
true if a call to Prj() will succeed

Definition at line 808 of file settings_manager.cpp.

809 {
810  return !m_projects.empty();
811 }
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.

References m_projects.

Referenced by PCB_BASE_EDIT_FRAME::doCloseWindow().

◆ IsSettingsPathValid()

bool SETTINGS_MANAGER::IsSettingsPathValid ( const wxString &  aPath)
static

Checks if a given path is probably a valid KiCad configuration directory.

Actually it just checks if a file called "kicad_common" exists, because that's probably good enough for now.

Parameters
aPathis the path to check
Returns
true if the path contains KiCad settings

Definition at line 562 of file settings_manager.cpp.

563 {
564  wxFileName test( aPath, "kicad_common" );
565  return test.Exists();
566 }

Referenced by GetPreviousVersionPaths(), and DIALOG_MIGRATE_SETTINGS::validatePath().

◆ Load() [1/2]

void SETTINGS_MANAGER::Load ( )

Definition at line 96 of file settings_manager.cpp.

97 {
98  // TODO(JE) We should check for dirty settings here and write them if so, because
99  // Load() could be called late in the application lifecycle
100 
101  for( auto&& settings : m_settings )
102  settings->LoadFromFile( GetPathForSettingsFile( settings.get() ) );
103 }
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References GetPathForSettingsFile(), and m_settings.

Referenced by PGM_BASE::InitPgm().

◆ Load() [2/2]

void SETTINGS_MANAGER::Load ( JSON_SETTINGS aSettings)

Definition at line 106 of file settings_manager.cpp.

107 {
108  auto it = std::find_if( m_settings.begin(), m_settings.end(),
109  [&aSettings]( const std::unique_ptr<JSON_SETTINGS>& aPtr )
110  {
111  return aPtr.get() == aSettings;
112  } );
113 
114  if( it != m_settings.end() )
115  ( *it )->LoadFromFile( GetPathForSettingsFile( it->get() ) );
116 }
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References GetPathForSettingsFile(), and m_settings.

◆ loadAllColorSettings()

void SETTINGS_MANAGER::loadAllColorSettings ( )
private

Definition at line 277 of file settings_manager.cpp.

278 {
279  // Create the built-in color settings
281  {
282  m_color_settings[settings->GetFilename()] =
283  static_cast<COLOR_SETTINGS*>( RegisterSettings( settings, false ) );
284  }
285 
286  // Search for and load any other settings
287  COLOR_SETTINGS_LOADER loader( [&]( const wxString& aFilename )
288  {
289  registerColorSettings( aFilename );
290  } );
291 
292  wxDir colors_dir( GetColorSettingsPath() );
293 
294  if( colors_dir.IsOpened() )
295  colors_dir.Traverse( loader );
296 }
static std::vector< COLOR_SETTINGS * > CreateBuiltinColorSettings()
Constructs and returns a list of color settings objects based on the built-in color themes.
void registerColorSettings(const wxString &aFilename)
static wxString GetColorSettingsPath()
Returns the path where color scheme files are stored; creating it if missing (normally .
JSON_SETTINGS * RegisterSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
Color settings are a bit different than most of the settings objects in that there can be more than o...

References COLOR_SETTINGS::CreateBuiltinColorSettings(), GetColorSettingsPath(), m_color_settings, registerColorSettings(), and RegisterSettings().

Referenced by ReloadColorSettings(), and SETTINGS_MANAGER().

◆ loadColorSettingsByName()

COLOR_SETTINGS * SETTINGS_MANAGER::loadColorSettingsByName ( const wxString &  aName)
private

Attempts to load a color theme by name (the color theme directory and .json ext are assumed)

Parameters
aNameis the filename of the color theme (without the extension or path)
Returns
the loaded settings, or nullptr if load failed

Definition at line 186 of file settings_manager.cpp.

187 {
188  wxLogTrace( traceSettings, "Attempting to load color theme %s", aName );
189 
190  wxFileName fn( GetColorSettingsPath(), aName, "json" );
191 
192  if( !fn.IsOk() || !fn.Exists() )
193  {
194  wxLogTrace( traceSettings, "Theme file %s.json not found, falling back to user", aName );
195  return nullptr;
196  }
197 
198  auto cs = static_cast<COLOR_SETTINGS*>(
199  RegisterSettings( new COLOR_SETTINGS( aName.ToStdString() ) ) );
200 
201  if( cs->GetFilename() != aName.ToStdString() )
202  {
203  wxLogTrace( traceSettings, "Warning: stored filename is actually %s, ", cs->GetFilename() );
204  }
205 
206  m_color_settings[aName] = cs;
207 
208  return cs;
209 }
static wxString GetColorSettingsPath()
Returns the path where color scheme files are stored; creating it if missing (normally .
JSON_SETTINGS * RegisterSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
Color settings are a bit different than most of the settings objects in that there can be more than o...
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.

References GetColorSettingsPath(), m_color_settings, RegisterSettings(), and traceSettings.

Referenced by GetColorSettings().

◆ LoadProject()

bool SETTINGS_MANAGER::LoadProject ( const wxString &  aFullPath,
bool  aSetActive = true 
)

Loads a project or sets up a new project with a specified path.

Parameters
aFullPathis the full path to the project
aSetActiveif true will set the loaded project as the active project
Returns
true if the PROJECT_FILE was successfully loaded from disk

Definition at line 712 of file settings_manager.cpp.

713 {
714  // Normalize path to new format even if migrating from a legacy file
715  wxFileName path( aFullPath );
716 
717  if( path.GetExt() == LegacyProjectFileExtension )
718  path.SetExt( ProjectFileExtension );
719 
720  wxString fullPath = path.GetFullPath();
721 
722  // If already loaded, we are all set. This might be called more than once over a project's
723  // lifetime in case the project is first loaded by the KiCad manager and then eeschema or
724  // pcbnew try to load it again when they are launched.
725  if( m_projects.count( fullPath ) )
726  return true;
727 
728  // No MDI yet
729  if( aSetActive && !m_projects.empty() )
730  {
731  PROJECT* oldProject = m_projects.begin()->second;
732  unloadProjectFile( oldProject, true );
733  m_projects.erase( m_projects.begin() );
734  }
735 
736  wxLogTrace( traceSettings, "Load project %s", fullPath );
737 
738  std::unique_ptr<PROJECT> project = std::make_unique<PROJECT>();
739  project->setProjectFullName( fullPath );
740 
741  bool success = loadProjectFile( *project );
742 
743  if( success )
744  project->SetReadOnly( project->GetProjectFile().IsReadOnly() );
745 
746  m_projects_list.push_back( std::move( project ) );
747  m_projects[fullPath] = m_projects_list.back().get();
748 
749  wxString fn( path.GetName() );
750 
751  PROJECT_LOCAL_SETTINGS* settings = static_cast<PROJECT_LOCAL_SETTINGS*>(
752  RegisterSettings( new PROJECT_LOCAL_SETTINGS( m_projects[fullPath], fn ) ) );
753 
754  m_projects[fullPath]->setLocalSettings( settings );
755 
756  if( m_kiway )
758 
759  return success;
760 }
PROJECT holds project specific data.
Definition: project.h:63
const std::string ProjectFileExtension
KIWAY * m_kiway
The kiway this settings manager interacts with.
The project local settings are things that are attached to a particular project, but also might be pa...
bool unloadProjectFile(PROJECT *aProject, bool aSave)
Optionally saves, and then unloads and unregisters the given PROJECT_FILE.
VTBL_ENTRY void ProjectChanged()
Calls ProjectChanged() on all KIWAY_PLAYERs.
Definition: kiway.cpp:538
const std::string LegacyProjectFileExtension
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.
bool loadProjectFile(PROJECT &aProject)
Registers a PROJECT_FILE and attempts to load it from disk.
JSON_SETTINGS * RegisterSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
std::vector< std::unique_ptr< PROJECT > > m_projects_list
Loaded projects (ownership here)

References LegacyProjectFileExtension, loadProjectFile(), m_kiway, m_projects, m_projects_list, KIWAY::ProjectChanged(), ProjectFileExtension, RegisterSettings(), traceSettings, and unloadProjectFile().

Referenced by KICAD_MANAGER_FRAME::CreateNewProject(), GetDefaultProject(), PGM_BASE::InitPgm(), LoadBoard(), TEST_NETLISTS_FIXTURE::loadSchematic(), TEST_SCH_SHEET_LIST_FIXTURE::loadSchematic(), DIALOG_SCHEMATIC_SETUP::OnAuxiliaryAction(), DIALOG_BOARD_SETUP::OnAuxiliaryAction(), SCH_EDIT_FRAME::OnImportProject(), KICAD_MANAGER_FRAME::OnUnarchiveFiles(), SCH_EDIT_FRAME::OpenProjectFiles(), PCB_EDIT_FRAME::OpenProjectFiles(), SCH::readSchematicFromFile(), PCB_EDIT_FRAME::SavePcbCopy(), PCB_EDIT_FRAME::SavePcbFile(), TEST_NETLIST_EXPORTER_PSPICE_SIM::TEST_NETLIST_EXPORTER_PSPICE_SIM(), and UnloadProject().

◆ loadProjectFile()

bool SETTINGS_MANAGER::loadProjectFile ( PROJECT aProject)
private

Registers a PROJECT_FILE and attempts to load it from disk.

Parameters
aProjectis the project object to load the file for
Returns
true if the PROJECT_FILE was successfully loaded

Definition at line 882 of file settings_manager.cpp.

883 {
884  wxFileName fullFn( aProject.GetProjectFullName() );
885  wxString fn( fullFn.GetName() );
886 
887  PROJECT_FILE* file =
888  static_cast<PROJECT_FILE*>( RegisterSettings( new PROJECT_FILE( fn ), false ) );
889 
890  m_project_files[aProject.GetProjectFullName()] = file;
891 
892  aProject.setProjectFile( file );
893  file->SetProject( &aProject );
894 
895  wxString path( fullFn.GetPath() );
896 
897  return file->LoadFromFile( path );
898 }
VTBL_ENTRY void setProjectFile(PROJECT_FILE *aFile)
Sets the backing store file for this project Should only be called by SETTINGS_MANGER on load.
Definition: project.h:319
std::map< wxString, PROJECT_FILE * > m_project_files
Loaded project files, mapped according to project full name.
PROJECT_FILE is the backing store for a PROJECT, in JSON format.
Definition: project_file.h:62
VTBL_ENTRY const wxString GetProjectFullName() const
Function GetProjectFullName returns the full path and name of the project.
Definition: project.cpp:116
JSON_SETTINGS * RegisterSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.

References PROJECT::GetProjectFullName(), m_project_files, RegisterSettings(), and PROJECT::setProjectFile().

Referenced by LoadProject().

◆ MigrateIfNeeded()

bool SETTINGS_MANAGER::MigrateIfNeeded ( )

Handles the initialization of the user settings directory and migration from previous KiCad versions as needed.

This method will check for the existence of the user settings path for this KiCad version. If it exists, settings load will proceed normally using that path.

If that directory is empty or does not exist, the migration wizard will be launched, which will give users the option to migrate settings from a previous KiCad version (if one is found), manually specify a directory to migrate fromm, or start with default settings.

Returns
true if migration was successful or not necessary, false otherwise

Definition at line 435 of file settings_manager.cpp.

436 {
437  if( m_headless )
438  {
439  wxLogTrace( traceSettings, "Settings migration not checked; running headless" );
440  return false;
441  }
442 
443  wxFileName path( GetUserSettingsPath(), "" );
444  wxLogTrace( traceSettings, "Using settings path %s", path.GetFullPath() );
445 
446  if( path.DirExists() )
447  {
448  wxFileName common = path;
449  common.SetName( "kicad_common" );
450  common.SetExt( "json" );
451 
452  if( common.Exists() )
453  {
454  wxLogTrace( traceSettings, "Path exists and has a kicad_common, continuing!" );
455  return true;
456  }
457  }
458 
459  // Now we have an empty path, let's figure out what to put in it
460  DIALOG_MIGRATE_SETTINGS dlg( this );
461 
462  if( dlg.ShowModal() != wxID_OK )
463  {
464  wxLogTrace( traceSettings, "Migration dialog canceled; exiting" );
465  return false;
466  }
467 
468  if( !path.DirExists() )
469  {
470  wxLogTrace( traceSettings, "Path didn't exist; creating it" );
471  path.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
472  }
473 
474  if( m_migration_source.IsEmpty() )
475  {
476  wxLogTrace( traceSettings, "No migration source given; starting with defaults" );
477  return true;
478  }
479 
480  MIGRATION_TRAVERSER traverser( m_migration_source, path.GetFullPath(), m_migrateLibraryTables );
481  wxDir source_dir( m_migration_source );
482 
483  source_dir.Traverse( traverser );
484 
485  if( !traverser.GetErrors().empty() )
486  DisplayErrorMessage( nullptr, traverser.GetErrors() );
487 
488  return true;
489 }
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition: confirm.cpp:253
bool m_migrateLibraryTables
If true, the symbol and footprint library tables will be migrated from the previous version.
wxString m_migration_source
bool m_headless
True if running outside a UI context.
static wxString GetUserSettingsPath()
Return the user configuration path used to store KiCad's configuration files.
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.

References DisplayErrorMessage(), GetUserSettingsPath(), m_headless, m_migrateLibraryTables, m_migration_source, and traceSettings.

Referenced by SETTINGS_MANAGER().

◆ Prj()

PROJECT & SETTINGS_MANAGER::Prj ( ) const

A helper while we are not MDI-capable – return the one and only project.

Returns
the loaded project

Definition at line 801 of file settings_manager.cpp.

802 {
803  // No MDI yet: First project in the list is the active project
804  return *m_projects.begin()->second;
805 }
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.

References m_projects.

Referenced by BackupProject(), PCB_EDIT_FRAME::Files_io_from_id(), GetPathForSettingsFile(), GetProjectBackupsPath(), TEST_NETLISTS_FIXTURE::loadSchematic(), TEST_SCH_SHEET_LIST_FIXTURE::loadSchematic(), PCB_EDIT_FRAME::OpenProjectFiles(), SaveProject(), SaveProjectAs(), TEST_NETLIST_EXPORTER_PSPICE_SIM::TEST_NETLIST_EXPORTER_PSPICE_SIM(), TriggerBackupIfNeeded(), and WriteDRCReport().

◆ registerColorSettings()

void SETTINGS_MANAGER::registerColorSettings ( const wxString &  aFilename)
private

Definition at line 242 of file settings_manager.cpp.

243 {
244  if( m_color_settings.count( aFilename ) )
245  return;
246 
247  m_color_settings[aFilename] = static_cast<COLOR_SETTINGS*>(
248  RegisterSettings( new COLOR_SETTINGS( aFilename ) ) );
249 }
JSON_SETTINGS * RegisterSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
Color settings are a bit different than most of the settings objects in that there can be more than o...

References m_color_settings, and RegisterSettings().

Referenced by AddNewColorSettings(), GetMigratedColorSettings(), and loadAllColorSettings().

◆ RegisterSettings()

JSON_SETTINGS * SETTINGS_MANAGER::RegisterSettings ( JSON_SETTINGS aSettings,
bool  aLoadNow = true 
)

Takes ownership of the pointer passed in.

Parameters
aSettingsis a settings object to register
Returns
a handle to the owned pointer

Definition at line 80 of file settings_manager.cpp.

81 {
82  std::unique_ptr<JSON_SETTINGS> ptr( aSettings );
83 
84  ptr->SetManager( this );
85 
86  wxLogTrace( traceSettings, "Registered new settings object <%s>", ptr->GetFullFilename() );
87 
88  if( aLoadNow )
89  ptr->LoadFromFile( GetPathForSettingsFile( ptr.get() ) );
90 
91  m_settings.push_back( std::move( ptr ) );
92  return m_settings.back().get();
93 }
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References GetPathForSettingsFile(), m_settings, and traceSettings.

Referenced by GetAppSettings(), loadAllColorSettings(), loadColorSettingsByName(), LoadProject(), loadProjectFile(), PCBCALC::IFACE::OnKifaceStart(), CV::IFACE::OnKifaceStart(), GERBV::IFACE::OnKifaceStart(), PGE::IFACE::OnKifaceStart(), PCB::IFACE::OnKifaceStart(), SCH::IFACE::OnKifaceStart(), PGM_KICAD::OnPgmInit(), registerColorSettings(), and SETTINGS_MANAGER().

◆ ReloadColorSettings()

void SETTINGS_MANAGER::ReloadColorSettings ( )

Re-scans the color themes directory, reloading any changes it finds.

Definition at line 299 of file settings_manager.cpp.

300 {
301  m_color_settings.clear();
303 }
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings

References loadAllColorSettings(), and m_color_settings.

Referenced by PANEL_EESCHEMA_COLOR_SETTINGS::PANEL_EESCHEMA_COLOR_SETTINGS(), and PANEL_FP_EDITOR_COLOR_SETTINGS::PANEL_FP_EDITOR_COLOR_SETTINGS().

◆ Save() [1/2]

void SETTINGS_MANAGER::Save ( )

Definition at line 119 of file settings_manager.cpp.

120 {
121  for( auto&& settings : m_settings )
122  {
123  // Never automatically save color settings, caller should use SaveColorSettings
124  if( dynamic_cast<COLOR_SETTINGS*>( settings.get() ) )
125  continue;
126 
127  settings->SaveToFile( GetPathForSettingsFile( settings.get() ) );
128  }
129 }
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References GetPathForSettingsFile(), and m_settings.

Referenced by GetMigratedColorSettings(), FOOTPRINT_EDITOR_SETTINGS::MigrateFromLegacy(), and COLOR_SETTINGS::migrateSchema0to1().

◆ Save() [2/2]

void SETTINGS_MANAGER::Save ( JSON_SETTINGS aSettings)

Definition at line 132 of file settings_manager.cpp.

133 {
134  auto it = std::find_if( m_settings.begin(), m_settings.end(),
135  [&aSettings]( const std::unique_ptr<JSON_SETTINGS>& aPtr )
136  {
137  return aPtr.get() == aSettings;
138  } );
139 
140  if( it != m_settings.end() )
141  {
142  wxLogTrace( traceSettings, "Saving %s", ( *it )->GetFullFilename() );
143  ( *it )->SaveToFile( GetPathForSettingsFile( it->get() ) );
144  }
145 }
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References GetPathForSettingsFile(), m_settings, and traceSettings.

◆ SaveColorSettings()

void SETTINGS_MANAGER::SaveColorSettings ( COLOR_SETTINGS aSettings,
const std::string &  aNamespace = "" 
)

Safely saves a COLOR_SETTINGS to disk, preserving any changes outside the given namespace.

A color settings namespace is one of the top-level JSON objects like "board", etc. This will preform a read-modify-write

Parameters
aSettingsis a pointer to a valid COLOR_SETTINGS object managed by SETTINGS_MANAGER
aNamespaceis the namespace of settings to save

Definition at line 306 of file settings_manager.cpp.

307 {
308  // The passed settings should already be managed
309  wxASSERT( std::find_if( m_color_settings.begin(), m_color_settings.end(),
310  [aSettings] ( const std::pair<wxString, COLOR_SETTINGS*>& el )
311  {
312  return el.second->GetFilename() == aSettings->GetFilename();
313  }
314  ) != m_color_settings.end() );
315 
316  nlohmann::json::json_pointer ptr = JSON_SETTINGS::PointerFromString( aNamespace );
317 
318  if( !aSettings->Store() )
319  {
320  wxLogTrace( traceSettings, "Color scheme %s not modified; skipping save",
321  aSettings->GetFilename(), aNamespace );
322  return;
323  }
324 
325  wxASSERT( aSettings->contains( ptr ) );
326 
327  wxLogTrace( traceSettings, "Saving color scheme %s, preserving %s", aSettings->GetFilename(),
328  aNamespace );
329 
330  nlohmann::json backup = aSettings->at( ptr );
331  wxString path = GetColorSettingsPath();
332 
333  aSettings->LoadFromFile( path );
334 
335  ( *aSettings )[ptr].update( backup );
336  aSettings->Load();
337 
338  aSettings->SaveToFile( path, true );
339 }
virtual bool Store()
Stores the current parameters into the JSON document represented by this object Note: this doesn't do...
wxString GetFilename() const
Definition: json_settings.h:64
virtual bool LoadFromFile(const wxString &aDirectory="")
Loads the backing file from disk and then calls Load()
nlohmann::json json
Definition: gerbview.cpp:39
virtual bool SaveToFile(const wxString &aDirectory="", bool aForce=false)
static wxString GetColorSettingsPath()
Returns the path where color scheme files are stored; creating it if missing (normally .
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
static nlohmann::json::json_pointer PointerFromString(std::string aPath)
Builds a JSON pointer based on a given string.
virtual void Load()
Updates the parameters of this object based on the current JSON document contents.

References GetColorSettingsPath(), JSON_SETTINGS::GetFilename(), JSON_SETTINGS::Load(), JSON_SETTINGS::LoadFromFile(), m_color_settings, JSON_SETTINGS::PointerFromString(), JSON_SETTINGS::SaveToFile(), JSON_SETTINGS::Store(), and traceSettings.

Referenced by FOOTPRINT_EDITOR_SETTINGS::MigrateFromLegacy(), PANEL_FP_EDITOR_COLOR_SETTINGS::PANEL_FP_EDITOR_COLOR_SETTINGS(), PANEL_COLOR_SETTINGS::saveCurrentTheme(), FOOTPRINT_EDIT_FRAME::SaveSettings(), and PCB_EDIT_FRAME::SaveSettings().

◆ SaveProject()

bool SETTINGS_MANAGER::SaveProject ( const wxString &  aFullPath = wxEmptyString)

Saves a loaded project.

Parameters
aFullPathis the project name to save. If empty, will save the first loaded project.
Returns
true if save was successful

Definition at line 834 of file settings_manager.cpp.

835 {
836  wxString path = aFullPath;
837 
838  if( path.empty() )
839  path = Prj().GetProjectFullName();
840 
841  // TODO: refactor for MDI
842  if( Prj().IsReadOnly() )
843  return false;
844 
845  if( !m_project_files.count( path ) )
846  return false;
847 
848  PROJECT_FILE* project = m_project_files.at( path );
849  wxString projectPath = GetPathForSettingsFile( project );
850 
851  project->SaveToFile( projectPath );
852  Prj().GetLocalSettings().SaveToFile( projectPath );
853 
854  return true;
855 }
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
VTBL_ENTRY PROJECT_LOCAL_SETTINGS & GetLocalSettings() const
Definition: project.h:149
bool SaveToFile(const wxString &aDirectory="", bool aForce=false) override
bool SaveToFile(const wxString &aDirectory="", bool aForce=false) override
std::map< wxString, PROJECT_FILE * > m_project_files
Loaded project files, mapped according to project full name.
PROJECT_FILE is the backing store for a PROJECT, in JSON format.
Definition: project_file.h:62
VTBL_ENTRY const wxString GetProjectFullName() const
Function GetProjectFullName returns the full path and name of the project.
Definition: project.cpp:116
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References PROJECT::GetLocalSettings(), GetPathForSettingsFile(), PROJECT::GetProjectFullName(), m_project_files, Prj(), PROJECT_LOCAL_SETTINGS::SaveToFile(), and PROJECT_FILE::SaveToFile().

Referenced by KICAD_MANAGER_FRAME::CloseProject(), KICAD_MANAGER_FRAME::CreateNewProject(), SCH_EDIT_FRAME::doCloseWindow(), PCB_EDIT_FRAME::Files_io_from_id(), SCH_EDIT_FRAME::OnImportProject(), SCH_EDIT_FRAME::OpenProjectFiles(), SaveBoard(), PCB_EDIT_FRAME::SavePcbCopy(), PCB_EDIT_FRAME::SavePcbFile(), SCH_EDIT_FRAME::SaveProjectSettings(), and PCB_EDIT_FRAME::SaveProjectSettings().

◆ SaveProjectAs()

void SETTINGS_MANAGER::SaveProjectAs ( const wxString &  aFullPath)

Sets the currently loaded project path and saves it (pointers remain valid)

Parameters
aFullPathis the full filename to set for the project

Definition at line 858 of file settings_manager.cpp.

859 {
860  wxString oldName = Prj().GetProjectFullName();
861 
862  // Changing this will cause UnloadProject to not save over the "old" project when loading below
863  Prj().setProjectFullName( aFullPath );
864 
865  wxFileName fn( aFullPath );
866 
867  PROJECT_FILE* project = m_project_files.at( oldName );
868  project->SetFilename( fn.GetName() );
869  project->SaveToFile( fn.GetPath() );
870 
871  Prj().GetLocalSettings().SetFilename( fn.GetName() );
872  Prj().GetLocalSettings().SaveToFile( fn.GetPath() );
873 
874  m_project_files[fn.GetFullPath()] = project;
875  m_project_files.erase( oldName );
876 
877  m_projects[fn.GetFullPath()] = m_projects[oldName];
878  m_projects.erase( oldName );
879 }
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
VTBL_ENTRY PROJECT_LOCAL_SETTINGS & GetLocalSettings() const
Definition: project.h:149
bool SaveToFile(const wxString &aDirectory="", bool aForce=false) override
bool SaveToFile(const wxString &aDirectory="", bool aForce=false) override
std::map< wxString, PROJECT_FILE * > m_project_files
Loaded project files, mapped according to project full name.
PROJECT_FILE is the backing store for a PROJECT, in JSON format.
Definition: project_file.h:62
VTBL_ENTRY const wxString GetProjectFullName() const
Function GetProjectFullName returns the full path and name of the project.
Definition: project.cpp:116
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.
VTBL_ENTRY void setProjectFullName(const wxString &aFullPathAndName)
Sets the: 1) full directory, 2) basename, and 3) extension of the project.
Definition: project.cpp:84
void SetFilename(const wxString &aFilename)
Definition: json_settings.h:68

References PROJECT::GetLocalSettings(), PROJECT::GetProjectFullName(), m_project_files, m_projects, Prj(), PROJECT_LOCAL_SETTINGS::SaveToFile(), PROJECT_FILE::SaveToFile(), JSON_SETTINGS::SetFilename(), and PROJECT::setProjectFullName().

Referenced by SCH_EDIT_FRAME::Save_File().

◆ SetKiway()

void SETTINGS_MANAGER::SetKiway ( KIWAY aKiway)
inline

Associate this setting manager with the given Kiway.

Parameters
aKiwayis the kiway this settings manager should use

Definition at line 52 of file settings_manager.h.

52 { m_kiway = aKiway; }
KIWAY * m_kiway
The kiway this settings manager interacts with.

References m_kiway.

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

◆ SetMigrateLibraryTables()

void SETTINGS_MANAGER::SetMigrateLibraryTables ( bool  aMigrate = true)
inline

Definition at line 199 of file settings_manager.h.

199 { m_migrateLibraryTables = aMigrate; }
bool m_migrateLibraryTables
If true, the symbol and footprint library tables will be migrated from the previous version.

References m_migrateLibraryTables.

Referenced by DIALOG_MIGRATE_SETTINGS::TransferDataFromWindow().

◆ SetMigrationSource()

void SETTINGS_MANAGER::SetMigrationSource ( const wxString &  aSource)
inline

Helper for DIALOG_MIGRATE_SETTINGS to specify a source for migration.

Parameters
aSourceis a directory containing settings files to migrate from (can be empty)

Definition at line 197 of file settings_manager.h.

197 { m_migration_source = aSource; }
wxString m_migration_source

References m_migration_source.

Referenced by DIALOG_MIGRATE_SETTINGS::TransferDataFromWindow().

◆ TriggerBackupIfNeeded()

bool SETTINGS_MANAGER::TriggerBackupIfNeeded ( REPORTER aReporter) const

Calls BackupProject if a new backup is needed according to the current backup policy.

Parameters
aReporteris used for progress reporting
Returns
if everything succeeded

Definition at line 1010 of file settings_manager.cpp.

1011 {
1013 
1014  if( !settings.enabled )
1015  return true;
1016 
1017  wxString prefix = Prj().GetProjectName() + '-';
1018 
1019  auto modTime =
1020  [&prefix]( const wxString& aFile )
1021  {
1022  wxDateTime dt;
1023  wxString fn( wxFileName( aFile ).GetName() );
1024  fn.Replace( prefix, "" );
1025  dt.ParseFormat( fn, backupDateTimeFormat );
1026  return dt;
1027  };
1028 
1029  // Project not saved yet
1030  if( Prj().GetProjectPath().empty() )
1031  return true;
1032 
1033  wxString backupPath = GetProjectBackupsPath();
1034 
1035  if( !wxDirExists( backupPath ) )
1036  {
1037  wxLogTrace( traceSettings, "Backup path %s doesn't exist, creating it", backupPath );
1038 
1039  if( !wxMkdir( backupPath ) )
1040  {
1041  wxLogTrace( traceSettings, "Could not create backups path! Skipping backup" );
1042  return false;
1043  }
1044  }
1045 
1046  wxDir dir( backupPath );
1047 
1048  if( !dir.IsOpened() )
1049  {
1050  wxLogTrace( traceSettings, "Could not open project backups path %s", dir.GetName() );
1051  return false;
1052  }
1053 
1054  std::vector<wxString> files;
1055 
1056  VECTOR_INSERT_TRAVERSER traverser( files,
1057  [&modTime]( const wxString& aFile )
1058  {
1059  return modTime( aFile ).IsValid();
1060  } );
1061 
1062  dir.Traverse( traverser, wxT( "*.zip" ) );
1063 
1064  // Sort newest-first
1065  std::sort( files.begin(), files.end(),
1066  [&]( const wxString& aFirst, const wxString& aSecond ) -> bool
1067  {
1068  wxDateTime first = modTime( aFirst );
1069  wxDateTime second = modTime( aSecond );
1070 
1071  return first.GetTicks() > second.GetTicks();
1072  } );
1073 
1074  // Do we even need to back up?
1075  if( !files.empty() )
1076  {
1077  wxDateTime lastTime = modTime( files[0] );
1078 
1079  if( lastTime.IsValid() )
1080  {
1081  wxTimeSpan delta = wxDateTime::Now() - modTime( files[0] );
1082 
1083  if( delta.IsShorterThan( wxTimeSpan::Seconds( settings.min_interval ) ) )
1084  return true;
1085  }
1086  }
1087 
1088  // Now that we know a backup is needed, apply the retention policy
1089 
1090  // Step 1: if we're over the total file limit, remove the oldest
1091  if( !files.empty() && settings.limit_total_files > 0 )
1092  {
1093  while( files.size() > static_cast<size_t>( settings.limit_total_files ) )
1094  {
1095  wxRemoveFile( files.back() );
1096  files.pop_back();
1097  }
1098  }
1099 
1100  // Step 2: Stay under the total size limit
1101  if( settings.limit_total_size > 0 )
1102  {
1103  wxULongLong totalSize = 0;
1104 
1105  for( const wxString& file : files )
1106  totalSize += wxFileName::GetSize( file );
1107 
1108  while( !files.empty() && totalSize > static_cast<wxULongLong>( settings.limit_total_size ) )
1109  {
1110  totalSize -= wxFileName::GetSize( files.back() );
1111  wxRemoveFile( files.back() );
1112  files.pop_back();
1113  }
1114  }
1115 
1116  // Step 3: Stay under the daily limit
1117  if( settings.limit_daily_files > 0 && files.size() > 1 )
1118  {
1119  wxDateTime day = modTime( files[0] );
1120  int num = 1;
1121 
1122  wxASSERT( day.IsValid() );
1123 
1124  std::vector<wxString> filesToDelete;
1125 
1126  for( size_t i = 1; i < files.size(); i++ )
1127  {
1128  wxDateTime dt = modTime( files[i] );
1129 
1130  if( dt.IsSameDate( day ) )
1131  {
1132  num++;
1133 
1134  if( num > settings.limit_daily_files )
1135  filesToDelete.emplace_back( files[i] );
1136  }
1137  else
1138  {
1139  day = dt;
1140  num = 1;
1141  }
1142  }
1143 
1144  for( const wxString& file : filesToDelete )
1145  wxRemoveFile( file );
1146  }
1147 
1148  return BackupProject( aReporter );
1149 }
static wxString backupDateTimeFormat
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
unsigned long long limit_total_size
Maximum total size of backups (bytes), 0 for unlimited.
bool enabled
Automatically back up the project when files are saved.
AUTO_BACKUP m_Backup
bool BackupProject(REPORTER &aReporter) const
Creates a backup archive of the current project.
COMMON_SETTINGS * GetCommonSettings() const
Retrieves the common settings shared by all applications.
wxString GetProjectBackupsPath() const
int min_interval
Minimum time, in seconds, between subsequent backups.
static bool empty(const wxTextEntryBase *aCtrl)
VTBL_ENTRY const wxString GetProjectName() const
Function GetProjectName returns the short name of the project.
Definition: project.cpp:128
int limit_daily_files
Maximum files to keep per day, 0 for unlimited.
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
int limit_total_files
Maximum number of backup archives to retain.

References backupDateTimeFormat, BackupProject(), empty(), COMMON_SETTINGS::AUTO_BACKUP::enabled, GetCommonSettings(), GetProjectBackupsPath(), PROJECT::GetProjectName(), COMMON_SETTINGS::AUTO_BACKUP::limit_daily_files, COMMON_SETTINGS::AUTO_BACKUP::limit_total_files, COMMON_SETTINGS::AUTO_BACKUP::limit_total_size, COMMON_SETTINGS::m_Backup, COMMON_SETTINGS::AUTO_BACKUP::min_interval, Prj(), and traceSettings.

Referenced by KICAD_MANAGER_FRAME::CloseProject(), SCH_EDIT_FRAME::doAutoSave(), and PCB_EDIT_FRAME::doAutoSave().

◆ UnloadProject()

bool SETTINGS_MANAGER::UnloadProject ( PROJECT aProject,
bool  aSave = true 
)

Saves, unloads and unregisters the given PROJECT.

Parameters
aProjectis the project object to unload
aSaveif true will save the project before unloading
Returns
true if the PROJECT file was successfully saved

Definition at line 763 of file settings_manager.cpp.

764 {
765  if( !aProject || !m_projects.count( aProject->GetProjectFullName() ) )
766  return false;
767 
768  if( !unloadProjectFile( aProject, aSave ) )
769  return false;
770 
771  wxString projectPath = aProject->GetProjectFullName();
772  wxLogTrace( traceSettings, "Unload project %s", projectPath );
773 
774  PROJECT* toRemove = m_projects.at( projectPath );
775  auto it = std::find_if( m_projects_list.begin(), m_projects_list.end(),
776  [&]( const std::unique_ptr<PROJECT>& ptr )
777  {
778  return ptr.get() == toRemove;
779  } );
780 
781  wxASSERT( it != m_projects_list.end() );
782  m_projects_list.erase( it );
783 
784  m_projects.erase( projectPath );
785 
786  // Immediately reload a null project; this is required until the rest of the application
787  // is refactored to not assume that Prj() always works
788  if( m_projects.empty() )
789  LoadProject( "" );
790 
791  // Remove the reference in the environment to the previous project
792  wxSetEnv( PROJECT_VAR_NAME, "" );
793 
794  if( m_kiway )
796 
797  return true;
798 }
PROJECT holds project specific data.
Definition: project.h:63
KIWAY * m_kiway
The kiway this settings manager interacts with.
#define PROJECT_VAR_NAME
A variable name whose value holds the current project directory.
Definition: project.h:38
bool unloadProjectFile(PROJECT *aProject, bool aSave)
Optionally saves, and then unloads and unregisters the given PROJECT_FILE.
VTBL_ENTRY void ProjectChanged()
Calls ProjectChanged() on all KIWAY_PLAYERs.
Definition: kiway.cpp:538
VTBL_ENTRY const wxString GetProjectFullName() const
Function GetProjectFullName returns the full path and name of the project.
Definition: project.cpp:116
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.
bool LoadProject(const wxString &aFullPath, bool aSetActive=true)
Loads a project or sets up a new project with a specified path.
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
std::vector< std::unique_ptr< PROJECT > > m_projects_list
Loaded projects (ownership here)

References PROJECT::GetProjectFullName(), LoadProject(), m_kiway, m_projects, m_projects_list, PROJECT_VAR_NAME, KIWAY::ProjectChanged(), traceSettings, and unloadProjectFile().

Referenced by KICAD_MANAGER_FRAME::CloseProject(), PCB_BASE_EDIT_FRAME::doCloseWindow(), PCB_EDIT_FRAME::Files_io_from_id(), DIALOG_SCHEMATIC_SETUP::OnAuxiliaryAction(), DIALOG_BOARD_SETUP::OnAuxiliaryAction(), SCH_EDIT_FRAME::OnImportProject(), KICAD_MANAGER_FRAME::OnUnarchiveFiles(), SCH_EDIT_FRAME::OpenProjectFiles(), PCB_EDIT_FRAME::OpenProjectFiles(), PCB_EDIT_FRAME::SavePcbCopy(), PCB_EDIT_FRAME::SavePcbFile(), and SCH_EDIT_FRAME::~SCH_EDIT_FRAME().

◆ unloadProjectFile()

bool SETTINGS_MANAGER::unloadProjectFile ( PROJECT aProject,
bool  aSave 
)
private

Optionally saves, and then unloads and unregisters the given PROJECT_FILE.

Parameters
aProjectis the project object to unload the file for
aSaveif true will save the project file before unloading
Returns
true if the PROJECT file was successfully saved

Definition at line 901 of file settings_manager.cpp.

902 {
903  if( !aProject )
904  return false;
905 
906  wxString name = aProject->GetProjectFullName();
907 
908  if( !m_project_files.count( name ) )
909  return false;
910 
912 
913  auto it = std::find_if( m_settings.begin(), m_settings.end(),
914  [&file]( const std::unique_ptr<JSON_SETTINGS>& aPtr )
915  {
916  return aPtr.get() == file;
917  } );
918 
919  if( it != m_settings.end() )
920  {
921  wxString projectPath = GetPathForSettingsFile( it->get() );
922 
923  FlushAndRelease( &aProject->GetLocalSettings(), aSave );
924 
925  if( aSave )
926  ( *it )->SaveToFile( projectPath );
927 
928  m_settings.erase( it );
929  }
930 
931  m_project_files.erase( name );
932 
933  return true;
934 }
VTBL_ENTRY PROJECT_LOCAL_SETTINGS & GetLocalSettings() const
Definition: project.h:149
std::map< wxString, PROJECT_FILE * > m_project_files
Loaded project files, mapped according to project full name.
PROJECT_FILE is the backing store for a PROJECT, in JSON format.
Definition: project_file.h:62
VTBL_ENTRY const wxString GetProjectFullName() const
Function GetProjectFullName returns the full path and name of the project.
Definition: project.cpp:116
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
const char * name
Definition: DXF_plotter.cpp:59
void FlushAndRelease(JSON_SETTINGS *aSettings, bool aSave=true)
If the given settings object is registered, save it to disk and unregister it.
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.

References FlushAndRelease(), PROJECT::GetLocalSettings(), GetPathForSettingsFile(), PROJECT::GetProjectFullName(), m_project_files, m_settings, and name.

Referenced by LoadProject(), and UnloadProject().

Member Data Documentation

◆ backupDateTimeFormat

wxString SETTINGS_MANAGER::backupDateTimeFormat = wxT( "%Y-%m-%d_%H%M%S" )
staticprivate

Definition at line 415 of file settings_manager.h.

Referenced by BackupProject(), and TriggerBackupIfNeeded().

◆ m_color_settings

◆ m_common_settings

COMMON_SETTINGS* SETTINGS_MANAGER::m_common_settings
private

Definition at line 396 of file settings_manager.h.

Referenced by GetCommonSettings(), and SETTINGS_MANAGER().

◆ m_headless

bool SETTINGS_MANAGER::m_headless
private

True if running outside a UI context.

Definition at line 386 of file settings_manager.h.

Referenced by MigrateIfNeeded().

◆ m_kiway

KIWAY* SETTINGS_MANAGER::m_kiway
private

The kiway this settings manager interacts with.

Definition at line 389 of file settings_manager.h.

Referenced by LoadProject(), SetKiway(), and UnloadProject().

◆ m_migrateLibraryTables

bool SETTINGS_MANAGER::m_migrateLibraryTables
private

If true, the symbol and footprint library tables will be migrated from the previous version.

Definition at line 401 of file settings_manager.h.

Referenced by MigrateIfNeeded(), and SetMigrateLibraryTables().

◆ m_migration_source

wxString SETTINGS_MANAGER::m_migration_source
private

Definition at line 398 of file settings_manager.h.

Referenced by MigrateIfNeeded(), and SetMigrationSource().

◆ m_ok

bool SETTINGS_MANAGER::m_ok
private

True if settings loaded successfully at construction.

Definition at line 404 of file settings_manager.h.

Referenced by IsOK(), and SETTINGS_MANAGER().

◆ m_project_files

std::map<wxString, PROJECT_FILE*> SETTINGS_MANAGER::m_project_files
private

Loaded project files, mapped according to project full name.

Definition at line 413 of file settings_manager.h.

Referenced by loadProjectFile(), SaveProject(), SaveProjectAs(), and unloadProjectFile().

◆ m_projects

std::map<wxString, PROJECT*> SETTINGS_MANAGER::m_projects
private

Loaded projects, mapped according to project full name.

Definition at line 410 of file settings_manager.h.

Referenced by GetOpenProjects(), GetProject(), IsProjectOpen(), LoadProject(), Prj(), SaveProjectAs(), UnloadProject(), and ~SETTINGS_MANAGER().

◆ m_projects_list

std::vector<std::unique_ptr<PROJECT> > SETTINGS_MANAGER::m_projects_list
private

Loaded projects (ownership here)

Definition at line 407 of file settings_manager.h.

Referenced by LoadProject(), and UnloadProject().

◆ m_settings

std::vector<std::unique_ptr<JSON_SETTINGS> > SETTINGS_MANAGER::m_settings
private

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