25#include <wx/filename.h>
26#include <wx/snglinst.h>
27#include <wx/stdpaths.h>
81 if( !wxFileExists( commonSettings.GetFullPath() ) )
96 for( std::unique_ptr<JSON_SETTINGS>& settings :
m_settings )
107 for( std::unique_ptr<JSON_SETTINGS>& settings :
m_settings )
111 std::map<std::string, nlohmann::json> fileHistories = settings->GetFileHistories();
113 settings->Internals()->clear();
116 for(
const auto& [
path, history] : fileHistories )
117 settings->Set(
path, history );
127 for( std::unique_ptr<JSON_SETTINGS>& settings :
m_settings )
131 for(
const auto& [
path, history] : settings->GetFileHistories() )
132 settings->Set(
path, nlohmann::json::array() );
142 std::unique_ptr<JSON_SETTINGS> ptr( aSettings );
144 ptr->SetManager(
this );
146 wxLogTrace(
traceSettings, wxT(
"Registered new settings object <%s>" ),
147 ptr->GetFullFilename() );
161 std::vector<JSON_SETTINGS*> toLoad;
165 []( std::unique_ptr<JSON_SETTINGS>& aSettings )
167 return aSettings.get();
178 [&aSettings](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
180 return aPtr.get() == aSettings;
212 [&aSettings](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
214 return aPtr.get() == aSettings;
219 wxLogTrace(
traceSettings, wxT(
"Saving %s" ), ( *it )->GetFullFilename() );
228 [&aSettings](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
230 return aPtr.get() == aSettings;
235 wxLogTrace(
traceSettings, wxT(
"Flush and release %s" ), ( *it )->GetFullFilename() );
241 size_t typeHash =
typeid( *tmp ).hash_code();
259 [&aName](
const std::pair<wxString, COLOR_SETTINGS*>& p )
261 return p.second->GetName().Lower() == aName.Lower();
292 wxLogTrace(
traceSettings, wxT(
"Attempting to load color theme %s" ), aName );
296 if( !fn.IsOk() || !fn.Exists() )
298 wxLogTrace(
traceSettings, wxT(
"Theme file %s.json not found, falling back to user" ),
305 if( settings->
GetFilename() != aName.ToStdString() )
307 wxLogTrace(
traceSettings, wxT(
"Warning: stored filename is actually %s, " ),
328 wxDirTraverseResult
OnFile(
const wxString& aFilePath )
override
330 wxFileName file( aFilePath );
332 if( file.GetExt() == wxS(
"json" ) )
335 return wxDIR_CONTINUE;
338 wxDirTraverseResult
OnDir(
const wxString& dirPath )
override
340 return wxDIR_CONTINUE;
360 if( aName.EndsWith( wxT(
".json" ) ) )
372 settings->
SetName( wxT(
"User" ) );
392 wxFileName third_party_path;
396 if( it != env.end() && !it->second.GetValue().IsEmpty() )
397 third_party_path.SetPath( it->second.GetValue() );
401 third_party_path.AppendDir( wxS(
"colors" ) );
404 wxDir third_party_colors_dir( third_party_path.GetFullPath() );
419 [&](
const wxFileName& aFilename )
425 if( system_colors_dir.IsOpened() )
426 system_colors_dir.Traverse( readOnlyLoader );
428 if( third_party_colors_dir.IsOpened() )
429 third_party_colors_dir.Traverse( readOnlyLoader );
431 if( colors_dir.IsOpened() )
432 colors_dir.Traverse( loader );
447 [aSettings] (
const std::pair<wxString, COLOR_SETTINGS*>& el )
449 return el.second->GetFilename() == aSettings->GetFilename();
456 if( !aSettings->
Store() )
458 wxLogTrace(
traceSettings, wxT(
"Color scheme %s not modified; skipping save" ),
463 wxASSERT( aSettings->
Contains( aNamespace ) );
465 wxLogTrace(
traceSettings, wxT(
"Saving color scheme %s, preserving %s" ),
469 std::optional<nlohmann::json> backup = aSettings->
GetJson( aNamespace );
475 ( *aSettings->
Internals() )[aNamespace].update( *backup );
485 wxASSERT( aSettings );
506 wxASSERT_MSG(
false, wxT(
"Unknown settings location!" ) );
531 wxDirTraverseResult
OnFile(
const wxString& aSrcFilePath )
override
533 wxFileName file( aSrcFilePath );
538 return wxDIR_CONTINUE;
542 if( file.GetFullName() == wxT(
"installed_packages.json" ) )
543 return wxDIR_CONTINUE;
547 if( file.GetExt() == wxT(
"hotkeys" ) )
548 return wxDIR_CONTINUE;
550 wxString
path = file.GetPath();
553 file.SetPath(
path );
555 wxLogTrace(
traceSettings, wxT(
"Copying %s to %s" ), aSrcFilePath, file.GetFullPath() );
560 return wxDIR_CONTINUE;
563 wxDirTraverseResult
OnDir(
const wxString& dirPath )
override
565 wxFileName dir( dirPath );
568 if( dir.GetName() == wxS(
"colors" ) ||
569 dir.GetName() == wxS(
"3d" ) )
572 wxString
path = dir.GetPath();
577 wxMkdir( dir.GetFullPath() );
579 return wxDIR_CONTINUE;
592 wxLogTrace(
traceSettings, wxT(
"Using settings path %s" ),
path.GetFullPath() );
600 if( !
path.DirExists() )
602 wxLogTrace(
traceSettings, wxT(
"Path didn't exist; creating it" ) );
603 path.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
606 wxLogTrace(
traceSettings, wxT(
"Settings migration not checked; running headless" ) );
610 if(
path.DirExists() )
612 wxFileName common =
path;
613 common.SetName( wxS(
"kicad_common" ) );
614 common.SetExt( wxS(
"json" ) );
616 if( common.Exists() )
618 wxLogTrace(
traceSettings, wxT(
"Path exists and has a kicad_common, continuing!" ) );
628 wxLogTrace(
traceSettings, wxT(
"Migration dialog canceled; exiting" ) );
632 if( !
path.DirExists() )
634 wxLogTrace(
traceSettings, wxT(
"Path didn't exist; creating it" ) );
635 path.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
640 wxLogTrace(
traceSettings, wxT(
"No migration source given; starting with defaults" ) );
649 source_dir.Traverse( traverser );
661 const std::vector<wxString> libKeys = {
662 wxT(
"KICAD6_SYMBOL_DIR" ),
663 wxT(
"KICAD6_3DMODEL_DIR" ),
664 wxT(
"KICAD6_FOOTPRINT_DIR" ),
665 wxT(
"KICAD6_TEMPLATE_DIR" ),
666 wxT(
"KICAD7_SYMBOL_DIR" ),
667 wxT(
"KICAD7_3DMODEL_DIR" ),
668 wxT(
"KICAD7_FOOTPRINT_DIR" ),
669 wxT(
"KICAD7_TEMPLATE_DIR" ),
670 wxT(
"KICAD8_SYMBOL_DIR" ),
671 wxT(
"KICAD8_3DMODEL_DIR" ),
672 wxT(
"KICAD8_FOOTPRINT_DIR" ),
673 wxT(
"KICAD8_TEMPLATE_DIR" ),
676 wxT(
"KICAD_PTEMPLATES" ),
679 wxT(
"KICAD_SYMBOL_DIR" ),
682 for(
const wxString& key : libKeys )
699 std::vector<wxFileName> base_paths;
704 if( wxGetEnv( wxT(
"KICAD_CONFIG_HOME" ),
nullptr ) )
715 wxFileName wxGtkPath;
716 wxGtkPath.AssignDir( wxS(
"~/.config/kicad" ) );
717 wxGtkPath.MakeAbsolute();
718 base_paths.emplace_back( wxGtkPath );
721 wxGtkPath.AssignDir( wxS(
"~/.var/app/org.kicad.KiCad/config/kicad" ) );
722 wxGtkPath.MakeAbsolute();
723 base_paths.emplace_back( wxGtkPath );
731 [&] (
const wxString& aSubDir )
736 wxString sub_path = dir.GetNameWithSep() + aSubDir;
740 aPaths->push_back( sub_path );
741 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: %s is valid" ), sub_path );
746 std::set<wxString> checkedPaths;
748 for(
const wxFileName& base_path : base_paths )
750 if( checkedPaths.count( base_path.GetFullPath() ) )
753 checkedPaths.insert( base_path.GetFullPath() );
755 if( !dir.Open( base_path.GetFullPath() ) )
757 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: could not open base path %s" ),
758 base_path.GetFullPath() );
762 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: checking base path %s" ),
763 base_path.GetFullPath() );
765 if( dir.GetFirst( &subdir, wxEmptyString, wxDIR_DIRS ) )
770 while( dir.GetNext( &subdir ) )
781 wxT(
"GetPreviousVersionName: root path %s is valid" ), dir.GetName() );
782 aPaths->push_back( dir.GetName() );
786 std::erase_if( *aPaths,
787 [](
const wxString& aPath ) ->
bool
789 wxFileName fulldir = wxFileName::DirName( aPath );
790 const wxArrayString& dirs = fulldir.GetDirs();
792 if( dirs.empty() || !fulldir.IsDirReadable() )
795 std::string ver = dirs.back().ToStdString();
803 std::sort( aPaths->begin(), aPaths->end(),
804 [&](
const wxString& a,
const wxString& b ) ->
bool
806 wxFileName aPath = wxFileName::DirName( a );
807 wxFileName bPath = wxFileName::DirName( b );
809 const wxArrayString& aDirs = aPath.GetDirs();
810 const wxArrayString& bDirs = bPath.GetDirs();
818 std::string verA = aDirs.back().ToStdString();
819 std::string verB = bDirs.back().ToStdString();
821 if( !extractVersion( verA ) )
824 if( !extractVersion( verB ) )
827 return compareVersions( verA, verB ) >= 0;
830 return aPaths->size() > 0;
836 wxFileName
test( aPath, wxS(
"kicad_common" ) );
841 test.SetExt(
"json" );
843 return test.Exists();
852 path.AppendDir( wxS(
"colors" ) );
854 if( !
path.DirExists() )
856 if( !wxMkdir(
path.GetPath() ) )
859 wxT(
"GetColorSettingsPath(): Path %s missing and could not be created!" ),
864 return path.GetPath();
873 path.AppendDir( wxS(
"toolbars" ) );
875 if( !
path.DirExists() )
877 if( !wxMkdir(
path.GetPath() ) )
880 wxT(
"GetToolbarSettingsPath(): Path %s missing and could not be created!" ),
885 return path.GetPath();
905 wxLogTrace(
traceSettings, wxT(
"compareSettingsVersions: bad input (%s, %s)" ),
914 else if( a_maj > b_maj )
924 else if( a_min > b_min )
938 std::regex re_version(
"(\\d+)\\.(\\d+)" );
941 if( std::regex_match( aVersionString, match, re_version ) )
945 int major = std::stoi( match[1].str() );
946 int minor = std::stoi( match[2].str() );
969 wxFileName
path( aFullPath );
974 wxString fullPath =
path.GetFullPath();
984 if( !lockFile.
Valid() )
986 wxLogTrace(
traceSettings, wxT(
"Project %s is locked; opening read-only" ), fullPath );
997 [&](
const std::unique_ptr<PROJECT>& ptr )
999 return ptr.get() == oldProject;
1006 wxLogTrace(
traceSettings, wxT(
"Load project %s" ), fullPath );
1008 std::unique_ptr<PROJECT>
project = std::make_unique<PROJECT>();
1009 project->setProjectFullName( fullPath );
1015 wxFileName projectPath( fullPath );
1019 if( !projectPath.GetPath().IsEmpty() && wxTheApp && wxTheApp->IsGUI() )
1020 wxSetWorkingDirectory( projectPath.GetPath() );
1029 if( lockFile && aSetActive )
1036 wxString fn(
path.GetName() );
1045 m_projects[fullPath]->setLocalSettings( settings );
1063 wxLogTrace(
traceSettings, wxT(
"Unload project %s" ), projectPath );
1069 [&](
const std::unique_ptr<PROJECT>& ptr )
1071 return ptr.get() == toRemove;
1079 if( wasActiveProject )
1114 && !
m_projects.begin()->second->GetProjectFullName().IsEmpty() );
1129 std::vector<wxString> ret;
1131 for(
const std::pair<const wxString, PROJECT*>& pair :
m_projects )
1134 if( !pair.first.IsEmpty() )
1135 ret.emplace_back( pair.first );
1147 wxString
path = aFullPath;
1162 project->SaveToFile( projectPath );
1176 if( aFullPath.IsSameAs( oldName ) )
1185 wxFileName fn( aFullPath );
1194 project->SetFilename( fn.GetName() );
1195 project->SaveToFile( fn.GetPath() );
1214 wxString oldName =
project->GetFilename();
1215 wxFileName fn( aFullPath );
1217 bool readOnly =
project->IsReadOnly();
1218 project->SetReadOnly(
false );
1220 project->SetFilename( fn.GetName() );
1221 project->SaveToFile( fn.GetPath() );
1222 project->SetFilename( oldName );
1230 project->SetReadOnly( readOnly );
1237 wxString fn( fullFn.GetName() );
1246 wxString
path( fullFn.GetPath() );
1268 [&file](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
1270 return aPtr.get() == file;
1282 ( *it )->SaveToFile( projectPath );
1304 wxDateTime timestamp = wxDateTime::Now();
1306 wxString fileName = wxString::Format( wxT(
"%s-%s" ),
Prj().GetProjectName(),
1309 if( !aTarget.IsOk() )
1312 aTarget.SetName( fileName );
1316 if( !aTarget.DirExists() && !wxMkdir( aTarget.GetPath() ) )
1318 wxLogTrace(
traceSettings, wxT(
"Could not create project backup path %s" ),
1319 aTarget.GetPath() );
1323 if( !aTarget.IsDirWritable() )
1325 wxLogTrace(
traceSettings, wxT(
"Backup directory %s is not writable" ),
1326 aTarget.GetPath() );
1330 wxLogTrace(
traceSettings, wxT(
"Backing up project to %s" ), aTarget.GetPath() );
1340 std::function<
bool(
const wxString& )> aCond ) :
1346 wxDirTraverseResult
OnFile(
const wxString& aFile )
override
1349 m_files.emplace_back( aFile );
1351 return wxDIR_CONTINUE;
1354 wxDirTraverseResult
OnDir(
const wxString& aDirName )
override
1356 return wxDIR_CONTINUE;
1376 [&prefix](
const wxString& aFile )
1379 wxString fn( wxFileName( aFile ).GetName() );
1380 fn.Replace( prefix, wxS(
"" ) );
1385 wxFileName projectPath(
Prj().GetProjectPath(), wxEmptyString, wxEmptyString );
1388 if( !projectPath.IsOk() || !projectPath.Exists() || !projectPath.IsDirWritable() )
1393 if( !wxDirExists( backupPath ) )
1395 wxLogTrace(
traceSettings, wxT(
"Backup path %s doesn't exist, creating it" ), backupPath );
1397 if( !wxMkdir( backupPath ) )
1399 wxLogTrace(
traceSettings, wxT(
"Could not create backups path! Skipping backup" ) );
1404 wxDir dir( backupPath );
1406 if( !dir.IsOpened() )
1408 wxLogTrace(
traceSettings, wxT(
"Could not open project backups path %s" ), dir.GetName() );
1412 std::vector<wxString> files;
1415 [&modTime](
const wxString& aFile )
1417 return modTime( aFile ).IsValid();
1420 dir.Traverse( traverser, wxT(
"*.zip" ) );
1423 std::sort( files.begin(), files.end(),
1424 [&](
const wxString& aFirst,
const wxString& aSecond ) ->
bool
1426 wxDateTime first = modTime( aFirst );
1427 wxDateTime second = modTime( aSecond );
1429 return first.GetTicks() > second.GetTicks();
1433 if( !files.empty() )
1435 wxDateTime lastTime = modTime( files[0] );
1437 if( lastTime.IsValid() )
1439 wxTimeSpan
delta = wxDateTime::Now() - modTime( files[0] );
1450 if( !backupSuccessful )
1454 files.insert( files.begin(), target.GetFullPath() );
1457 if( files.size() >= 2
1460 wxRemoveFile( files[0] );
1471 wxRemoveFile( files.back() );
1479 wxULongLong totalSize = 0;
1481 for(
const wxString& file : files )
1482 totalSize += wxFileName::GetSize( file );
1484 while( !files.empty() && totalSize >
static_cast<wxULongLong
>( settings.
limit_total_size ) )
1486 totalSize -= wxFileName::GetSize( files.back() );
1487 wxRemoveFile( files.back() );
1495 wxDateTime day = modTime( files[0] );
1498 wxASSERT( day.IsValid() );
1500 std::vector<wxString> filesToDelete;
1502 for(
size_t i = 1; i < files.size(); i++ )
1504 wxDateTime dt = modTime( files[i] );
1506 if( dt.IsSameDate( day ) )
1511 filesToDelete.emplace_back( files[i] );
1520 for(
const wxString& file : filesToDelete )
1521 wxRemoveFile( file );
wxString GetMajorMinorVersion()
Get only the major and minor version in a string major.minor.
Color settings are a bit different than most of the settings objects in that there can be more than o...
void SetName(const wxString &aName)
static std::vector< COLOR_SETTINGS * > CreateBuiltinColorSettings()
Constructs and returns a list of color settings objects based on the built-in color themes.
static const wxString COLOR_BUILTIN_DEFAULT
std::function< void(const wxFileName &)> m_action
JSON_DIR_TRAVERSER(std::function< void(const wxFileName &)> aAction)
wxDirTraverseResult OnDir(const wxString &dirPath) override
wxDirTraverseResult OnFile(const wxString &aFilePath) override
std::optional< nlohmann::json > GetJson(const std::string &aPath) const
Fetches a JSON object that is a subset of this JSON_SETTINGS object, using a path of the form "key1....
bool Contains(const std::string &aPath) const
SETTINGS_LOC GetLocation() const
virtual bool LoadFromFile(const wxString &aDirectory="")
Loads the backing file from disk and then calls Load()
virtual void Load()
Updates the parameters of this object based on the current JSON document contents.
void SetReadOnly(bool aReadOnly)
JSON_SETTINGS_INTERNALS * Internals()
void SetFilename(const wxString &aFilename)
virtual bool SaveToFile(const wxString &aDirectory="", bool aForce=false)
Calls Store() and then writes the contents of the JSON document to a file.
virtual bool Store()
Stores the current parameters into the JSON document represented by this object Note: this doesn't do...
wxString GetFilename() const
wxDirTraverseResult OnDir(const wxString &dirPath) override
MIGRATION_TRAVERSER(const wxString &aSrcDir, const wxString &aDestDir, bool aMigrateTables)
wxDirTraverseResult OnFile(const wxString &aSrcFilePath) override
static wxString CalculateUserSettingsPath(bool aIncludeVer=true, bool aUseEnv=true)
Determines the base path for user settings files.
static wxString GetDefault3rdPartyPath()
Gets the default path for PCM packages.
static wxString GetStockDataPath(bool aRespectRunFromBuildDir=true)
Gets the stock (install) data path, which is the base path for things like scripting,...
static wxString GetUserSettingsPath()
Return the user configuration path used to store KiCad's configuration files.
virtual ENV_VAR_MAP & GetLocalEnvVariables() const
static bool Archive(const wxString &aSrcDir, const wxString &aDestFile, REPORTER &aReporter, bool aVerbose=true, bool aIncludeExtraFiles=false)
Create an archive of the project.
static bool AreZipArchivesIdentical(const wxString &aZipFileA, const wxString &aZipFileB, REPORTER &aReporter)
Compare the CRCs of all the files in zip archive to determine whether the archives are identical.
The backing store for a PROJECT, in JSON format.
bool ShouldAutoSave() const
void SetProject(PROJECT *aProject)
The project local settings are things that are attached to a particular project, but also might be pa...
bool SaveToFile(const wxString &aDirectory="", bool aForce=false) override
Calls Store() and then writes the contents of the JSON document to a file.
bool ShouldAutoSave() const
Container for project specific data.
virtual void setProjectFile(PROJECT_FILE *aFile)
Set the backing store file for this project.
virtual bool IsReadOnly() const
virtual const wxString GetProjectFullName() const
Return the full path and name of the project.
virtual const wxString GetProjectPath() const
Return the full path of the project.
virtual const wxString GetProjectName() const
Return the short name of the project.
virtual PROJECT_LOCAL_SETTINGS & GetLocalSettings() const
virtual void setProjectFullName(const wxString &aFullPathAndName)
Set the full directory, basename, and extension of the project.
A pure virtual class used to derive REPORTER objects from.
static int compareVersions(const std::string &aFirst, const std::string &aSecond)
Compare two settings versions, like "5.99" and "6.0".
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Return the path a given settings file should be loaded from / stored to.
static std::string GetSettingsVersion()
Parse the current KiCad build version and extracts the major and minor revision to use as the name of...
void SaveProjectAs(const wxString &aFullPath, PROJECT *aProject=nullptr)
Set the currently loaded project path and saves it (pointers remain valid).
JSON_SETTINGS * registerSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
static wxString GetUserSettingsPath()
A proxy for PATHS::GetUserSettingsPath() rather than fighting swig.
T * RegisterSettings(T *aSettings, bool aLoadNow=true)
Take ownership of the pointer passed in.
void SaveProjectCopy(const wxString &aFullPath, PROJECT *aProject=nullptr)
Save a copy of the current project under the given path.
bool MigrateIfNeeded()
Handle the initialization of the user settings directory and migration from previous KiCad versions a...
wxString m_migration_source
void SaveColorSettings(COLOR_SETTINGS *aSettings, const std::string &aNamespace="")
Safely save a COLOR_SETTINGS to disk, preserving any changes outside the given namespace.
std::map< wxString, PROJECT * > m_projects
Loaded projects, mapped according to project full name.
static bool extractVersion(const std::string &aVersionString, int *aMajor=nullptr, int *aMinor=nullptr)
Extract the numeric version from a given settings string.
COLOR_SETTINGS * registerColorSettings(const wxString &aFilename, bool aAbsolutePath=false)
bool m_headless
True if running outside a UI context.
COLOR_SETTINGS * GetColorSettings(const wxString &aName)
Retrieve a color settings object that applications can read colors from.
SETTINGS_MANAGER(bool aHeadless=false)
static wxString GetColorSettingsPath()
Return the path where color scheme files are stored; creating it if missing (normally .
COMMON_SETTINGS * GetCommonSettings() const
Retrieve the common settings shared by all applications.
bool SaveProject(const wxString &aFullPath=wxEmptyString, PROJECT *aProject=nullptr)
Save a loaded project.
void ClearFileHistory()
Clear saved file history from all settings files.
wxString GetProjectBackupsPath() const
bool LoadProject(const wxString &aFullPath, bool aSetActive=true)
Load a project or sets up a new project with a specified path.
void ResetToDefaults()
Reset all program settings to defaults.
std::map< wxString, PROJECT_FILE * > m_project_files
Loaded project files, mapped according to project full name.
std::unordered_map< wxString, COLOR_SETTINGS * > m_color_settings
COLOR_SETTINGS * loadColorSettingsByName(const wxString &aName)
Attempt to load a color theme by name (the color theme directory and .json ext are assumed).
bool IsProjectOpen() const
Helper for checking if we have a project open.
static wxString GetToolbarSettingsPath()
Return the path where toolbar configuration files are stored; creating it if missing (normally .
bool GetPreviousVersionPaths(std::vector< wxString > *aName=nullptr)
Retrieve the name of the most recent previous KiCad version that can be found in the user settings di...
static bool IsSettingsPathValid(const wxString &aPath)
Check if a given path is probably a valid KiCad configuration directory.
bool BackupProject(REPORTER &aReporter, wxFileName &aTarget) const
Create a backup archive of the current project.
std::vector< std::unique_ptr< PROJECT > > m_projects_list
Loaded projects (ownership here).
void loadAllColorSettings()
PROJECT * GetProject(const wxString &aFullPath) const
Retrieve a loaded project by name.
bool UnloadProject(PROJECT *aProject, bool aSave=true)
Save, unload and unregister the given PROJECT.
std::vector< wxString > GetOpenProjects() const
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
bool TriggerBackupIfNeeded(REPORTER &aReporter) const
Call BackupProject() if a new backup is needed according to the current backup policy.
bool m_migrateLibraryTables
If true, the symbol and footprint library tables will be migrated from the previous version.
bool unloadProjectFile(PROJECT *aProject, bool aSave)
Optionally save, unload and unregister the given PROJECT_FILE.
COLOR_SETTINGS * GetMigratedColorSettings()
Return a color theme for storing colors migrated from legacy (5.x and earlier) settings,...
std::unordered_map< size_t, JSON_SETTINGS * > m_app_settings_cache
Cache for app settings.
COLOR_SETTINGS * AddNewColorSettings(const wxString &aFilename)
Register a new color settings object with the given filename.
bool m_ok
True if settings loaded successfully at construction.
void registerBuiltinColorSettings()
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
bool loadProjectFile(PROJECT &aProject)
Register a PROJECT_FILE and attempt to load it from disk.
bool IsProjectOpenNotDummy() const
Helper for checking if we have a project open that is not a dummy project.
static wxString backupDateTimeFormat
void ReloadColorSettings()
Re-scan the color themes directory, reloading any changes it finds.
COMMON_SETTINGS * m_common_settings
KIWAY * m_kiway
The kiway this settings manager interacts with.
void FlushAndRelease(JSON_SETTINGS *aSettings, bool aSave=true)
If the given settings object is registered, save it to disk and unregister it.
wxDirTraverseResult OnFile(const wxString &aFile) override
wxDirTraverseResult OnDir(const wxString &aDirName) override
std::vector< wxString > & m_files
VECTOR_INSERT_TRAVERSER(std::vector< wxString > &aVec, std::function< bool(const wxString &)> aCond)
std::function< bool(const wxString &)> m_condition
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
This file is part of the common library.
Functions related to environment variables, including help functions.
void KiCopyFile(const wxString &aSrcPath, const wxString &aDestPath, wxString &aErrors)
static const std::string SymbolLibraryTableFileName
static const std::string ProjectFileExtension
static const std::string LegacyProjectFileExtension
static const std::string FootprintLibraryTableFileName
static const std::string ArchiveFileExtension
std::map< wxString, ENV_VAR_ITEM > ENV_VAR_MAP
@ TOOLBARS
The toolbar directory (e.g. ~/.config/kicad/toolbars/)
@ PROJECT
The settings directory inside a project folder.
@ USER
The main config directory (e.g. ~/.config/kicad/)
@ COLORS
The color scheme directory (e.g. ~/.config/kicad/colors/)
@ NONE
No directory prepended, full path in filename (used for PROJECT_FILE)
This file contains miscellaneous commonly used macros and functions.
KICOMMON_API wxString GetVersionedEnvVarName(const wxString &aBaseName)
Construct a versioned environment variable based on this KiCad major version.
PGM_BASE & Pgm()
The global program "get" accessor.
#define PROJECT_VAR_NAME
A variable name whose value holds the current project directory.
#define PROJECT_BACKUPS_DIR_SUFFIX
Project settings path will be <projectname> + this.
int min_interval
Minimum time, in seconds, between subsequent backups.
unsigned long long limit_total_size
Maximum total size of backups (bytes), 0 for unlimited.
int limit_total_files
Maximum number of backup archives to retain.
int limit_daily_files
Maximum files to keep per day, 0 for unlimited.
bool enabled
Automatically back up the project when files are saved.
Definition of file extensions used in Kicad.