25#include <wx/filename.h>
26#include <wx/snglinst.h>
27#include <wx/stdpaths.h>
52 m_headless( aHeadless ),
54 m_common_settings( nullptr ),
56 m_migrateLibraryTables( true )
82 for( std::unique_ptr<JSON_SETTINGS>& settings :
m_settings )
93 std::unique_ptr<JSON_SETTINGS> ptr( aSettings );
95 ptr->SetManager(
this );
97 wxLogTrace(
traceSettings, wxT(
"Registered new settings object <%s>" ), ptr->GetFullFilename() );
112 std::vector<JSON_SETTINGS*> toLoad;
116 []( std::unique_ptr<JSON_SETTINGS>& aSettings )
118 return aSettings.get();
129 [&aSettings](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
131 return aPtr.get() == aSettings;
155 [&aSettings](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
157 return aPtr.get() == aSettings;
162 wxLogTrace(
traceSettings, wxT(
"Saving %s" ), ( *it )->GetFullFilename() );
171 [&aSettings](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
173 return aPtr.get() == aSettings;
178 wxLogTrace(
traceSettings, wxT(
"Flush and release %s" ), ( *it )->GetFullFilename() );
183 size_t typeHash =
typeid( *it->get() ).hash_code();
201 [&aName](
const std::pair<wxString, COLOR_SETTINGS*>& p )
203 return p.second->GetName().Lower() == aName.Lower();
234 wxLogTrace(
traceSettings, wxT(
"Attempting to load color theme %s" ), aName );
238 if( !fn.IsOk() || !fn.Exists() )
240 wxLogTrace(
traceSettings, wxT(
"Theme file %s.json not found, falling back to user" ), aName );
246 if( settings->
GetFilename() != aName.ToStdString() )
248 wxLogTrace(
traceSettings, wxT(
"Warning: stored filename is actually %s, " ),
269 wxDirTraverseResult
OnFile(
const wxString& aFilePath )
override
271 wxFileName file( aFilePath );
273 if( file.GetExt() == wxS(
"json" ) )
276 return wxDIR_CONTINUE;
279 wxDirTraverseResult
OnDir(
const wxString& dirPath )
override
281 return wxDIR_CONTINUE;
301 if( aName.EndsWith( wxT(
".json" ) ) )
313 settings->
SetName( wxT(
"User" ) );
333 wxFileName third_party_path;
335 auto it = env.find( wxS(
"KICAD7_3RD_PARTY" ) );
337 if( it != env.end() && !it->second.GetValue().IsEmpty() )
338 third_party_path.SetPath( it->second.GetValue() );
342 third_party_path.AppendDir( wxS(
"colors" ) );
345 wxDir third_party_colors_dir( third_party_path.GetFullPath() );
360 [&](
const wxFileName& aFilename )
366 if( system_colors_dir.IsOpened() )
367 system_colors_dir.Traverse( readOnlyLoader );
369 if( third_party_colors_dir.IsOpened() )
370 third_party_colors_dir.Traverse( readOnlyLoader );
372 if( colors_dir.IsOpened() )
373 colors_dir.Traverse( loader );
388 [aSettings] (
const std::pair<wxString, COLOR_SETTINGS*>& el )
390 return el.second->GetFilename() == aSettings->GetFilename();
397 if( !aSettings->
Store() )
399 wxLogTrace(
traceSettings, wxT(
"Color scheme %s not modified; skipping save" ),
404 wxASSERT( aSettings->
Contains( aNamespace ) );
406 wxLogTrace(
traceSettings, wxT(
"Saving color scheme %s, preserving %s" ),
410 std::optional<nlohmann::json> backup = aSettings->
GetJson( aNamespace );
416 ( *aSettings->
Internals() )[aNamespace].update( *backup );
426 wxASSERT( aSettings );
430 case SETTINGS_LOC::USER:
433 case SETTINGS_LOC::PROJECT:
437 case SETTINGS_LOC::COLORS:
440 case SETTINGS_LOC::NONE:
444 wxASSERT_MSG(
false, wxT(
"Unknown settings location!" ) );
469 wxDirTraverseResult
OnFile(
const wxString& aSrcFilePath )
override
471 wxFileName file( aSrcFilePath );
474 file.GetName() == wxT(
"fp-lib-table" ) ) )
476 return wxDIR_CONTINUE;
480 if( file.GetFullName() == wxT(
"installed_packages.json" ) )
481 return wxDIR_CONTINUE;
485 if( file.GetExt() == wxT(
"hotkeys" ) )
486 return wxDIR_CONTINUE;
488 wxString
path = file.GetPath();
491 file.SetPath(
path );
493 wxLogTrace(
traceSettings, wxT(
"Copying %s to %s" ), aSrcFilePath, file.GetFullPath() );
498 return wxDIR_CONTINUE;
501 wxDirTraverseResult
OnDir(
const wxString& dirPath )
override
503 wxFileName dir( dirPath );
506 if( dir.GetName() == wxS(
"colors" ) ||
507 dir.GetName() == wxS(
"3d" ) )
510 wxString
path = dir.GetPath();
515 wxMkdir( dir.GetFullPath() );
517 return wxDIR_CONTINUE;
530 wxLogTrace(
traceSettings, wxT(
"Using settings path %s" ),
path.GetFullPath() );
537 if( !
path.DirExists() )
539 wxLogTrace(
traceSettings, wxT(
"Path didn't exist; creating it" ) );
540 path.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
543 wxLogTrace(
traceSettings, wxT(
"Settings migration not checked; running headless" ) );
547 if(
path.DirExists() )
549 wxFileName common =
path;
550 common.SetName( wxS(
"kicad_common" ) );
551 common.SetExt( wxS(
"json" ) );
553 if( common.Exists() )
555 wxLogTrace(
traceSettings, wxT(
"Path exists and has a kicad_common, continuing!" ) );
563 if( dlg.ShowModal() != wxID_OK )
565 wxLogTrace(
traceSettings, wxT(
"Migration dialog canceled; exiting" ) );
569 if( !
path.DirExists() )
571 wxLogTrace(
traceSettings, wxT(
"Path didn't exist; creating it" ) );
572 path.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
577 wxLogTrace(
traceSettings, wxT(
"No migration source given; starting with defaults" ) );
586 source_dir.Traverse( traverser );
598 const std::vector<wxString> libKeys = {
599 wxT(
"KICAD6_SYMBOL_DIR" ),
600 wxT(
"KICAD6_3DMODEL_DIR" ),
601 wxT(
"KICAD6_FOOTPRINT_DIR" ),
602 wxT(
"KICAD6_TEMPLATE_DIR" ),
603 wxT(
"KICAD7_SYMBOL_DIR" ),
604 wxT(
"KICAD7_3DMODEL_DIR" ),
605 wxT(
"KICAD7_FOOTPRINT_DIR" ),
606 wxT(
"KICAD7_TEMPLATE_DIR" ),
609 wxT(
"KICAD_PTEMPLATES" ),
612 wxT(
"KICAD_SYMBOL_DIR" ),
615 for(
const wxString& key : libKeys )
632 std::vector<wxFileName> base_paths;
637 if( wxGetEnv( wxT(
"KICAD_CONFIG_HOME" ),
nullptr ) )
647 wxFileName wxGtkPath;
648 wxGtkPath.AssignDir( wxS(
"~/.config/kicad" ) );
649 wxGtkPath.MakeAbsolute();
650 base_paths.emplace_back( wxGtkPath );
653 wxGtkPath.AssignDir( wxS(
"~/.var/app/org.kicad.KiCad/config/kicad" ) );
654 wxGtkPath.MakeAbsolute();
655 base_paths.emplace_back( wxGtkPath );
662 auto check_dir = [&] (
const wxString& aSubDir )
667 wxString sub_path = dir.GetNameWithSep() + aSubDir;
671 aPaths->push_back( sub_path );
672 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: %s is valid" ), sub_path );
677 std::set<wxString> checkedPaths;
679 for(
const wxFileName& base_path : base_paths )
681 if( checkedPaths.count( base_path.GetFullPath() ) )
684 checkedPaths.insert( base_path.GetFullPath() );
686 if( !dir.Open( base_path.GetFullPath() ) )
688 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: could not open base path %s" ),
689 base_path.GetFullPath() );
693 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: checking base path %s" ),
694 base_path.GetFullPath() );
696 if( dir.GetFirst( &subdir, wxEmptyString, wxDIR_DIRS ) )
701 while( dir.GetNext( &subdir ) )
712 wxT(
"GetPreviousVersionName: root path %s is valid" ), dir.GetName() );
713 aPaths->push_back( dir.GetName() );
717 std::sort( aPaths->begin(), aPaths->end(),
718 [&](
const wxString& a,
const wxString& b ) ->
bool
720 wxString verA = wxFileName::DirName( a ).GetDirs().back();
721 wxString verB = wxFileName::DirName( b ).GetDirs().back();
723 if( !extractVersion( verA.ToStdString() )
724 || !extractVersion( verB.ToStdString() ) )
732 return aPaths->size() > 0;
738 wxFileName
test( aPath, wxS(
"kicad_common" ) );
743 test.SetExt(
"json" );
745 return test.Exists();
754 path.AppendDir( wxS(
"colors" ) );
756 if( !
path.DirExists() )
758 if( !wxMkdir(
path.GetPath() ) )
761 wxT(
"GetColorSettingsPath(): Path %s missing and could not be created!" ),
766 return path.GetPath();
784 wxLogTrace(
traceSettings, wxT(
"compareSettingsVersions: bad input (%s, %s)" ), aFirst, aSecond );
792 else if( a_maj > b_maj )
802 else if( a_min > b_min )
816 std::regex re_version(
"(\\d+)\\.(\\d+)" );
819 if( std::regex_match( aVersionString, match, re_version ) )
823 int major = std::stoi( match[1].str() );
824 int minor = std::stoi( match[2].str() );
847 wxFileName
path( aFullPath );
852 wxString fullPath =
path.GetFullPath();
860 bool readOnly =
false;
863 if( !lockFile.
Valid() )
865 wxLogTrace(
traceSettings, wxT(
"Project %s is locked; opening read-only" ), fullPath );
877 [&](
const std::unique_ptr<PROJECT>& ptr )
879 return ptr.get() == oldProject;
886 wxLogTrace(
traceSettings, wxT(
"Load project %s" ), fullPath );
888 std::unique_ptr<PROJECT>
project = std::make_unique<PROJECT>();
889 project->setProjectFullName( fullPath );
895 project->SetReadOnly( readOnly ||
project->GetProjectFile().IsReadOnly() );
904 wxString fn(
path.GetName() );
913 m_projects[fullPath]->setLocalSettings( settings );
931 wxLogTrace(
traceSettings, wxT(
"Unload project %s" ), projectPath );
935 [&](
const std::unique_ptr<PROJECT>& ptr )
937 return ptr.get() == toRemove;
988 std::vector<wxString> ret;
990 for(
const std::pair<const wxString, PROJECT*>& pair :
m_projects )
991 ret.emplace_back( pair.first );
1002 wxString
path = aFullPath;
1017 project->SaveToFile( projectPath );
1031 if( aFullPath.IsSameAs( oldName ) )
1040 wxFileName fn( aFullPath );
1049 project->SetFilename( fn.GetName() );
1050 project->SaveToFile( fn.GetPath() );
1069 wxString oldName =
project->GetFilename();
1070 wxFileName fn( aFullPath );
1072 bool readOnly =
project->IsReadOnly();
1073 project->SetReadOnly(
false );
1075 project->SetFilename( fn.GetName() );
1076 project->SaveToFile( fn.GetPath() );
1077 project->SetFilename( oldName );
1085 project->SetReadOnly( readOnly );
1092 wxString fn( fullFn.GetName() );
1101 wxString
path( fullFn.GetPath() );
1120 [&file](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
1122 return aPtr.get() == file;
1132 ( *it )->SaveToFile( projectPath );
1154 wxDateTime timestamp = wxDateTime::Now();
1156 wxString fileName = wxString::Format( wxT(
"%s-%s" ),
Prj().GetProjectName(),
1161 target.SetName( fileName );
1164 if( !target.DirExists() && !wxMkdir( target.GetPath() ) )
1166 wxLogTrace(
traceSettings, wxT(
"Could not create project backup path %s" ), target.GetPath() );
1170 if( !target.IsDirWritable() )
1172 wxLogTrace(
traceSettings, wxT(
"Backup directory %s is not writable" ), target.GetPath() );
1176 wxLogTrace(
traceSettings, wxT(
"Backing up project to %s" ), target.GetPath() );
1180 return archiver.
Archive(
Prj().GetProjectPath(), target.GetFullPath(), aReporter );
1188 std::function<
bool(
const wxString& )> aCond ) :
1194 wxDirTraverseResult
OnFile(
const wxString& aFile )
override
1197 m_files.emplace_back( aFile );
1199 return wxDIR_CONTINUE;
1202 wxDirTraverseResult
OnDir(
const wxString& aDirName )
override
1204 return wxDIR_CONTINUE;
1224 [&prefix](
const wxString& aFile )
1227 wxString fn( wxFileName( aFile ).GetName() );
1228 fn.Replace( prefix, wxS(
"" ) );
1233 wxFileName projectPath(
Prj().GetProjectPath() );
1236 if( !projectPath.IsOk() || !projectPath.Exists() || !projectPath.IsDirWritable() )
1241 if( !wxDirExists( backupPath ) )
1243 wxLogTrace(
traceSettings, wxT(
"Backup path %s doesn't exist, creating it" ), backupPath );
1245 if( !wxMkdir( backupPath ) )
1247 wxLogTrace(
traceSettings, wxT(
"Could not create backups path! Skipping backup" ) );
1252 wxDir dir( backupPath );
1254 if( !dir.IsOpened() )
1256 wxLogTrace(
traceSettings, wxT(
"Could not open project backups path %s" ), dir.GetName() );
1260 std::vector<wxString> files;
1263 [&modTime](
const wxString& aFile )
1265 return modTime( aFile ).IsValid();
1268 dir.Traverse( traverser, wxT(
"*.zip" ) );
1271 std::sort( files.begin(), files.end(),
1272 [&](
const wxString& aFirst,
const wxString& aSecond ) ->
bool
1274 wxDateTime first = modTime( aFirst );
1275 wxDateTime second = modTime( aSecond );
1277 return first.GetTicks() > second.GetTicks();
1281 if( !files.empty() )
1283 wxDateTime lastTime = modTime( files[0] );
1285 if( lastTime.IsValid() )
1287 wxTimeSpan
delta = wxDateTime::Now() - modTime( files[0] );
1301 wxRemoveFile( files.back() );
1309 wxULongLong totalSize = 0;
1311 for(
const wxString& file : files )
1312 totalSize += wxFileName::GetSize( file );
1314 while( !files.empty() && totalSize >
static_cast<wxULongLong
>( settings.
limit_total_size ) )
1316 totalSize -= wxFileName::GetSize( files.back() );
1317 wxRemoveFile( files.back() );
1325 wxDateTime day = modTime( files[0] );
1328 wxASSERT( day.IsValid() );
1330 std::vector<wxString> filesToDelete;
1332 for(
size_t i = 1; i < files.size(); i++ )
1334 wxDateTime dt = modTime( files[i] );
1336 if( dt.IsSameDate( day ) )
1341 filesToDelete.emplace_back( files[i] );
1350 for(
const wxString& file : filesToDelete )
1351 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)
virtual bool Store()
Stores the current parameters into the JSON document represented by this object Note: this doesn't do...
wxString GetFilename() const
virtual void ProjectChanged()
Calls ProjectChanged() on all KIWAY_PLAYERs.
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.
bool Archive(const wxString &aSrcDir, const wxString &aDestFile, REPORTER &aReporter, bool aVerbose=true, bool aIncludeExtraFiles=false)
Creates an archive of the project.
The backing store for a PROJECT, in JSON format.
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
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)
Compares two settings versions, like "5.99" and "6.0".
std::unique_ptr< LOCKFILE > m_project_lock
Lock for loaded project (expand to multiple once we support MDI)
wxString GetPathForSettingsFile(JSON_SETTINGS *aSettings)
Returns the path a given settings file should be loaded from / stored to.
static std::string GetSettingsVersion()
Parses the current KiCad build version and extracts the major and minor revision to use as the name o...
void SaveProjectAs(const wxString &aFullPath, PROJECT *aProject=nullptr)
Sets the currently loaded project path and saves it (pointers remain valid) Note that this will not m...
JSON_SETTINGS * registerSettings(JSON_SETTINGS *aSettings, bool aLoadNow=true)
static wxString GetUserSettingsPath()
A proxy for PATHS::GetUserSettingsPath rather than fighting swig.
COLOR_SETTINGS * GetColorSettings(const wxString &aName="user")
Retrieves a color settings object that applications can read colors from.
T * RegisterSettings(T *aSettings, bool aLoadNow=true)
Takes ownership of the pointer passed in.
void SaveProjectCopy(const wxString &aFullPath, PROJECT *aProject=nullptr)
Saves a copy of the current project under the given path.
bool MigrateIfNeeded()
Handles the initialization of the user settings directory and migration from previous KiCad versions ...
wxString m_migration_source
void SaveColorSettings(COLOR_SETTINGS *aSettings, const std::string &aNamespace="")
Safely saves a COLOR_SETTINGS to disk, preserving any changes outside the given namespace.
bool BackupProject(REPORTER &aReporter) const
Creates a backup archive of the current project.
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)
Extracts 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.
SETTINGS_MANAGER(bool aHeadless=false)
static wxString GetColorSettingsPath()
Returns the path where color scheme files are stored; creating it if missing (normally .
COMMON_SETTINGS * GetCommonSettings() const
Retrieves the common settings shared by all applications.
bool SaveProject(const wxString &aFullPath=wxEmptyString, PROJECT *aProject=nullptr)
Saves a loaded project.
wxString GetProjectBackupsPath() const
bool LoadProject(const wxString &aFullPath, bool aSetActive=true)
Loads a project or sets up a new project with a specified path.
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)
Attempts 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 TODO: This should be deprecated along with Prj() once w...
bool GetPreviousVersionPaths(std::vector< wxString > *aName=nullptr)
Retrieves the name of the most recent previous KiCad version that can be found in the user settings d...
static bool IsSettingsPathValid(const wxString &aPath)
Checks if a given path is probably a valid KiCad configuration directory.
std::vector< std::unique_ptr< PROJECT > > m_projects_list
Loaded projects (ownership here)
void loadAllColorSettings()
PROJECT * GetProject(const wxString &aFullPath) const
Retrieves a loaded project by name.
bool UnloadProject(PROJECT *aProject, bool aSave=true)
Saves, unloads and unregisters the given PROJECT.
std::vector< wxString > GetOpenProjects() const
std::vector< std::unique_ptr< JSON_SETTINGS > > m_settings
bool TriggerBackupIfNeeded(REPORTER &aReporter) const
Calls 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 saves, and then unloads and unregisters the given PROJECT_FILE.
COLOR_SETTINGS * GetMigratedColorSettings()
Returns 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)
Registers 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)
Registers a PROJECT_FILE and attempts to load it from disk.
static wxString backupDateTimeFormat
void ReloadColorSettings()
Re-scans 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.
void KiCopyFile(const wxString &aSrcPath, const wxString &aDestPath, wxString &aErrors)
const std::string LegacyProjectFileExtension
const std::string ProjectFileExtension
const std::string ArchiveFileExtension
const wxChar *const traceSettings
Flag to enable debug output of settings operations and management.
std::map< wxString, ENV_VAR_ITEM > ENV_VAR_MAP
This file contains miscellaneous commonly used macros and functions.
#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.
KIWAY Kiway & Pgm(), KFCTL_STANDALONE
The global Program "get" accessor.
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.