diff options
Diffstat (limited to 'library/process_xml.cpp')
| -rw-r--r-- | library/process_xml.cpp | 1646 |
1 files changed, 700 insertions, 946 deletions
diff --git a/library/process_xml.cpp b/library/process_xml.cpp index 0e591116..1b5f6360 100644 --- a/library/process_xml.cpp +++ b/library/process_xml.cpp @@ -1,44 +1,30 @@ -// ************************************************************************** +// ************************************************************************** // * This file is part of the FreeFileSync project. It is distributed under * // * GNU General Public License: http://www.gnu.org/licenses/gpl.html * // * Copyright (C) 2008-2011 ZenJu (zhnmju123 AT gmx.de) * // ************************************************************************** // #include "process_xml.h" +#include <zenxml/zenxml.h> #include "../shared/i18n.h" #include "../shared/global_func.h" #include "../shared/standard_paths.h" #include "../shared/string_conv.h" #include "../shared/file_handling.h" +#include "../shared/file_io.h" +#include "../shared/xml_base.h" using namespace zen; -using namespace xmlAccess; //functionally needed!!! - - -XmlType xmlAccess::getXmlType(const wxString& filename) //throw() -{ - try - { - TiXmlDocument doc; - loadXmlDocument(filename, doc); //throw (XmlError) - return getXmlType(doc); - } - catch (const XmlError&) {} - - return XML_TYPE_OTHER; -} +using namespace xmlAccess; //functionally needed for correct overload resolution!!! -XmlType xmlAccess::getXmlType(const TiXmlDocument& doc) //throw() +XmlType getXmlType(const zen::XmlDoc& doc) //throw() { - const TiXmlElement* root = doc.RootElement(); - if (root && root->ValueStr() == std::string("FreeFileSync")) + if (doc.root().getNameAs<std::string>() == "FreeFileSync") { - const char* cfgType = root->Attribute("XmlType"); - if (cfgType) + std::string type; + if (doc.root().getAttribute("XmlType", type)) { - const std::string type(cfgType); - if (type == "GUI") return XML_TYPE_GUI; else if (type == "BATCH") @@ -51,1288 +37,1056 @@ XmlType xmlAccess::getXmlType(const TiXmlDocument& doc) //throw() } -void xmlAccess::initXmlDocument(TiXmlDocument& doc, XmlType type) //throw() +XmlType xmlAccess::getXmlType(const wxString& filename) //throw() { - TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "UTF-8", ""); //delete won't be necessary later; ownership passed to TiXmlDocument! - doc.LinkEndChild(decl); + XmlDoc doc; + try + { + std::string stream = loadStream(filename); //throw XmlFileError + parse(stream, doc); //throw XmlParsingError + } + catch (const zen::XmlError&) //catch XmlFileError, XmlParsingError + { + return XML_TYPE_OTHER; + } + return ::getXmlType(doc); +} - TiXmlElement* root = new TiXmlElement("FreeFileSync"); - doc.LinkEndChild(root); +void setXmlType(XmlDoc& doc, XmlType type) //throw() +{ switch (type) { case XML_TYPE_GUI: - addXmlAttribute("XmlType", "GUI", doc.RootElement()); + doc.root().setAttribute("XmlType", "GUI"); break; case XML_TYPE_BATCH: - addXmlAttribute("XmlType", "BATCH", doc.RootElement()); + doc.root().setAttribute("XmlType", "BATCH"); break; case XML_TYPE_GLOBAL: - addXmlAttribute("XmlType", "GLOBAL", doc.RootElement()); + doc.root().setAttribute("XmlType", "GLOBAL"); break; case XML_TYPE_OTHER: + assert(false); break; } } +//################################################################################################################ -class FfsXmlErrorLogger : public xmlAccess::XmlErrorLogger -{ -public: - //read gui settings, all values retrieved are optional, so check for initial values! (== -1) - void readConfig(const TiXmlElement* root, xmlAccess::XmlGuiConfig& outputCfg); - //read batch settings, all values retrieved are optional - void readConfig(const TiXmlElement* root, xmlAccess::XmlBatchConfig& outputCfg); - //read global settings, valid for both GUI and batch mode, independent from configuration - void readConfig(const TiXmlElement* root, xmlAccess::XmlGlobalSettings& outputCfg); - -private: - //read alternate configuration (optional) => might point to NULL - void readConfig(const TiXmlElement& folderPair, FolderPairEnh& enhPair); - void readFilter(const TiXmlElement& parent, FilterConfig& output); - - //read basic FreefileSync settings (used by commandline and GUI) - void readConfig(const TiXmlElement* root, MainConfiguration& mainCfg); -}; - - - -bool readXmlElement(const std::string& name, const TiXmlElement* parent, CompareVariant& output) +wxString xmlAccess::getGlobalConfigFile() { - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) - { - if (dummy == "ByTimeAndSize") - output = zen::CMP_BY_TIME_SIZE; - else if (dummy == "ByContent") - output = zen::CMP_BY_CONTENT; - else - return false; - - return true; - } - else - return false; + return zen::getConfigDir() + wxT("GlobalSettings.xml"); } -bool readXmlElement(const std::string& name, const TiXmlElement* parent, SyncDirection& output) +void xmlAccess::OptionalDialogs::resetDialogs() { - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) - { - if (dummy == "left") - output = SYNC_DIR_LEFT; - else if (dummy == "right") - output = SYNC_DIR_RIGHT; - else //treat all other input as "none" - output = SYNC_DIR_NONE; - - return true; - } - else - return false; + warningDependentFolders = true; + warningMultiFolderWriteAccess = true; + warningSignificantDifference = true; + warningNotEnoughDiskSpace = true; + warningUnresolvedConflicts = true; + warningSyncDatabase = true; + popupOnConfigChange = true; + showSummaryBeforeSync = true; } -bool readXmlElement(const std::string& name, const TiXmlElement* parent, xmlAccess::OnError& output) +xmlAccess::XmlGuiConfig xmlAccess::convertBatchToGui(const xmlAccess::XmlBatchConfig& batchCfg) { - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) - { - if (dummy == "Ignore") - output = xmlAccess::ON_ERROR_IGNORE; - else if (dummy == "Exit") - output = xmlAccess::ON_ERROR_EXIT; - else //treat all other input as popup - output = xmlAccess::ON_ERROR_POPUP; - - return true; - } - else - return false; + XmlGuiConfig output; + output.mainCfg = batchCfg.mainCfg; + return output; } -bool readXmlElement(const std::string& name, const TiXmlElement* parent , OnGuiError& output) +xmlAccess::XmlBatchConfig xmlAccess::convertGuiToBatch(const xmlAccess::XmlGuiConfig& guiCfg) { - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) - { - if (dummy == "Popup") - output = ON_GUIERROR_POPUP; - else if (dummy == "Ignore") - output = ON_GUIERROR_IGNORE; - else - return false; - - return true; - } - return false; -} - + XmlBatchConfig output; + output.mainCfg = guiCfg.mainCfg; -bool readXmlElement(const std::string& name, const TiXmlElement* parent , zen::DeletionPolicy& output) -{ - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) + switch (guiCfg.handleError) { - if (dummy == "DeletePermanently") - output = zen::DELETE_PERMANENTLY; - else if (dummy == "MoveToRecycleBin") - output = zen::MOVE_TO_RECYCLE_BIN; - else if (dummy == "MoveToCustomDirectory") - output = zen::MOVE_TO_CUSTOM_DIRECTORY; - else - return false; - - return true; + case ON_GUIERROR_POPUP: + output.handleError = xmlAccess::ON_ERROR_POPUP; + break; + case ON_GUIERROR_IGNORE: + output.handleError = xmlAccess::ON_ERROR_IGNORE; + break; } - return false; -} - - -bool readXmlElement(const std::string& name, const TiXmlElement* parent , zen::SymLinkHandling& output) -{ - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) - { - if (dummy == "Ignore") - output = zen::SYMLINK_IGNORE; - else if (dummy == "UseDirectly") - output = zen::SYMLINK_USE_DIRECTLY; - else if (dummy == "FollowLink") - output = zen::SYMLINK_FOLLOW_LINK; - else - return false; - return true; - } - return false; + return output; } -bool readXmlElement(const std::string& name, const TiXmlElement* parent , zen::UnitTime& output) +xmlAccess::MergeType xmlAccess::getMergeType(const std::vector<wxString>& filenames) //throw () { - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) - { - if (dummy == "Inactive") - output = zen::UTIME_NONE; - else if (dummy == "Second") - output = zen::UTIME_SEC; - else if (dummy == "Minute") - output = zen::UTIME_MIN; - else if (dummy == "Hour") - output = zen::UTIME_HOUR; - else if (dummy == "Day") - output = zen::UTIME_DAY; - else - return false; - - return true; - } - return false; -} - + bool guiCfgExists = false; + bool batchCfgExists = false; -bool readXmlElement(const std::string& name, const TiXmlElement* parent , zen::UnitSize& output) -{ - std::string dummy; - if (xmlAccess::readXmlElement(name, parent, dummy)) + for (std::vector<wxString>::const_iterator i = filenames.begin(); i != filenames.end(); ++i) { - if (dummy == "Inactive") - output = zen::USIZE_NONE; - else if (dummy == "Byte") - output = zen::USIZE_BYTE; - else if (dummy == "KB") - output = zen::USIZE_KB; - else if (dummy == "MB") - output = zen::USIZE_MB; - else - return false; - - return true; - } - return false; -} + switch (xmlAccess::getXmlType(*i)) //throw() + { + case XML_TYPE_GUI: + guiCfgExists = true; + break; + case XML_TYPE_BATCH: + batchCfgExists = true; + break; -bool readXmlElement(const std::string& name, const TiXmlElement* parent , zen::SyncConfig::Variant& output) -{ - std::string dummy; - if (!xmlAccess::readXmlElement(name, parent, dummy)) - return false; + case XML_TYPE_GLOBAL: + case XML_TYPE_OTHER: + return MERGE_OTHER; + } + } - if (dummy == "Automatic") - output = SyncConfig::AUTOMATIC; - else if (dummy == "Mirror") - output = SyncConfig::MIRROR; - else if (dummy == "Update") - output = SyncConfig::UPDATE; - else if (dummy == "Custom") - output = SyncConfig::CUSTOM; + if (guiCfgExists && batchCfgExists) + return MERGE_GUI_BATCH; + else if (guiCfgExists && !batchCfgExists) + return MERGE_GUI; + else if (!guiCfgExists && batchCfgExists) + return MERGE_BATCH; else - return false; - - return true; + return MERGE_OTHER; } -bool readXmlElement(const std::string& name, const TiXmlElement* parent, Zstring& output) +namespace { - wxString dummy; - if (!xmlAccess::readXmlElement(name, parent, dummy)) - return false; - - output = wxToZ(dummy); - return true; -} - - -bool readXmlAttribute(const std::string& name, const TiXmlElement* node, xmlAccess::ColumnTypes& output) +template <class XmlCfg> +XmlCfg loadCfgImpl(const wxString& filename, std::unique_ptr<xmlAccess::FfsXmlError>& exeption) //throw (xmlAccess::FfsXmlError) { - int dummy = 0; - if (xmlAccess::readXmlAttribute(name, node, dummy)) + XmlCfg cfg; + try { - output = static_cast<xmlAccess::ColumnTypes>(dummy); - return true; + xmlAccess::readConfig(filename, cfg); //throw (xmlAccess::FfsXmlError); } - else - return false; -} - - -void FfsXmlErrorLogger::readFilter(const TiXmlElement& parent, FilterConfig& output) -{ - //read filter settings - readXmlElementLogging("Include", &parent, output.includeFilter); - readXmlElementLogging("Exclude", &parent, output.excludeFilter); - - //migration "strategy": no error checking on these... :P - - readXmlElementLogging("TimeSpan", &parent, output.timeSpan); - readXmlElementLogging("UnitTimeSpan", &parent, output.unitTimeSpan); - - readXmlElementLogging("SizeMin", &parent, output.sizeMin); - readXmlElementLogging("UnitSizeMin", &parent, output.unitSizeMin); - - readXmlElementLogging("SizeMax", &parent, output.sizeMax); - readXmlElementLogging("UnitSizeMax", &parent, output.unitSizeMax); -} - - -//################################################################################################################ -void FfsXmlErrorLogger::readConfig(const TiXmlElement& folderPair, FolderPairEnh& enhPair) -{ - //read folder pairs - readXmlElementLogging("Left", &folderPair, enhPair.leftDirectory); - readXmlElementLogging("Right", &folderPair, enhPair.rightDirectory); - - - //########################################################### - //alternate sync configuration - const TiXmlElement* xmlAltSyncCfg = TiXmlHandleConst(&folderPair).FirstChild("AlternateSyncConfig").ToElement(); - if (xmlAltSyncCfg) + catch (const xmlAccess::FfsXmlError& e) { - AlternateSyncConfig* altSyncCfg = new AlternateSyncConfig; - enhPair.altSyncConfig.reset(altSyncCfg); - - const TiXmlElement* xmlSyncDirections = TiXmlHandleConst(xmlAltSyncCfg).FirstChild("CustomDirections").ToElement(); - - //read sync configuration - readXmlElementLogging("Variant", xmlAltSyncCfg, altSyncCfg->syncConfiguration.var); - - readXmlElementLogging("LeftOnly", xmlSyncDirections, altSyncCfg->syncConfiguration.custom.exLeftSideOnly); - readXmlElementLogging("RightOnly", xmlSyncDirections, altSyncCfg->syncConfiguration.custom.exRightSideOnly); - readXmlElementLogging("LeftNewer", xmlSyncDirections, altSyncCfg->syncConfiguration.custom.leftNewer); - readXmlElementLogging("RightNewer", xmlSyncDirections, altSyncCfg->syncConfiguration.custom.rightNewer); - readXmlElementLogging("Different", xmlSyncDirections, altSyncCfg->syncConfiguration.custom.different); - readXmlElementLogging("Conflict", xmlSyncDirections, altSyncCfg->syncConfiguration.custom.conflict); - - readXmlElementLogging("DeletionPolicy", xmlAltSyncCfg, altSyncCfg->handleDeletion); - readXmlElementLogging("CustomDeletionFolder", xmlAltSyncCfg, altSyncCfg->customDeletionDirectory); + if (e.getSeverity() == xmlAccess::FfsXmlError::FATAL) + throw; + else + exeption.reset(new xmlAccess::FfsXmlError(e)); } - - //########################################################### - //alternate filter configuration - const TiXmlElement* filterCfg = TiXmlHandleConst(&folderPair).FirstChild("LocalFilter").ToElement(); - if (filterCfg) - readFilter(*filterCfg, enhPair.localFilter); + return cfg; } -void FfsXmlErrorLogger::readConfig(const TiXmlElement* root, MainConfiguration& mainCfg) +template <class XmlCfg> +void mergeConfigFilesImpl(const std::vector<wxString>& filenames, XmlCfg& config) //throw (xmlAccess::FfsXmlError) { - TiXmlHandleConst hRoot(root); //custom const handle: TiXml API seems broken in this regard - - //########################################################### - const TiXmlElement* xmlMainConfig = hRoot.FirstChild("MainConfig").ToElement(); - - const TiXmlElement* cmpSettings = hRoot.FirstChild("MainConfig").FirstChild("Comparison").ToElement(); - - //read compare variant - readXmlElementLogging("Variant", cmpSettings, mainCfg.compareVar); - - //include symbolic links at all? - readXmlElementLogging("HandleSymlinks", cmpSettings, mainCfg.handleSymlinks); - - //########################################################### - const TiXmlElement* xmlSyncCfg = hRoot.FirstChild("MainConfig").FirstChild("SyncConfig").ToElement(); - const TiXmlElement* syncDirections = TiXmlHandleConst(xmlSyncCfg).FirstChild("CustomDirections").ToElement(); - - //read sync configuration - readXmlElementLogging("Variant", xmlSyncCfg, mainCfg.syncConfiguration.var); - - readXmlElementLogging("LeftOnly", syncDirections, mainCfg.syncConfiguration.custom.exLeftSideOnly); - readXmlElementLogging("RightOnly", syncDirections, mainCfg.syncConfiguration.custom.exRightSideOnly); - readXmlElementLogging("LeftNewer", syncDirections, mainCfg.syncConfiguration.custom.leftNewer); - readXmlElementLogging("RightNewer", syncDirections, mainCfg.syncConfiguration.custom.rightNewer); - readXmlElementLogging("Different", syncDirections, mainCfg.syncConfiguration.custom.different); - readXmlElementLogging("Conflict", syncDirections, mainCfg.syncConfiguration.custom.conflict); - - //########################################################### - //misc - readXmlElementLogging("DeletionPolicy", xmlSyncCfg, mainCfg.handleDeletion); - readXmlElementLogging("CustomDeletionFolder", xmlSyncCfg, mainCfg.customDeletionDirectory); - //########################################################### - const TiXmlElement* filter = TiXmlHandleConst(xmlMainConfig).FirstChild("GlobalFilter").ToElement(); + using namespace xmlAccess; - //read filter settings - if (filter) - readFilter(*filter, mainCfg.globalFilter); - else - logError("GlobalFilter"); + assert(!filenames.empty()); + if (filenames.empty()) + return; - //########################################################### - const TiXmlElement* pairs = hRoot.FirstChild("MainConfig").FirstChild("FolderPairs").FirstChild("Pair").ToElement(); + std::vector<zen::MainConfiguration> mainCfgs; + std::unique_ptr<FfsXmlError> savedException; - //read all folder pairs - mainCfg.additionalPairs.clear(); - bool firstLoop = true; - while (pairs) + for (std::vector<wxString>::const_iterator i = filenames.begin(); i != filenames.end(); ++i) { - FolderPairEnh newPair; - readConfig(*pairs, newPair); - - if (firstLoop) //read first folder pair + switch (getXmlType(*i)) { - firstLoop = false; - mainCfg.firstPair = newPair; - } - else //read additional folder pairs - mainCfg.additionalPairs.push_back(newPair); + case XML_TYPE_GUI: + mainCfgs.push_back(loadCfgImpl<XmlGuiConfig>(*i, savedException).mainCfg); //throw (xmlAccess::FfsXmlError) + break; + + case XML_TYPE_BATCH: + mainCfgs.push_back(loadCfgImpl<XmlBatchConfig>(*i, savedException).mainCfg); //throw (xmlAccess::FfsXmlError) + break; - pairs = pairs->NextSiblingElement(); + case XML_TYPE_GLOBAL: + case XML_TYPE_OTHER: + break; + } } -} + if (mainCfgs.empty()) + throw FfsXmlError(_("Invalid FreeFileSync config file!")); -void FfsXmlErrorLogger::readConfig(const TiXmlElement* root, xmlAccess::XmlGuiConfig& outputCfg) -{ - //read main config - readConfig(root, outputCfg.mainCfg); + try //...to init all non-"mainCfg" settings with first config file + { + xmlAccess::readConfig(filenames[0], config); //throw (xmlAccess::FfsXmlError); + } + catch (...) {} - //read GUI specific config data - const TiXmlElement* guiConfig = TiXmlHandleConst(root).FirstChild("GuiConfig").ToElement(); + config.mainCfg = merge(mainCfgs); - readXmlElementLogging("HideFiltered", guiConfig, outputCfg.hideFilteredElements); - readXmlElementLogging("HandleError", guiConfig, outputCfg.handleError); - readXmlElementLogging("SyncPreviewActive", guiConfig, outputCfg.syncPreviewEnabled); + if (savedException.get()) //"re-throw" exception + throw* savedException; +} } -void FfsXmlErrorLogger::readConfig(const TiXmlElement* root, xmlAccess::XmlBatchConfig& outputCfg) +void xmlAccess::convertConfig(const std::vector<wxString>& filenames, XmlGuiConfig& config) //throw (xmlAccess::FfsXmlError) { - //read main config - readConfig(root, outputCfg.mainCfg); - - //read batch specific config - const TiXmlElement* batchConfig = TiXmlHandleConst(root).FirstChild("BatchConfig").ToElement(); - - readXmlElementLogging("Silent", batchConfig, outputCfg.silent); - readXmlElementLogging("LogfileDirectory", batchConfig, outputCfg.logFileDirectory); - readXmlElementLogging("LogfileCountMax", batchConfig, outputCfg.logFileCountMax); - readXmlElementLogging("HandleError", batchConfig, outputCfg.handleError); + mergeConfigFilesImpl(filenames, config); //throw (xmlAccess::FfsXmlError) } -void FfsXmlErrorLogger::readConfig(const TiXmlElement* root, xmlAccess::XmlGlobalSettings& outputCfg) +void xmlAccess::convertConfig(const std::vector<wxString>& filenames, XmlBatchConfig& config) //throw (xmlAccess::FfsXmlError); { - //read global settings - const TiXmlElement* global = TiXmlHandleConst(root).FirstChild("Shared").ToElement(); - - //try to read program language setting - readXmlElementLogging("Language", global, outputCfg.programLanguage); - - //copy locked files using VSS - readXmlElementLogging("CopyLockedFiles", global, outputCfg.copyLockedFiles); - - //file permissions - readXmlElementLogging("CopyFilePermissions", global, outputCfg.copyFilePermissions); - - //verify file copying - readXmlElementLogging("VerifyCopiedFiles", global, outputCfg.verifyFileCopy); - - //max. allowed file time deviation - readXmlElementLogging("FileTimeTolerance", global, outputCfg.fileTimeTolerance); - - - const TiXmlElement* optionalDialogs = TiXmlHandleConst(root).FirstChild("Shared").FirstChild("ShowOptionalDialogs").ToElement(); - - //folder dependency check - readXmlElementLogging("CheckForDependentFolders", optionalDialogs, outputCfg.optDialogs.warningDependentFolders); - - //check for multi write access for directory as part of multiple pairs - readXmlElementLogging("CheckForMultipleWriteAccess", optionalDialogs, outputCfg.optDialogs.warningMultiFolderWriteAccess); - - //significant difference check - readXmlElementLogging("CheckForSignificantDifference", optionalDialogs, outputCfg.optDialogs.warningSignificantDifference); - //check free disk space - readXmlElementLogging("CheckForFreeDiskSpace", optionalDialogs, outputCfg.optDialogs.warningNotEnoughDiskSpace); - //check for unresolved conflicts - readXmlElementLogging("CheckForUnresolvedConflicts", optionalDialogs, outputCfg.optDialogs.warningUnresolvedConflicts); - - readXmlElementLogging("NotifyDatabaseError", optionalDialogs, outputCfg.optDialogs.warningSyncDatabase); - - readXmlElementLogging("PopupOnConfigChange", optionalDialogs, outputCfg.optDialogs.popupOnConfigChange); - - readXmlElementLogging("SummaryBeforeSync", optionalDialogs, outputCfg.optDialogs.showSummaryBeforeSync); - - - //gui specific global settings (optional) - const TiXmlElement* gui = TiXmlHandleConst(root).FirstChild("Gui").ToElement(); - const TiXmlElement* mainWindow = TiXmlHandleConst(gui).FirstChild("Windows").FirstChild("Main").ToElement(); - - //read application window size and position - readXmlElementLogging("Width", mainWindow, outputCfg.gui.widthNotMaximized); - readXmlElementLogging("Height", mainWindow, outputCfg.gui.heightNotMaximized); - readXmlElementLogging("PosX", mainWindow, outputCfg.gui.posXNotMaximized); - readXmlElementLogging("PosY", mainWindow, outputCfg.gui.posYNotMaximized); - readXmlElementLogging("Maximized", mainWindow, outputCfg.gui.isMaximized); - - readXmlElementLogging("ManualDeletionOnBothSides", mainWindow, outputCfg.gui.deleteOnBothSides); - readXmlElementLogging("ManualDeletionUseRecycler", mainWindow, outputCfg.gui.useRecyclerForManualDeletion); - - readXmlElementLogging("RespectCaseOnSearch", mainWindow, outputCfg.gui.textSearchRespectCase); - - size_t folderPairMax = 0; - readXmlElementLogging("FolderPairsMax", mainWindow, folderPairMax); - if (folderPairMax != 0) //if reading fails, leave at default - outputCfg.gui.addFolderPairCountMax = std::max(static_cast<size_t>(2), folderPairMax) - 1; //map folderPairMax to additionalFolderPairMax - - //########################################################### - //read column attributes - readXmlAttributeLogging("AutoAdjust", TiXmlHandleConst(mainWindow).FirstChild("LeftColumns").ToElement(), outputCfg.gui.autoAdjustColumnsLeft); - readXmlAttributeLogging("ShowFileIcons", TiXmlHandleConst(mainWindow).FirstChild("LeftColumns").ToElement(), outputCfg.gui.showFileIconsLeft); - - const TiXmlElement* leftColumn = TiXmlHandleConst(mainWindow).FirstChild("LeftColumns").FirstChild("Column").ToElement(); - size_t colPos = 0; - while (leftColumn) - { - ColumnAttrib newAttrib; - newAttrib.position = colPos++; - readXmlAttributeLogging("Type", leftColumn, newAttrib.type); - readXmlAttributeLogging("Visible", leftColumn, newAttrib.visible); - readXmlAttributeLogging("Width", leftColumn, newAttrib.width); - outputCfg.gui.columnAttribLeft.push_back(newAttrib); - - leftColumn = leftColumn->NextSiblingElement(); - } - - readXmlAttributeLogging("AutoAdjust", TiXmlHandleConst(mainWindow).FirstChild("RightColumns").ToElement(), outputCfg.gui.autoAdjustColumnsRight); - readXmlAttributeLogging("ShowFileIcons", TiXmlHandleConst(mainWindow).FirstChild("RightColumns").ToElement(), outputCfg.gui.showFileIconsRight); - - const TiXmlElement* rightColumn = TiXmlHandleConst(mainWindow).FirstChild("RightColumns").FirstChild("Column").ToElement(); - colPos = 0; - while (rightColumn) - { - ColumnAttrib newAttrib; - newAttrib.position = colPos++; - readXmlAttributeLogging("Type", rightColumn, newAttrib.type); - readXmlAttributeLogging("Visible", rightColumn, newAttrib.visible); - readXmlAttributeLogging("Width", rightColumn, newAttrib.width); - outputCfg.gui.columnAttribRight.push_back(newAttrib); - - rightColumn = rightColumn->NextSiblingElement(); - } - - readXmlElementLogging("FolderHistoryLeft", mainWindow, outputCfg.gui.folderHistoryLeft); - readXmlElementLogging("FolderHistoryRight", mainWindow, outputCfg.gui.folderHistoryRight); - readXmlElementLogging("MaximumHistorySize", mainWindow, outputCfg.gui.folderHistMax); - - readXmlElementLogging("Perspective", mainWindow, outputCfg.gui.guiPerspectiveLast); - - //external applications - const TiXmlElement* extApps = TiXmlHandleConst(gui).FirstChild("ExternalApplications").FirstChild("Commandline").ToElement(); - if (extApps) - { - outputCfg.gui.externelApplications.clear(); - while (extApps) - { - wxString description; - wxString cmdLine; - - readXmlAttributeLogging("Description", extApps, description); - const char* text = extApps->GetText(); - if (text) cmdLine = wxString::FromUTF8(text); //read commandline - outputCfg.gui.externelApplications.push_back(std::make_pair(description, cmdLine)); - - extApps = extApps->NextSiblingElement(); - } - } - //load config file history - const TiXmlElement* cfgHistory = TiXmlHandleConst(gui).FirstChild("ConfigHistory").ToElement(); - - //load config history elements - readXmlAttributeLogging("LastUsed", cfgHistory, outputCfg.gui.lastUsedConfigFile); - readXmlElementLogging("File", cfgHistory, outputCfg.gui.cfgFileHistory); - - //last update check - readXmlElementLogging("LastUpdateCheck", gui, outputCfg.gui.lastUpdateCheck); - - - //batch specific global settings - //const TiXmlElement* batch = TiXmlHandleConst(root).FirstChild("Batch").ToElement(); + mergeConfigFilesImpl(filenames, config); //throw (xmlAccess::FfsXmlError) } -void addXmlElement(const std::string& name, const CompareVariant variant, TiXmlElement* parent) +namespace zen +{ +template <> inline +void writeText(const CompareVariant& value, std::string& output) { - switch (variant) + switch (value) { case zen::CMP_BY_TIME_SIZE: - xmlAccess::addXmlElement(name, std::string("ByTimeAndSize"), parent); + output = "ByTimeAndSize"; break; case zen::CMP_BY_CONTENT: - xmlAccess::addXmlElement(name, std::string("ByContent"), parent); + output = "ByContent"; break; } } +template <> inline +bool readText(const std::string& input, CompareVariant& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "ByTimeAndSize") + value = zen::CMP_BY_TIME_SIZE; + else if (tmp == "ByContent") + value = zen::CMP_BY_CONTENT; + else + return false; + return true; +} -void addXmlElement(const std::string& name, const SyncDirection value, TiXmlElement* parent) + +template <> inline +void writeText(const SyncDirection& value, std::string& output) { switch (value) { case SYNC_DIR_LEFT: - xmlAccess::addXmlElement(name, std::string("left"), parent); + output = "left"; break; case SYNC_DIR_RIGHT: - xmlAccess::addXmlElement(name, std::string("right"), parent); + output = "right"; break; case SYNC_DIR_NONE: - xmlAccess::addXmlElement(name, std::string("none"), parent); + output = "none"; break; } } +template <> inline +bool readText(const std::string& input, SyncDirection& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "left") + value = SYNC_DIR_LEFT; + else if (tmp == "right") + value = SYNC_DIR_RIGHT; + else if (tmp == "none") + value = SYNC_DIR_NONE; + else + return false; + return true; +} + -void addXmlElement(const std::string& name, const xmlAccess::OnError value, TiXmlElement* parent) +template <> inline +void writeText(const OnError& value, std::string& output) { switch (value) { - case xmlAccess::ON_ERROR_IGNORE: - xmlAccess::addXmlElement(name, std::string("Ignore"), parent); + case ON_ERROR_IGNORE: + output = "Ignore"; break; - case xmlAccess::ON_ERROR_EXIT: - xmlAccess::addXmlElement(name, std::string("Exit"), parent); + case ON_ERROR_EXIT: + output = "Exit"; break; - case xmlAccess::ON_ERROR_POPUP: - xmlAccess::addXmlElement(name, std::string("Popup"), parent); + case ON_ERROR_POPUP: + output = "Popup"; break; } } +template <> inline +bool readText(const std::string& input, OnError& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "Ignore") + value = ON_ERROR_IGNORE; + else if (tmp == "Exit") + value = ON_ERROR_EXIT; + else if (tmp == "Popup") + value = ON_ERROR_POPUP; + else + return false; + return true; +} + -void addXmlElement(const std::string& name, const OnGuiError value, TiXmlElement* parent) +template <> inline +void writeText(const OnGuiError& value, std::string& output) { switch (value) { case ON_GUIERROR_IGNORE: - xmlAccess::addXmlElement(name, std::string("Ignore"), parent); + output = "Ignore"; break; case ON_GUIERROR_POPUP: - xmlAccess::addXmlElement(name, std::string("Popup"), parent); + output = "Popup"; break; } } +template <> inline +bool readText(const std::string& input, OnGuiError& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "Ignore") + value = ON_GUIERROR_IGNORE; + else if (tmp == "Popup") + value = ON_GUIERROR_POPUP; + else + return false; + return true; +} -void addXmlElement(const std::string& name, const zen::DeletionPolicy value, TiXmlElement* parent) + +template <> inline +void writeText(const DeletionPolicy& value, std::string& output) { switch (value) { - case zen::DELETE_PERMANENTLY: - xmlAccess::addXmlElement(name, std::string("DeletePermanently"), parent); + case DELETE_PERMANENTLY: + output = "DeletePermanently"; break; - case zen::MOVE_TO_RECYCLE_BIN: - xmlAccess::addXmlElement(name, std::string("MoveToRecycleBin"), parent); + case MOVE_TO_RECYCLE_BIN: + output = "MoveToRecycleBin"; break; - case zen::MOVE_TO_CUSTOM_DIRECTORY: - xmlAccess::addXmlElement(name, std::string("MoveToCustomDirectory"), parent); + case MOVE_TO_CUSTOM_DIRECTORY: + output = "MoveToCustomDirectory"; break; } } +template <> inline +bool readText(const std::string& input, DeletionPolicy& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "DeletePermanently") + value = DELETE_PERMANENTLY; + else if (tmp == "MoveToRecycleBin") + value = MOVE_TO_RECYCLE_BIN; + else if (tmp == "MoveToCustomDirectory") + value = MOVE_TO_CUSTOM_DIRECTORY; + else + return false; + return true; +} + -void addXmlElement(const std::string& name, const zen::SymLinkHandling value, TiXmlElement* parent) +template <> inline +void writeText(const SymLinkHandling& value, std::string& output) { switch (value) { - case zen::SYMLINK_IGNORE: - xmlAccess::addXmlElement(name, std::string("Ignore"), parent); + case SYMLINK_IGNORE: + output = "Ignore"; break; - case zen::SYMLINK_USE_DIRECTLY: - xmlAccess::addXmlElement(name, std::string("UseDirectly"), parent); + case SYMLINK_USE_DIRECTLY: + output = "UseDirectly"; break; - case zen::SYMLINK_FOLLOW_LINK: - xmlAccess::addXmlElement(name, std::string("FollowLink"), parent); + case SYMLINK_FOLLOW_LINK: + output = "FollowLink"; break; } } +template <> inline +bool readText(const std::string& input, SymLinkHandling& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "Ignore") + value = SYMLINK_IGNORE; + else if (tmp == "UseDirectly") + value = SYMLINK_USE_DIRECTLY; + else if (tmp == "FollowLink") + value = SYMLINK_FOLLOW_LINK; + else + return false; + return true; +} + -void addXmlElement(const std::string& name, const zen::UnitTime value, TiXmlElement* parent) +template <> inline +void writeText(const UnitTime& value, std::string& output) { switch (value) { - case zen::UTIME_NONE: - xmlAccess::addXmlElement(name, std::string("Inactive"), parent); + case UTIME_NONE: + output = "Inactive"; break; - case zen::UTIME_SEC: - xmlAccess::addXmlElement(name, std::string("Second"), parent); + case UTIME_SEC: + output = "Second"; break; - case zen::UTIME_MIN: - xmlAccess::addXmlElement(name, std::string("Minute"), parent); + case UTIME_MIN: + output = "Minute"; break; - case zen::UTIME_HOUR: - xmlAccess::addXmlElement(name, std::string("Hour"), parent); + case UTIME_HOUR: + output = "Hour"; break; - case zen::UTIME_DAY: - xmlAccess::addXmlElement(name, std::string("Day"), parent); + case UTIME_DAY: + output = "Day"; break; } } +template <> inline +bool readText(const std::string& input, UnitTime& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "Inactive") + value = UTIME_NONE; + else if (tmp == "Second") + value = UTIME_SEC; + else if (tmp == "Minute") + value = UTIME_MIN; + else if (tmp == "Hour") + value = UTIME_HOUR; + else if (tmp == "Day") + value = UTIME_DAY; + else + return false; + return true; +} + + +template <> inline +void writeText(const ColumnTypes& value, std::string& output) +{ + output = toString<std::string>(value); +} -void addXmlElement(const std::string& name, zen::UnitSize value, TiXmlElement* parent) +template <> inline +bool readText(const std::string& input, ColumnTypes& value) +{ + value = static_cast<ColumnTypes>(toNumber<int>(input)); + return true; +} + + +template <> inline +void writeText(const UnitSize& value, std::string& output) { switch (value) { - case zen::USIZE_NONE: - xmlAccess::addXmlElement(name, std::string("Inactive"), parent); + case USIZE_NONE: + output = "Inactive"; break; - case zen::USIZE_BYTE: - xmlAccess::addXmlElement(name, std::string("Byte"), parent); + case USIZE_BYTE: + output = "Byte"; break; - case zen::USIZE_KB: - xmlAccess::addXmlElement(name, std::string("KB"), parent); + case USIZE_KB: + output = "KB"; break; - case zen::USIZE_MB: - xmlAccess::addXmlElement(name, std::string("MB"), parent); + case USIZE_MB: + output = "MB"; break; } } +template <> inline +bool readText(const std::string& input, UnitSize& value) +{ + std::string tmp = input; + zen::trim(tmp); + if (tmp == "Inactive") + value = USIZE_NONE; + else if (tmp == "Byte") + value = USIZE_BYTE; + else if (tmp == "KB") + value = USIZE_KB; + else if (tmp == "MB") + value = USIZE_MB; + else + return false; + return true; +} + -void addXmlElement(const std::string& name, SyncConfig::Variant value, TiXmlElement* parent) +template <> inline +void writeText(const SyncConfig::Variant& value, std::string& output) { switch (value) { case SyncConfig::AUTOMATIC: - xmlAccess::addXmlElement(name, std::string("Automatic"), parent); + output = "Automatic"; break; case SyncConfig::MIRROR: - xmlAccess::addXmlElement(name, std::string("Mirror"), parent); + output = "Mirror"; break; case SyncConfig::UPDATE: - xmlAccess::addXmlElement(name, std::string("Update"), parent); + output = "Update"; break; case SyncConfig::CUSTOM: - xmlAccess::addXmlElement(name, std::string("Custom"), parent); + output = "Custom"; break; } } - -void addXmlElement(const std::string& name, const Zstring& value, TiXmlElement* parent) +template <> inline +bool readText(const std::string& input, SyncConfig::Variant& value) { - xmlAccess::addXmlElement(name, wxString(zToWx(value)), parent); + std::string tmp = input; + zen::trim(tmp); + if (tmp == "Automatic") + value = SyncConfig::AUTOMATIC; + else if (tmp == "Mirror") + value = SyncConfig::MIRROR; + else if (tmp == "Update") + value = SyncConfig::UPDATE; + else if (tmp == "Custom") + value = SyncConfig::CUSTOM; + else + return false; + return true; } -void addXmlAttribute(const std::string& name, const xmlAccess::ColumnTypes value, TiXmlElement* node) +template <> inline +bool readValue(const XmlElement& input, ColumnAttrib& value) { - xmlAccess::addXmlAttribute(name, static_cast<int>(value), node); + XmlIn in(input); + bool rv1 = in.attribute("Type", value.type); + bool rv2 = in.attribute("Visible", value.visible); + bool rv3 = in.attribute("Width", value.width); + value.position = 0; + return rv1 && rv2 && rv3; } - -void writeFilter(const FilterConfig& input, TiXmlElement& parent) +template <> inline +void writeValue(const ColumnAttrib& value, XmlElement& output) { - addXmlElement("Include", input.includeFilter, &parent); - addXmlElement("Exclude", input.excludeFilter, &parent); - - addXmlElement("TimeSpan", input.timeSpan, &parent); - addXmlElement("UnitTimeSpan", input.unitTimeSpan, &parent); + XmlOut out(output); + out.attribute("Type", value.type); + out.attribute("Visible", value.visible); + out.attribute("Width", value.width); +} +} - addXmlElement("SizeMin", input.sizeMin, &parent); - addXmlElement("UnitSizeMin", input.unitSizeMin, &parent); - addXmlElement("SizeMax", input.sizeMax, &parent); - addXmlElement("UnitSizeMax", input.unitSizeMax, &parent); +namespace +{ +void readConfig(const XmlIn& in, SyncConfig& syncCfg) +{ + in["Variant"](syncCfg.var); + + XmlIn inCustDir = in["CustomDirections"]; + inCustDir["LeftOnly" ](syncCfg.custom.exLeftSideOnly); + inCustDir["RightOnly" ](syncCfg.custom.exRightSideOnly); + inCustDir["LeftNewer" ](syncCfg.custom.leftNewer); + inCustDir["RightNewer"](syncCfg.custom.rightNewer); + inCustDir["Different" ](syncCfg.custom.different); + inCustDir["Conflict" ](syncCfg.custom.conflict); } -void writeXmlLocalConfig(const FolderPairEnh& enhPair, TiXmlElement& parent) +void readConfig(const XmlIn& in, FilterConfig& filter) { - //write folder pairs - TiXmlElement* newfolderPair = new TiXmlElement("Pair"); - parent.LinkEndChild(newfolderPair); + in["Include"](filter.includeFilter); + in["Exclude"](filter.excludeFilter); - addXmlElement("Left", enhPair.leftDirectory, newfolderPair); - addXmlElement("Right", enhPair.rightDirectory, newfolderPair); + in["TimeSpan" ](filter.timeSpan); + in["UnitTimeSpan"](filter.unitTimeSpan); + in["SizeMin" ](filter.sizeMin); + in["UnitSizeMin"](filter.unitSizeMin); - //alternate sync configuration - const AlternateSyncConfig* altSyncConfig = enhPair.altSyncConfig.get(); - if (altSyncConfig) - { - TiXmlElement* xmlAltSyncCfg = new TiXmlElement("AlternateSyncConfig"); - newfolderPair->LinkEndChild(xmlAltSyncCfg); + in["SizeMax" ](filter.sizeMax); + in["UnitSizeMax"](filter.unitSizeMax); +} - //write sync configuration - addXmlElement("Variant", altSyncConfig->syncConfiguration.var, xmlAltSyncCfg); - TiXmlElement* syncDirections = new TiXmlElement("CustomDirections"); - xmlAltSyncCfg->LinkEndChild(syncDirections); +void readConfig(const XmlIn& in, FolderPairEnh& enhPair) +{ + //read folder pairs + in["Left" ](enhPair.leftDirectory); + in["Right"](enhPair.rightDirectory); - addXmlElement("LeftOnly", altSyncConfig->syncConfiguration.custom.exLeftSideOnly, syncDirections); - addXmlElement("RightOnly", altSyncConfig->syncConfiguration.custom.exRightSideOnly, syncDirections); - addXmlElement("LeftNewer", altSyncConfig->syncConfiguration.custom.leftNewer, syncDirections); - addXmlElement("RightNewer", altSyncConfig->syncConfiguration.custom.rightNewer, syncDirections); - addXmlElement("Different", altSyncConfig->syncConfiguration.custom.different, syncDirections); - addXmlElement("Conflict", altSyncConfig->syncConfiguration.custom.conflict, syncDirections); + //########################################################### + //alternate sync configuration (optional) + XmlIn inAlt = in["AlternateSyncConfig"]; + if (inAlt) + { + std::shared_ptr<AlternateSyncConfig> altSyncCfg = std::make_shared<AlternateSyncConfig>(); + enhPair.altSyncConfig = altSyncCfg; + + //read sync configuration + readConfig(inAlt, altSyncCfg->syncConfiguration); - //misc - addXmlElement("DeletionPolicy", altSyncConfig->handleDeletion, xmlAltSyncCfg); - addXmlElement("CustomDeletionFolder", altSyncConfig->customDeletionDirectory, xmlAltSyncCfg); + inAlt["DeletionPolicy" ](altSyncCfg->handleDeletion); + inAlt["CustomDeletionFolder"](altSyncCfg->customDeletionDirectory); } //########################################################### //alternate filter configuration - TiXmlElement* filterCfg = new TiXmlElement("LocalFilter"); - newfolderPair->LinkEndChild(filterCfg); - - //write filter settings - writeFilter(enhPair.localFilter, *filterCfg); + readConfig(in["LocalFilter"], enhPair.localFilter); } -void writeConfig(const MainConfiguration& mainCfg, TiXmlElement& root) +void readConfig(const XmlIn& in, MainConfiguration& mainCfg) { - TiXmlElement* xmlMainCfg = new TiXmlElement("MainConfig"); - root.LinkEndChild(xmlMainCfg); - - //########################################################### - TiXmlElement* cmpSettings = new TiXmlElement("Comparison"); - xmlMainCfg->LinkEndChild(cmpSettings); + XmlIn inCmp = in["MainConfig"]["Comparison"]; - //write compare algorithm - addXmlElement("Variant", mainCfg.compareVar, cmpSettings); + //read compare variant + inCmp["Variant"](mainCfg.compareVar); //include symbolic links at all? - addXmlElement("HandleSymlinks", mainCfg.handleSymlinks, cmpSettings); + inCmp["HandleSymlinks"](mainCfg.handleSymlinks); //########################################################### - TiXmlElement* xmlSyncCfg = new TiXmlElement("SyncConfig"); - xmlMainCfg->LinkEndChild(xmlSyncCfg); - - //write sync configuration - addXmlElement("Variant", mainCfg.syncConfiguration.var, xmlSyncCfg); - - TiXmlElement* syncDirections = new TiXmlElement("CustomDirections"); - xmlSyncCfg->LinkEndChild(syncDirections); - - addXmlElement("LeftOnly", mainCfg.syncConfiguration.custom.exLeftSideOnly, syncDirections); - addXmlElement("RightOnly", mainCfg.syncConfiguration.custom.exRightSideOnly, syncDirections); - addXmlElement("LeftNewer", mainCfg.syncConfiguration.custom.leftNewer, syncDirections); - addXmlElement("RightNewer", mainCfg.syncConfiguration.custom.rightNewer, syncDirections); - addXmlElement("Different", mainCfg.syncConfiguration.custom.different, syncDirections); - addXmlElement("Conflict", mainCfg.syncConfiguration.custom.conflict, syncDirections); + XmlIn inSync = in["MainConfig"]["SyncConfig"]; + //read sync configuration + readConfig(inSync, mainCfg.syncConfiguration); //########################################################### - //write filter settings - TiXmlElement* filter = new TiXmlElement("GlobalFilter"); - xmlMainCfg->LinkEndChild(filter); - writeFilter(mainCfg.globalFilter, *filter); + //misc + inSync["DeletionPolicy" ](mainCfg.handleDeletion); + inSync["CustomDeletionFolder"](mainCfg.customDeletionDirectory); + //########################################################### - //other - addXmlElement("DeletionPolicy", mainCfg.handleDeletion, xmlSyncCfg); - addXmlElement("CustomDeletionFolder", mainCfg.customDeletionDirectory, xmlSyncCfg); + XmlIn inFilter = in["MainConfig"]["GlobalFilter"]; + //read filter settings + readConfig(inFilter, mainCfg.globalFilter); //########################################################### - TiXmlElement* pairs = new TiXmlElement("FolderPairs"); - xmlMainCfg->LinkEndChild(pairs); + //read all folder pairs + mainCfg.additionalPairs.clear(); - //write first folder pair - writeXmlLocalConfig(mainCfg.firstPair, *pairs); + bool firstIter = true; + for (XmlIn inPair = in["MainConfig"]["FolderPairs"]["Pair"]; inPair; inPair.next()) + { + FolderPairEnh newPair; + readConfig(inPair, newPair); - //write additional folder pairs - for (std::vector<FolderPairEnh>::const_iterator i = mainCfg.additionalPairs.begin(); i != mainCfg.additionalPairs.end(); ++i) - writeXmlLocalConfig(*i, *pairs); + if (firstIter) + { + firstIter = false; + mainCfg.firstPair = newPair; //set first folder pair + } + else + mainCfg.additionalPairs.push_back(newPair); //set additional folder pairs + } } -void writeConfig(const xmlAccess::XmlGuiConfig& inputCfg, TiXmlElement& root) +void readConfig(const XmlIn& in, xmlAccess::XmlGuiConfig& config) { - //write main config - writeConfig(inputCfg.mainCfg, root); + ::readConfig(in, config.mainCfg); //read main config - //write GUI specific config - TiXmlElement* guiConfig = new TiXmlElement("GuiConfig"); - root.LinkEndChild(guiConfig); + //read GUI specific config data + XmlIn inGuiCfg = in["GuiConfig"]; - addXmlElement("HideFiltered", inputCfg.hideFilteredElements, guiConfig); - addXmlElement("HandleError", inputCfg.handleError, guiConfig); - addXmlElement("SyncPreviewActive", inputCfg.syncPreviewEnabled, guiConfig); + inGuiCfg["HideFiltered" ](config.hideFilteredElements); + inGuiCfg["HandleError" ](config.handleError); + inGuiCfg["SyncPreviewActive"](config.syncPreviewEnabled); } -void writeConfig(const xmlAccess::XmlBatchConfig& inputCfg, TiXmlElement& root) +void readConfig(const XmlIn& in, xmlAccess::XmlBatchConfig& config) { - //write main config - writeConfig(inputCfg.mainCfg, root); + ::readConfig(in, config.mainCfg); //read main config - //write GUI specific config - TiXmlElement* batchConfig = new TiXmlElement("BatchConfig"); - root.LinkEndChild(batchConfig); + //read GUI specific config data + XmlIn inBatchCfg = in["BatchConfig"]; - addXmlElement("Silent", inputCfg.silent, batchConfig); - addXmlElement("LogfileDirectory", inputCfg.logFileDirectory, batchConfig); - addXmlElement("LogfileCountMax", inputCfg.logFileCountMax, batchConfig); - addXmlElement("HandleError", inputCfg.handleError, batchConfig); + inBatchCfg["Silent" ](config.silent); + inBatchCfg["LogfileDirectory"](config.logFileDirectory); + inBatchCfg["LogfileCountMax" ](config.logFileCountMax); + inBatchCfg["HandleError" ](config.handleError); } -void writeConfig(const xmlAccess::XmlGlobalSettings& inputCfg, TiXmlElement& root) +void readConfig(const XmlIn& in, XmlGlobalSettings& config) { - //write global settings - TiXmlElement* global = new TiXmlElement("Shared"); - root.LinkEndChild(global); + XmlIn inShared = in["Shared"]; - //program language - addXmlElement("Language", inputCfg.programLanguage, global); + //try to read program language setting + inShared["Language"](config.programLanguage); //copy locked files using VSS - addXmlElement("CopyLockedFiles", inputCfg.copyLockedFiles, global); + inShared["CopyLockedFiles"](config.copyLockedFiles); //file permissions - addXmlElement("CopyFilePermissions", inputCfg.copyFilePermissions, global); + inShared["CopyFilePermissions"](config.copyFilePermissions); //verify file copying - addXmlElement("VerifyCopiedFiles", inputCfg.verifyFileCopy, global); + inShared["VerifyCopiedFiles"](config.verifyFileCopy); //max. allowed file time deviation - addXmlElement("FileTimeTolerance", inputCfg.fileTimeTolerance, global); - - - //optional dialogs - TiXmlElement* optionalDialogs = new TiXmlElement("ShowOptionalDialogs"); - global->LinkEndChild(optionalDialogs); - - //warning: dependent folders - addXmlElement("CheckForDependentFolders", inputCfg.optDialogs.warningDependentFolders, optionalDialogs); - - //check for multi write access for directory as part of multiple pairs - addXmlElement("CheckForMultipleWriteAccess", inputCfg.optDialogs.warningMultiFolderWriteAccess, optionalDialogs); - - //significant difference check - addXmlElement("CheckForSignificantDifference", inputCfg.optDialogs.warningSignificantDifference, optionalDialogs); - - //check free disk space - addXmlElement("CheckForFreeDiskSpace", inputCfg.optDialogs.warningNotEnoughDiskSpace, optionalDialogs); - - //check for unresolved conflicts - addXmlElement("CheckForUnresolvedConflicts", inputCfg.optDialogs.warningUnresolvedConflicts, optionalDialogs); - - addXmlElement("NotifyDatabaseError", inputCfg.optDialogs.warningSyncDatabase, optionalDialogs); - - addXmlElement("PopupOnConfigChange", inputCfg.optDialogs.popupOnConfigChange, optionalDialogs); - - addXmlElement("SummaryBeforeSync", inputCfg.optDialogs.showSummaryBeforeSync, optionalDialogs); - - - //################################################################### - //write global gui settings - TiXmlElement* gui = new TiXmlElement("Gui"); - root.LinkEndChild(gui); - - TiXmlElement* windows = new TiXmlElement("Windows"); - gui->LinkEndChild(windows); + inShared["FileTimeTolerance"](config.fileTimeTolerance); + + XmlIn inOpt = inShared["ShowOptionalDialogs"]; + inOpt["CheckForDependentFolders" ](config.optDialogs.warningDependentFolders); + inOpt["CheckForMultipleWriteAccess" ](config.optDialogs.warningMultiFolderWriteAccess); + inOpt["CheckForSignificantDifference"](config.optDialogs.warningSignificantDifference); + inOpt["CheckForFreeDiskSpace"](config.optDialogs.warningNotEnoughDiskSpace); + inOpt["CheckForUnresolvedConflicts"](config.optDialogs.warningUnresolvedConflicts); + inOpt["NotifyDatabaseError"](config.optDialogs.warningSyncDatabase); + inOpt["PopupOnConfigChange"](config.optDialogs.popupOnConfigChange); + inOpt["SummaryBeforeSync" ](config.optDialogs.showSummaryBeforeSync); - TiXmlElement* mainWindow = new TiXmlElement("Main"); - windows->LinkEndChild(mainWindow); + //gui specific global settings (optional) + XmlIn inGui = in["Gui"]; + XmlIn inWnd = inGui["Windows"]["Main"]; - //window size - addXmlElement("Width", inputCfg.gui.widthNotMaximized, mainWindow); - addXmlElement("Height", inputCfg.gui.heightNotMaximized, mainWindow); + //read application window size and position + inWnd["Width" ](config.gui.dlgSize.x); + inWnd["Height" ](config.gui.dlgSize.y); + inWnd["PosX" ](config.gui.dlgPos.x); + inWnd["PosY" ](config.gui.dlgPos.y); + inWnd["Maximized"](config.gui.isMaximized); - //window position - addXmlElement("PosX", inputCfg.gui.posXNotMaximized, mainWindow); - addXmlElement("PosY", inputCfg.gui.posYNotMaximized, mainWindow); - addXmlElement("Maximized", inputCfg.gui.isMaximized, mainWindow); + inWnd["ManualDeletionOnBothSides"](config.gui.deleteOnBothSides); + inWnd["ManualDeletionUseRecycler"](config.gui.useRecyclerForManualDeletion); + inWnd["RespectCaseOnSearch" ](config.gui.textSearchRespectCase); - addXmlElement("ManualDeletionOnBothSides", inputCfg.gui.deleteOnBothSides, mainWindow); - addXmlElement("ManualDeletionUseRecycler", inputCfg.gui.useRecyclerForManualDeletion, mainWindow); + //########################################################### - addXmlElement("RespectCaseOnSearch", inputCfg.gui.textSearchRespectCase, mainWindow); + //read column attributes + XmlIn inColLeft = inWnd["LeftColumns"]; - addXmlElement("FolderPairsMax", inputCfg.gui.addFolderPairCountMax + 1 /*add main pair*/, mainWindow); + inColLeft.attribute("AutoAdjust", config.gui.autoAdjustColumnsLeft); + inColLeft.attribute("ShowFileIcons", config.gui.showFileIconsLeft); + inColLeft(config.gui.columnAttribLeft); + for (size_t i = 0; i < config.gui.columnAttribLeft.size(); ++i) + config.gui.columnAttribLeft[i].position = i; - //write column attributes - TiXmlElement* leftColumn = new TiXmlElement("LeftColumns"); - mainWindow->LinkEndChild(leftColumn); - - addXmlAttribute("AutoAdjust", inputCfg.gui.autoAdjustColumnsLeft, leftColumn); - addXmlAttribute("ShowFileIcons", inputCfg.gui.showFileIconsLeft, leftColumn); + //########################################################### + XmlIn inColRight = inWnd["RightColumns"]; - ColumnAttributes columnAtrribLeftCopy = inputCfg.gui.columnAttribLeft; //can't change const vector - sort(columnAtrribLeftCopy.begin(), columnAtrribLeftCopy.end(), xmlAccess::sortByPositionOnly); - for (size_t i = 0; i < columnAtrribLeftCopy.size(); ++i) - { - TiXmlElement* subElement = new TiXmlElement("Column"); - leftColumn->LinkEndChild(subElement); + inColRight.attribute("AutoAdjust", config.gui.autoAdjustColumnsRight); + inColRight.attribute("ShowFileIcons", config.gui.showFileIconsRight); - const ColumnAttrib& colAttrib = columnAtrribLeftCopy[i]; - addXmlAttribute("Type", colAttrib.type, subElement); - addXmlAttribute("Visible", colAttrib.visible, subElement); - addXmlAttribute("Width", colAttrib.width, subElement); - } + inColRight(config.gui.columnAttribRight); + for (size_t i = 0; i < config.gui.columnAttribRight.size(); ++i) + config.gui.columnAttribRight[i].position = i; - TiXmlElement* rightColumn = new TiXmlElement("RightColumns"); - mainWindow->LinkEndChild(rightColumn); + inWnd["FolderHistoryLeft" ](config.gui.folderHistoryLeft); + inWnd["FolderHistoryRight"](config.gui.folderHistoryRight); + inWnd["MaximumHistorySize"](config.gui.folderHistMax); + inWnd["Perspective" ](config.gui.guiPerspectiveLast); - addXmlAttribute("AutoAdjust", inputCfg.gui.autoAdjustColumnsRight, rightColumn); - addXmlAttribute("ShowFileIcons", inputCfg.gui.showFileIconsRight, rightColumn); + //external applications + inGui["ExternalApplications"](config.gui.externelApplications); - ColumnAttributes columnAtrribRightCopy = inputCfg.gui.columnAttribRight; - sort(columnAtrribRightCopy.begin(), columnAtrribRightCopy.end(), xmlAccess::sortByPositionOnly); - for (size_t i = 0; i < columnAtrribRightCopy.size(); ++i) - { - TiXmlElement* subElement = new TiXmlElement("Column"); - rightColumn->LinkEndChild(subElement); + //load config file history + XmlIn inHist = inGui["ConfigHistory"]; - const ColumnAttrib& colAttrib = columnAtrribRightCopy[i]; - addXmlAttribute("Type", colAttrib.type, subElement); - addXmlAttribute("Visible", colAttrib.visible, subElement); - addXmlAttribute("Width", colAttrib.width, subElement); - } + inHist.attribute("LastUsed", config.gui.lastUsedConfigFile); + inHist(config.gui.cfgFileHistory); - addXmlElement("FolderHistoryLeft", inputCfg.gui.folderHistoryLeft , mainWindow); - addXmlElement("FolderHistoryRight", inputCfg.gui.folderHistoryRight, mainWindow); - addXmlElement("MaximumHistorySize", inputCfg.gui.folderHistMax , mainWindow); + //last update check + inGui["LastUpdateCheck"](config.gui.lastUpdateCheck); - addXmlElement("Perspective", inputCfg.gui.guiPerspectiveLast, mainWindow); + //batch specific global settings + //XmlIn inBatch = in["Batch"]; +} - //external applications - TiXmlElement* extApp = new TiXmlElement("ExternalApplications"); - gui->LinkEndChild(extApp); - for (ExternalApps::const_iterator i = inputCfg.gui.externelApplications.begin(); i != inputCfg.gui.externelApplications.end(); ++i) - { - TiXmlElement* newEntry = new TiXmlElement("Commandline"); - extApp->LinkEndChild(newEntry); +template <class ConfigType> +void readConfig(const wxString& filename, XmlType type, ConfigType& config) +{ + if (!fileExists(wxToZ(filename))) + throw FfsXmlError(wxString(_("File does not exist:")) + wxT("\n\"") + filename + wxT("\"")); - addXmlAttribute("Description", i->first, newEntry); - newEntry->LinkEndChild(new TiXmlText(i->second.ToUTF8())); //commandline - } + XmlDoc doc; + loadXmlDocument(filename, doc); //throw (FfsXmlError) - //write config file history - TiXmlElement* cfgHistory = new TiXmlElement("ConfigHistory"); - gui->LinkEndChild(cfgHistory); + if (getXmlType(doc) != type) //throw() + throw FfsXmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"")); - addXmlAttribute("LastUsed", inputCfg.gui.lastUsedConfigFile, cfgHistory); - addXmlElement("File", inputCfg.gui.cfgFileHistory, cfgHistory); + XmlIn in(doc); + ::readConfig(in, config); - //last update check - addXmlElement("LastUpdateCheck", inputCfg.gui.lastUpdateCheck, gui); + if (in.errorsOccured()) + throw FfsXmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"\n\n") + + getErrorMessageFormatted(in), FfsXmlError::WARNING); +} +} - //################################################################### - //write global batch settings - TiXmlElement* batch = new TiXmlElement("Batch"); - root.LinkEndChild(batch); +void xmlAccess::readConfig(const wxString& filename, xmlAccess::XmlGuiConfig& config) +{ + ::readConfig(filename, XML_TYPE_GUI, config); } -wxString xmlAccess::getGlobalConfigFile() +void xmlAccess::readConfig(const wxString& filename, xmlAccess::XmlBatchConfig& config) { - return zen::getConfigDir() + wxT("GlobalSettings.xml"); + ::readConfig(filename, XML_TYPE_BATCH, config); } -void xmlAccess::OptionalDialogs::resetDialogs() +void xmlAccess::readConfig(xmlAccess::XmlGlobalSettings& config) { - warningDependentFolders = true; - warningMultiFolderWriteAccess = true; - warningSignificantDifference = true; - warningNotEnoughDiskSpace = true; - warningUnresolvedConflicts = true; - warningSyncDatabase = true; - popupOnConfigChange = true; - showSummaryBeforeSync = true; + ::readConfig(getGlobalConfigFile(), XML_TYPE_GLOBAL, config); } -xmlAccess::XmlGuiConfig xmlAccess::convertBatchToGui(const xmlAccess::XmlBatchConfig& batchCfg) +//################################################################################################ +namespace { - XmlGuiConfig output; - output.mainCfg = batchCfg.mainCfg; - return output; +void writeConfig(const SyncConfig& syncCfg, XmlOut& out) +{ + out["Variant"](syncCfg.var); + + XmlOut outCustDir = out["CustomDirections"]; + outCustDir["LeftOnly" ](syncCfg.custom.exLeftSideOnly); + outCustDir["RightOnly" ](syncCfg.custom.exRightSideOnly); + outCustDir["LeftNewer" ](syncCfg.custom.leftNewer); + outCustDir["RightNewer"](syncCfg.custom.rightNewer); + outCustDir["Different" ](syncCfg.custom.different); + outCustDir["Conflict" ](syncCfg.custom.conflict); } -xmlAccess::XmlBatchConfig xmlAccess::convertGuiToBatch(const xmlAccess::XmlGuiConfig& guiCfg) +void writeConfig(const FilterConfig& filter, XmlOut& out) { - XmlBatchConfig output; - output.mainCfg = guiCfg.mainCfg; + out["Include"](filter.includeFilter); + out["Exclude"](filter.excludeFilter); - switch (guiCfg.handleError) - { - case ON_GUIERROR_POPUP: - output.handleError = xmlAccess::ON_ERROR_POPUP; - break; - case ON_GUIERROR_IGNORE: - output.handleError = xmlAccess::ON_ERROR_IGNORE; - break; - } + out["TimeSpan" ](filter.timeSpan); + out["UnitTimeSpan"](filter.unitTimeSpan); - return output; + out["SizeMin" ](filter.sizeMin); + out["UnitSizeMin"](filter.unitSizeMin); + + out["SizeMax" ](filter.sizeMax); + out["UnitSizeMax"](filter.unitSizeMax); } -xmlAccess::MergeType xmlAccess::getMergeType(const std::vector<wxString>& filenames) //throw () +void writeConfigFolderPair(const FolderPairEnh& enhPair, XmlOut& out) { - bool guiCfgExists = false; - bool batchCfgExists = false; + XmlOut outPair = out.ref().addChild("Pair"); - for (std::vector<wxString>::const_iterator i = filenames.begin(); i != filenames.end(); ++i) + //read folder pairs + outPair["Left" ](enhPair.leftDirectory); + outPair["Right"](enhPair.rightDirectory); + + //########################################################### + //alternate sync configuration (optional) + if (enhPair.altSyncConfig.get()) { - switch (xmlAccess::getXmlType(*i)) //throw() - { - case XML_TYPE_GUI: - guiCfgExists = true; - break; + XmlOut outAlt = outPair["AlternateSyncConfig"]; - case XML_TYPE_BATCH: - batchCfgExists = true; - break; + //read sync configuration + writeConfig(enhPair.altSyncConfig->syncConfiguration, outAlt); - case XML_TYPE_GLOBAL: - case XML_TYPE_OTHER: - return MERGE_OTHER; - } + outAlt["DeletionPolicy" ](enhPair.altSyncConfig->handleDeletion); + outAlt["CustomDeletionFolder"](enhPair.altSyncConfig->customDeletionDirectory); } - if (guiCfgExists && batchCfgExists) - return MERGE_GUI_BATCH; - else if (guiCfgExists && !batchCfgExists) - return MERGE_GUI; - else if (!guiCfgExists && batchCfgExists) - return MERGE_BATCH; - else - return MERGE_OTHER; + //########################################################### + //alternate filter configuration + XmlOut outFilter = outPair["LocalFilter"]; + writeConfig(enhPair.localFilter, outFilter); } -namespace -{ -template <class XmlCfg> -XmlCfg loadCfgImpl(const wxString& filename, std::auto_ptr<xmlAccess::XmlError>& exeption) //throw (xmlAccess::XmlError) +void writeConfig(const MainConfiguration& mainCfg, XmlOut& out) { - XmlCfg cfg; - try - { - xmlAccess::readConfig(filename, cfg); //throw (xmlAccess::XmlError); - } - catch (const xmlAccess::XmlError& e) - { - if (e.getSeverity() == xmlAccess::XmlError::FATAL) - throw; - else - exeption.reset(new xmlAccess::XmlError(e)); - } - return cfg; -} + XmlOut outCmp = out["MainConfig"]["Comparison"]; + //write compare variant + outCmp["Variant"](mainCfg.compareVar); -template <class XmlCfg> -void mergeConfigFilesImpl(const std::vector<wxString>& filenames, XmlCfg& config) //throw (xmlAccess::XmlError) -{ - using namespace xmlAccess; - - assert(!filenames.empty()); - if (filenames.empty()) - return; + //include symbolic links at all? + outCmp["HandleSymlinks"](mainCfg.handleSymlinks); - std::vector<zen::MainConfiguration> mainCfgs; - std::auto_ptr<XmlError> savedException; + //########################################################### + XmlOut outSync = out["MainConfig"]["SyncConfig"]; - for (std::vector<wxString>::const_iterator i = filenames.begin(); i != filenames.end(); ++i) - { - switch (getXmlType(*i)) - { - case XML_TYPE_GUI: - mainCfgs.push_back(loadCfgImpl<XmlGuiConfig>(*i, savedException).mainCfg); //throw (xmlAccess::XmlError) - break; + //write sync configuration + writeConfig(mainCfg.syncConfiguration, outSync); + //########################################################### - case XML_TYPE_BATCH: - mainCfgs.push_back(loadCfgImpl<XmlBatchConfig>(*i, savedException).mainCfg); //throw (xmlAccess::XmlError) - break; + //misc + outSync["DeletionPolicy" ](mainCfg.handleDeletion); + outSync["CustomDeletionFolder"](mainCfg.customDeletionDirectory); + //########################################################### - case XML_TYPE_GLOBAL: - case XML_TYPE_OTHER: - break; - } - } + XmlOut outFilter = out["MainConfig"]["GlobalFilter"]; + //write filter settings + writeConfig(mainCfg.globalFilter, outFilter); - if (mainCfgs.empty()) - throw XmlError(_("Invalid FreeFileSync config file!")); + //########################################################### + //write all folder pairs - try //...to init all non-"mainCfg" settings with first config file - { - xmlAccess::readConfig(filenames[0], config); //throw (xmlAccess::XmlError); - } - catch (...) {} + XmlOut outFp = out["MainConfig"]["FolderPairs"]; - config.mainCfg = merge(mainCfgs); + //write first folder pair + writeConfigFolderPair(mainCfg.firstPair, outFp); - if (savedException.get()) //"re-throw" exception - throw* savedException; -} + //write additional folder pairs + std::for_each(mainCfg.additionalPairs.begin(), mainCfg.additionalPairs.end(), + [&](const FolderPairEnh& fp) { writeConfigFolderPair(fp, outFp); }); } -void xmlAccess::convertConfig(const std::vector<wxString>& filenames, XmlGuiConfig& config) //throw (xmlAccess::XmlError) +void writeConfig(const XmlGuiConfig& config, XmlOut& out) { - mergeConfigFilesImpl(filenames, config); //throw (xmlAccess::XmlError) -} + writeConfig(config.mainCfg, out); //write main config + //write GUI specific config data + XmlOut outGuiCfg = out["GuiConfig"]; -void xmlAccess::convertConfig(const std::vector<wxString>& filenames, XmlBatchConfig& config) //throw (xmlAccess::XmlError); -{ - mergeConfigFilesImpl(filenames, config); //throw (xmlAccess::XmlError) + outGuiCfg["HideFiltered" ](config.hideFilteredElements); + outGuiCfg["HandleError" ](config.handleError); + outGuiCfg["SyncPreviewActive"](config.syncPreviewEnabled); } +void writeConfig(const XmlBatchConfig& config, XmlOut& out) +{ + writeConfig(config.mainCfg, out); //write main config + //write GUI specific config data + XmlOut outBatchCfg = out["BatchConfig"]; + outBatchCfg["Silent" ](config.silent); + outBatchCfg["LogfileDirectory"](config.logFileDirectory); + outBatchCfg["LogfileCountMax" ](config.logFileCountMax); + outBatchCfg["HandleError" ](config.handleError); +} - -void xmlAccess::readConfig(const wxString& filename, xmlAccess::XmlGuiConfig& config) +void writeConfig(const XmlGlobalSettings& config, XmlOut& out) { - //load XML - if (!fileExists(wxToZ(filename))) - throw XmlError(wxString(_("File does not exist:")) + wxT("\n\"") + filename + wxT("\"")); + XmlOut outShared = out["Shared"]; - TiXmlDocument doc; - loadXmlDocument(filename, doc); //throw (XmlError) + //write program language setting + outShared["Language"](config.programLanguage); - if (getXmlType(doc) != XML_TYPE_GUI) //throw() - throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"")); + //copy locked files using VSS + outShared["CopyLockedFiles"](config.copyLockedFiles); - FfsXmlErrorLogger logger; - logger.readConfig(doc.RootElement(), config); //read GUI layout configuration + //file permissions + outShared["CopyFilePermissions"](config.copyFilePermissions); - if (logger.errorsOccurred()) - throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"\n\n") + - logger.getErrorMessageFormatted(), XmlError::WARNING); -} + //verify file copying + outShared["VerifyCopiedFiles"](config.verifyFileCopy); + //max. allowed file time deviation + outShared["FileTimeTolerance"](config.fileTimeTolerance); + + XmlOut outOpt = outShared["ShowOptionalDialogs"]; + outOpt["CheckForDependentFolders" ](config.optDialogs.warningDependentFolders); + outOpt["CheckForMultipleWriteAccess" ](config.optDialogs.warningMultiFolderWriteAccess); + outOpt["CheckForSignificantDifference"](config.optDialogs.warningSignificantDifference); + outOpt["CheckForFreeDiskSpace"](config.optDialogs.warningNotEnoughDiskSpace); + outOpt["CheckForUnresolvedConflicts"](config.optDialogs.warningUnresolvedConflicts); + outOpt["NotifyDatabaseError"](config.optDialogs.warningSyncDatabase); + outOpt["PopupOnConfigChange"](config.optDialogs.popupOnConfigChange); + outOpt["SummaryBeforeSync" ](config.optDialogs.showSummaryBeforeSync); -void xmlAccess::readConfig(const wxString& filename, xmlAccess::XmlBatchConfig& config) -{ - //load XML - if (!fileExists(wxToZ(filename))) - throw XmlError(wxString(_("File does not exist:")) + wxT("\n\"") + filename + wxT("\"")); + //gui specific global settings (optional) + XmlOut outGui = out["Gui"]; + XmlOut outWnd = outGui["Windows"]["Main"]; - TiXmlDocument doc; - loadXmlDocument(filename, doc); //throw (XmlError) + //write application window size and position + outWnd["Width" ](config.gui.dlgSize.x); + outWnd["Height" ](config.gui.dlgSize.y); + outWnd["PosX" ](config.gui.dlgPos.x); + outWnd["PosY" ](config.gui.dlgPos.y); + outWnd["Maximized"](config.gui.isMaximized); - if (getXmlType(doc) != XML_TYPE_BATCH) //throw() - throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"")); + outWnd["ManualDeletionOnBothSides"](config.gui.deleteOnBothSides); + outWnd["ManualDeletionUseRecycler"](config.gui.useRecyclerForManualDeletion); + outWnd["RespectCaseOnSearch" ](config.gui.textSearchRespectCase); - FfsXmlErrorLogger logger; - logger.readConfig(doc.RootElement(), config); //read GUI layout configuration + //########################################################### - if (logger.errorsOccurred()) - throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"\n\n") + - logger.getErrorMessageFormatted(), XmlError::WARNING); -} + //write column attributes + XmlOut outColLeft = outWnd["LeftColumns"]; + outColLeft.attribute("AutoAdjust", config.gui.autoAdjustColumnsLeft); + outColLeft.attribute("ShowFileIcons", config.gui.showFileIconsLeft); -void xmlAccess::readConfig(xmlAccess::XmlGlobalSettings& config) -{ - //load XML - if (!fileExists(wxToZ(getGlobalConfigFile()))) - throw XmlError(wxString(_("File does not exist:")) + wxT("\n\"") + getGlobalConfigFile() + wxT("\"")); + outColLeft(config.gui.columnAttribLeft); - TiXmlDocument doc; - loadXmlDocument(getGlobalConfigFile(), doc); //throw (XmlError) + //########################################################### + XmlOut outColRight = outWnd["RightColumns"]; - if (getXmlType(doc) != XML_TYPE_GLOBAL) //throw() - throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + getGlobalConfigFile() + wxT("\"")); + outColRight.attribute("AutoAdjust", config.gui.autoAdjustColumnsRight); + outColRight.attribute("ShowFileIcons", config.gui.showFileIconsRight); - FfsXmlErrorLogger logger; - logger.readConfig(doc.RootElement(), config); //read GUI layout configuration + outColRight(config.gui.columnAttribRight); - if (logger.errorsOccurred()) - throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + getGlobalConfigFile() + wxT("\"\n\n") + - logger.getErrorMessageFormatted(), XmlError::WARNING); -} + outWnd["FolderHistoryLeft" ](config.gui.folderHistoryLeft); + outWnd["FolderHistoryRight"](config.gui.folderHistoryRight); + outWnd["MaximumHistorySize"](config.gui.folderHistMax); + outWnd["Perspective" ](config.gui.guiPerspectiveLast); + //external applications + outGui["ExternalApplications"](config.gui.externelApplications); -void xmlAccess::writeConfig(const XmlGuiConfig& outputCfg, const wxString& filename) -{ - TiXmlDocument doc; - initXmlDocument(doc, XML_TYPE_GUI); //throw() + //load config file history + XmlOut outHist = outGui["ConfigHistory"]; - if (!doc.RootElement()) - throw XmlError(wxString(_("Error writing file:")) + wxT("\n\"") + filename + wxT("\"")); + outHist.attribute("LastUsed", config.gui.lastUsedConfigFile); + outHist(config.gui.cfgFileHistory); - writeConfig(outputCfg, *doc.RootElement()); //add GUI layout configuration settings + //last update check + outGui["LastUpdateCheck"](config.gui.lastUpdateCheck); - saveXmlDocument(filename, doc); //throw (XmlError) + //batch specific global settings + //XmlOut outBatch = out["Batch"]; } -void xmlAccess::writeConfig(const XmlBatchConfig& outputCfg, const wxString& filename) +template <class ConfigType> +void writeConfig(const ConfigType& config, XmlType type, const wxString& filename) { - TiXmlDocument doc; - initXmlDocument(doc, XML_TYPE_BATCH); //throw() + XmlDoc doc("FreeFileSync"); + setXmlType(doc, type); //throw() - if (!doc.RootElement()) - throw XmlError(wxString(_("Error writing file:")) + wxT("\n\"") + filename + wxT("\"")); + XmlOut out(doc); + writeConfig(config, out); - writeConfig(outputCfg, *doc.RootElement()); //add GUI layout configuration settings + saveXmlDocument(doc, filename); //throw (FfsXmlError) +} +} - saveXmlDocument(filename, doc); //throw (XmlError) +void xmlAccess::writeConfig(const XmlGuiConfig& config, const wxString& filename) +{ + ::writeConfig(config, XML_TYPE_GUI, filename); //throw (FfsXmlError) } -void xmlAccess::writeConfig(const XmlGlobalSettings& outputCfg) +void xmlAccess::writeConfig(const XmlBatchConfig& config, const wxString& filename) { - TiXmlDocument doc; - initXmlDocument(doc, XML_TYPE_GLOBAL); //throw() - - if (!doc.RootElement()) - throw XmlError(wxString(_("Error writing file:")) + wxT("\n\"") + getGlobalConfigFile() + wxT("\"")); + ::writeConfig(config, XML_TYPE_BATCH, filename); //throw (FfsXmlError) +} - writeConfig(outputCfg, *doc.RootElement()); //add GUI layout configuration settings - saveXmlDocument(getGlobalConfigFile(), doc); //throw (XmlError) +void xmlAccess::writeConfig(const XmlGlobalSettings& config) +{ + ::writeConfig(config, XML_TYPE_GLOBAL, getGlobalConfigFile()); //throw (FfsXmlError) } |