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" ) );
344 wxDir third_party_colors_dir( third_party_path.GetFullPath() );
354 [&](
const wxFileName& aFilename )
360 wxDir colors_dir( color_settings_path );
362 if( colors_dir.IsOpened() )
364 if( third_party_colors_dir.IsOpened() )
365 third_party_colors_dir.Traverse( thirdPartyLoader );
367 colors_dir.Traverse( loader );
383 [aSettings] (
const std::pair<wxString, COLOR_SETTINGS*>& el )
385 return el.second->GetFilename() == aSettings->GetFilename();
392 if( !aSettings->
Store() )
394 wxLogTrace(
traceSettings, wxT(
"Color scheme %s not modified; skipping save" ),
399 wxASSERT( aSettings->
Contains( aNamespace ) );
401 wxLogTrace(
traceSettings, wxT(
"Saving color scheme %s, preserving %s" ),
405 std::optional<nlohmann::json> backup = aSettings->
GetJson( aNamespace );
411 ( *aSettings->
Internals() )[aNamespace].update( *backup );
421 wxASSERT( aSettings );
425 case SETTINGS_LOC::USER:
428 case SETTINGS_LOC::PROJECT:
432 case SETTINGS_LOC::COLORS:
435 case SETTINGS_LOC::NONE:
439 wxASSERT_MSG(
false, wxT(
"Unknown settings location!" ) );
464 wxDirTraverseResult
OnFile(
const wxString& aSrcFilePath )
override
466 wxFileName file( aSrcFilePath );
469 file.GetName() == wxT(
"fp-lib-table" ) ) )
471 return wxDIR_CONTINUE;
475 if( file.GetFullName() == wxT(
"installed_packages.json" ) )
476 return wxDIR_CONTINUE;
480 if( file.GetExt() == wxT(
"hotkeys" ) )
481 return wxDIR_CONTINUE;
483 wxString
path = file.GetPath();
486 file.SetPath(
path );
488 wxLogTrace(
traceSettings, wxT(
"Copying %s to %s" ), aSrcFilePath, file.GetFullPath() );
493 return wxDIR_CONTINUE;
496 wxDirTraverseResult
OnDir(
const wxString& dirPath )
override
498 wxFileName dir( dirPath );
501 if( dir.GetName() == wxS(
"colors" ) ||
502 dir.GetName() == wxS(
"3d" ) )
505 wxString
path = dir.GetPath();
510 wxMkdir( dir.GetFullPath() );
512 return wxDIR_CONTINUE;
525 wxLogTrace(
traceSettings, wxT(
"Using settings path %s" ),
path.GetFullPath() );
532 if( !
path.DirExists() )
534 wxLogTrace(
traceSettings, wxT(
"Path didn't exist; creating it" ) );
535 path.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
538 wxLogTrace(
traceSettings, wxT(
"Settings migration not checked; running headless" ) );
542 if(
path.DirExists() )
544 wxFileName common =
path;
545 common.SetName( wxS(
"kicad_common" ) );
546 common.SetExt( wxS(
"json" ) );
548 if( common.Exists() )
550 wxLogTrace(
traceSettings, wxT(
"Path exists and has a kicad_common, continuing!" ) );
558 if( dlg.ShowModal() != wxID_OK )
560 wxLogTrace(
traceSettings, wxT(
"Migration dialog canceled; exiting" ) );
564 if( !
path.DirExists() )
566 wxLogTrace(
traceSettings, wxT(
"Path didn't exist; creating it" ) );
567 path.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
572 wxLogTrace(
traceSettings, wxT(
"No migration source given; starting with defaults" ) );
581 source_dir.Traverse( traverser );
593 const std::vector<wxString> libKeys = {
594 wxT(
"KICAD6_SYMBOL_DIR" ),
595 wxT(
"KICAD6_3DMODEL_DIR" ),
596 wxT(
"KICAD6_FOOTPRINT_DIR" ),
597 wxT(
"KICAD6_TEMPLATE_DIR" ),
598 wxT(
"KICAD7_SYMBOL_DIR" ),
599 wxT(
"KICAD7_3DMODEL_DIR" ),
600 wxT(
"KICAD7_FOOTPRINT_DIR" ),
601 wxT(
"KICAD7_TEMPLATE_DIR" ),
604 wxT(
"KICAD_PTEMPLATES" ),
607 wxT(
"KICAD_SYMBOL_DIR" ),
610 for(
const wxString& key : libKeys )
627 std::vector<wxFileName> base_paths;
632 if( wxGetEnv( wxT(
"KICAD_CONFIG_HOME" ),
nullptr ) )
642 wxFileName wxGtkPath;
643 wxGtkPath.AssignDir( wxS(
"~/.config/kicad" ) );
644 wxGtkPath.MakeAbsolute();
645 base_paths.emplace_back( wxGtkPath );
648 wxGtkPath.AssignDir( wxS(
"~/.var/app/org.kicad.KiCad/config/kicad" ) );
649 wxGtkPath.MakeAbsolute();
650 base_paths.emplace_back( wxGtkPath );
657 auto check_dir = [&] (
const wxString& aSubDir )
662 wxString sub_path = dir.GetNameWithSep() + aSubDir;
666 aPaths->push_back( sub_path );
667 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: %s is valid" ), sub_path );
672 std::set<wxString> checkedPaths;
674 for(
const wxFileName& base_path : base_paths )
676 if( checkedPaths.count( base_path.GetFullPath() ) )
679 checkedPaths.insert( base_path.GetFullPath() );
681 if( !dir.Open( base_path.GetFullPath() ) )
683 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: could not open base path %s" ),
684 base_path.GetFullPath() );
688 wxLogTrace(
traceSettings, wxT(
"GetPreviousVersionName: checking base path %s" ),
689 base_path.GetFullPath() );
691 if( dir.GetFirst( &subdir, wxEmptyString, wxDIR_DIRS ) )
696 while( dir.GetNext( &subdir ) )
707 wxT(
"GetPreviousVersionName: root path %s is valid" ), dir.GetName() );
708 aPaths->push_back( dir.GetName() );
712 std::sort( aPaths->begin(), aPaths->end(),
713 [&](
const wxString& a,
const wxString& b ) ->
bool
715 wxString verA = wxFileName::DirName( a ).GetDirs().back();
716 wxString verB = wxFileName::DirName( b ).GetDirs().back();
718 if( !extractVersion( verA.ToStdString() )
719 || !extractVersion( verB.ToStdString() ) )
727 return aPaths->size() > 0;
733 wxFileName
test( aPath, wxS(
"kicad_common" ) );
738 test.SetExt(
"json" );
740 return test.Exists();
749 path.AppendDir( wxS(
"colors" ) );
751 if( !
path.DirExists() )
753 if( !wxMkdir(
path.GetPath() ) )
756 wxT(
"GetColorSettingsPath(): Path %s missing and could not be created!" ),
761 return path.GetPath();
767 static wxString user_settings_path;
769 if( user_settings_path.empty() )
772 return user_settings_path;
783 if( aUseEnv && wxGetEnv( wxT(
"KICAD_CONFIG_HOME" ), &envstr ) && !envstr.IsEmpty() )
786 cfgpath.AssignDir( envstr );
792 cfgpath.AppendDir(
TO_STR( KICAD_CONFIG_DIR ) );
798 return cfgpath.GetPath();
818 wxLogTrace(
traceSettings, wxT(
"compareSettingsVersions: bad input (%s, %s)" ), aFirst, aSecond );
826 else if( a_maj > b_maj )
836 else if( a_min > b_min )
850 std::regex re_version(
"(\\d+)\\.(\\d+)" );
853 if( std::regex_match( aVersionString, match, re_version ) )
857 int major = std::stoi( match[1].str() );
858 int minor = std::stoi( match[2].str() );
881 wxFileName
path( aFullPath );
886 wxString fullPath =
path.GetFullPath();
894 bool readOnly =
false;
897 if( !lockFile.
Valid() )
899 wxLogTrace(
traceSettings, wxT(
"Project %s is locked; opening read-only" ), fullPath );
911 [&](
const std::unique_ptr<PROJECT>& ptr )
913 return ptr.get() == oldProject;
920 wxLogTrace(
traceSettings, wxT(
"Load project %s" ), fullPath );
922 std::unique_ptr<PROJECT>
project = std::make_unique<PROJECT>();
923 project->setProjectFullName( fullPath );
929 project->SetReadOnly( readOnly ||
project->GetProjectFile().IsReadOnly() );
938 wxString fn(
path.GetName() );
947 m_projects[fullPath]->setLocalSettings( settings );
965 wxLogTrace(
traceSettings, wxT(
"Unload project %s" ), projectPath );
969 [&](
const std::unique_ptr<PROJECT>& ptr )
971 return ptr.get() == toRemove;
1022 std::vector<wxString> ret;
1024 for(
const std::pair<const wxString, PROJECT*>& pair :
m_projects )
1025 ret.emplace_back( pair.first );
1036 wxString
path = aFullPath;
1051 project->SaveToFile( projectPath );
1065 if( aFullPath.IsSameAs( oldName ) )
1074 wxFileName fn( aFullPath );
1083 project->SetFilename( fn.GetName() );
1084 project->SaveToFile( fn.GetPath() );
1103 wxString oldName =
project->GetFilename();
1104 wxFileName fn( aFullPath );
1106 bool readOnly =
project->IsReadOnly();
1107 project->SetReadOnly(
false );
1109 project->SetFilename( fn.GetName() );
1110 project->SaveToFile( fn.GetPath() );
1111 project->SetFilename( oldName );
1119 project->SetReadOnly( readOnly );
1126 wxString fn( fullFn.GetName() );
1135 wxString
path( fullFn.GetPath() );
1154 [&file](
const std::unique_ptr<JSON_SETTINGS>& aPtr )
1156 return aPtr.get() == file;
1166 ( *it )->SaveToFile( projectPath );
1188 wxDateTime timestamp = wxDateTime::Now();
1190 wxString fileName = wxString::Format( wxT(
"%s-%s" ),
Prj().GetProjectName(),
1195 target.SetName( fileName );
1198 if( !target.DirExists() && !wxMkdir( target.GetPath() ) )
1200 wxLogTrace(
traceSettings, wxT(
"Could not create project backup path %s" ), target.GetPath() );
1204 if( !target.IsDirWritable() )
1206 wxLogTrace(
traceSettings, wxT(
"Backup directory %s is not writable" ), target.GetPath() );
1210 wxLogTrace(
traceSettings, wxT(
"Backing up project to %s" ), target.GetPath() );
1214 return archiver.
Archive(
Prj().GetProjectPath(), target.GetFullPath(), aReporter );
1222 std::function<
bool(
const wxString& )> aCond ) :
1228 wxDirTraverseResult
OnFile(
const wxString& aFile )
override
1231 m_files.emplace_back( aFile );
1233 return wxDIR_CONTINUE;
1236 wxDirTraverseResult
OnDir(
const wxString& aDirName )
override
1238 return wxDIR_CONTINUE;
1258 [&prefix](
const wxString& aFile )
1261 wxString fn( wxFileName( aFile ).GetName() );
1262 fn.Replace( prefix, wxS(
"" ) );
1267 wxFileName projectPath(
Prj().GetProjectPath() );
1270 if( !projectPath.IsOk() || !projectPath.Exists() || !projectPath.IsDirWritable() )
1275 if( !wxDirExists( backupPath ) )
1277 wxLogTrace(
traceSettings, wxT(
"Backup path %s doesn't exist, creating it" ), backupPath );
1279 if( !wxMkdir( backupPath ) )
1281 wxLogTrace(
traceSettings, wxT(
"Could not create backups path! Skipping backup" ) );
1286 wxDir dir( backupPath );
1288 if( !dir.IsOpened() )
1290 wxLogTrace(
traceSettings, wxT(
"Could not open project backups path %s" ), dir.GetName() );
1294 std::vector<wxString> files;
1297 [&modTime](
const wxString& aFile )
1299 return modTime( aFile ).IsValid();
1302 dir.Traverse( traverser, wxT(
"*.zip" ) );
1305 std::sort( files.begin(), files.end(),
1306 [&](
const wxString& aFirst,
const wxString& aSecond ) ->
bool
1308 wxDateTime first = modTime( aFirst );
1309 wxDateTime second = modTime( aSecond );
1311 return first.GetTicks() > second.GetTicks();
1315 if( !files.empty() )
1317 wxDateTime lastTime = modTime( files[0] );
1319 if( lastTime.IsValid() )
1321 wxTimeSpan
delta = wxDateTime::Now() - modTime( files[0] );
1335 wxRemoveFile( files.back() );
1343 wxULongLong totalSize = 0;
1345 for(
const wxString& file : files )
1346 totalSize += wxFileName::GetSize( file );
1348 while( !files.empty() && totalSize >
static_cast<wxULongLong
>( settings.
limit_total_size ) )
1350 totalSize -= wxFileName::GetSize( files.back() );
1351 wxRemoveFile( files.back() );
1359 wxDateTime day = modTime( files[0] );
1362 wxASSERT( day.IsValid() );
1364 std::vector<wxString> filesToDelete;
1366 for(
size_t i = 1; i < files.size(); i++ )
1368 wxDateTime dt = modTime( files[i] );
1370 if( dt.IsSameDate( day ) )
1375 filesToDelete.emplace_back( files[i] );
1384 for(
const wxString& file : filesToDelete )
1385 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 GetDefault3rdPartyPath()
Gets the default path for PCM packages.
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()
Return the user configuration path used to store KiCad's configuration files.
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.
static wxString calculateUserSettingsPath(bool aIncludeVer=true, bool aUseEnv=true)
Determines the base path for user settings files.
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.