diff options
Diffstat (limited to 'library/process_xml.cpp')
| -rw-r--r-- | library/process_xml.cpp | 1137 |
1 files changed, 1137 insertions, 0 deletions
diff --git a/library/process_xml.cpp b/library/process_xml.cpp new file mode 100644 index 00000000..e81fb3f9 --- /dev/null +++ b/library/process_xml.cpp @@ -0,0 +1,1137 @@ +// ************************************************************************** +// * 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-2010 ZenJu (zhnmju123 AT gmx.de) * +// ************************************************************************** +// +#include "process_xml.h" +#include "../shared/xml_base.h" +#include <wx/intl.h> +#include <wx/filefn.h> +#include "../shared/global_func.h" +#include "../shared/standard_paths.h" +#include "../shared/string_conv.h" + +using namespace ffs3; +using namespace xmlAccess; //functionally needed!!! + + +class FfsXmlParser : public xmlAccess::XmlParser +{ +public: + FfsXmlParser(const TiXmlElement* rootElement) : xmlAccess::XmlParser(rootElement) {} + + //read gui settings, all values retrieved are optional, so check for initial values! (== -1) + void readXmlGuiConfig(xmlAccess::XmlGuiConfig& outputCfg); + //read batch settings, all values retrieved are optional + void readXmlBatchConfig(xmlAccess::XmlBatchConfig& outputCfg); + //read global settings, valid for both GUI and batch mode, independent from configuration + void readXmlGlobalSettings(xmlAccess::XmlGlobalSettings& outputCfg); + +private: + //read alternate configuration (optional) => might point to NULL + void readXmlLocalConfig(const TiXmlElement& folderPair, FolderPairEnh& enhPair); + + //read basic FreefileSync settings (used by commandline and GUI), return true if ALL values have been retrieved successfully + void readXmlMainConfig(MainConfiguration& mainCfg); +}; + + +//write gui settings +bool writeXmlGuiConfig(const xmlAccess::XmlGuiConfig& outputCfg, TiXmlDocument& doc); +//write batch settings +bool writeXmlBatchConfig(const xmlAccess::XmlBatchConfig& outputCfg, TiXmlDocument& doc); +//write global settings +bool writeXmlGlobalSettings(const xmlAccess::XmlGlobalSettings& outputCfg, TiXmlDocument& doc); +//write alternate configuration (optional) => might point to NULL +void writeXmlLocalConfig(const FolderPairEnh& enhPair, TiXmlElement& parent); +//write basic FreefileSync settings (used by commandline and GUI), return true if everything was written successfully +bool writeXmlMainConfig(const MainConfiguration& mainCfg, TiXmlDocument& doc); + + +void xmlAccess::readConfig(const wxString& filename, xmlAccess::XmlGuiConfig& config) +{ + //load XML + if (!wxFileExists(filename)) + throw XmlError(wxString(_("File does not exist:")) + wxT("\n\"") + filename + wxT("\"")); + + TiXmlDocument doc; + loadXmlDocument(filename, XML_GUI_CONFIG, doc); //throw (XmlError) + + FfsXmlParser parser(doc.RootElement()); + parser.readXmlGuiConfig(config); //read GUI layout configuration + + if (parser.errorsOccurred()) + throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"\n\n") + + parser.getErrorMessageFormatted(), XmlError::WARNING); +} + + +void xmlAccess::readConfig(const wxString& filename, xmlAccess::XmlBatchConfig& config) +{ + //load XML + if (!wxFileExists(filename)) + throw XmlError(wxString(_("File does not exist:")) + wxT("\n\"") + filename + wxT("\"")); + + TiXmlDocument doc; + loadXmlDocument(filename, XML_BATCH_CONFIG, doc); //throw (XmlError) + + FfsXmlParser parser(doc.RootElement()); + parser.readXmlBatchConfig(config); //read GUI layout configuration + + if (parser.errorsOccurred()) + throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + filename + wxT("\"\n\n") + + parser.getErrorMessageFormatted(), XmlError::WARNING); +} + + +void xmlAccess::readConfig(xmlAccess::XmlGlobalSettings& config) +{ + //load XML + if (!wxFileExists(getGlobalConfigFile())) + throw XmlError(wxString(_("File does not exist:")) + wxT("\n\"") + getGlobalConfigFile() + wxT("\"")); + + TiXmlDocument doc; + loadXmlDocument(getGlobalConfigFile(), XML_GLOBAL_SETTINGS, doc); //throw (XmlError) + + FfsXmlParser parser(doc.RootElement()); + parser.readXmlGlobalSettings(config); //read GUI layout configuration + + if (parser.errorsOccurred()) + throw XmlError(wxString(_("Error parsing configuration file:")) + wxT("\n\"") + getGlobalConfigFile() + wxT("\"\n\n") + + parser.getErrorMessageFormatted(), XmlError::WARNING); +} + + +void xmlAccess::writeConfig(const XmlGuiConfig& outputCfg, const wxString& filename) +{ + TiXmlDocument doc; + getDefaultXmlDocument(XML_GUI_CONFIG, doc); + + //populate and write XML tree + if (!writeXmlGuiConfig(outputCfg, doc)) //add GUI layout configuration settings + throw XmlError(wxString(_("Error writing file:")) + wxT("\n\"") + filename + wxT("\"")); + + saveXmlDocument(filename, doc); //throw (XmlError) +} + + +void xmlAccess::writeConfig(const XmlBatchConfig& outputCfg, const wxString& filename) +{ + TiXmlDocument doc; + getDefaultXmlDocument(XML_BATCH_CONFIG, doc); + + //populate and write XML tree + if (!writeXmlBatchConfig(outputCfg, doc)) //add batch configuration settings + throw XmlError(wxString(_("Error writing file:")) + wxT("\n\"") + filename + wxT("\"")); + + saveXmlDocument(filename, doc); //throw (XmlError) +} + + +void xmlAccess::writeConfig(const XmlGlobalSettings& outputCfg) +{ + TiXmlDocument doc; + getDefaultXmlDocument(XML_GLOBAL_SETTINGS, doc); + + //populate and write XML tree + if (!writeXmlGlobalSettings(outputCfg, doc)) //add GUI layout configuration settings + throw XmlError(wxString(_("Error writing file:")) + wxT("\n\"") + getGlobalConfigFile() + wxT("\"")); + + saveXmlDocument(getGlobalConfigFile(), doc); //throw (XmlError) +} + + +bool readXmlElement(const std::string& name, const TiXmlElement* parent, CompareVariant& output) +{ + std::string dummy; + if (xmlAccess::readXmlElement(name, parent, dummy)) + { + if (dummy == "ByTimeAndSize") + output = ffs3::CMP_BY_TIME_SIZE; + else if (dummy == "ByContent") + output = ffs3::CMP_BY_CONTENT; + else + return false; + + return true; + } + else + return false; +} + + +bool readXmlElement(const std::string& name, const TiXmlElement* parent, SyncDirection& output) +{ + 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; +} + + +bool readXmlElement(const std::string& name, const TiXmlElement* parent, xmlAccess::OnError& output) +{ + 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; +} + + +bool readXmlElement(const std::string& name, const TiXmlElement* parent , ffs3::DeletionPolicy& output) +{ + std::string dummy; + if (xmlAccess::readXmlElement(name, parent, dummy)) + { + if (dummy == "DeletePermanently") + output = ffs3::DELETE_PERMANENTLY; + else if (dummy == "MoveToRecycleBin") + output = ffs3::MOVE_TO_RECYCLE_BIN; + else if (dummy == "MoveToCustomDirectory") + output = ffs3::MOVE_TO_CUSTOM_DIRECTORY; + else + return false; + + return true; + } + return false; +} + + +bool readXmlElement(const std::string& name, const TiXmlElement* parent , ffs3::SymLinkHandling& output) +{ + std::string dummy; + if (xmlAccess::readXmlElement(name, parent, dummy)) + { + if (dummy == "Ignore") + output = ffs3::SYMLINK_IGNORE; + else if (dummy == "UseDirectly") + output = ffs3::SYMLINK_USE_DIRECTLY; + else if (dummy == "FollowLink") + output = ffs3::SYMLINK_FOLLOW_LINK; + else + return false; + + return true; + } + return false; +} + + +bool readXmlElement(const std::string& name, const TiXmlElement* parent, Zstring& output) +{ + 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) +{ + int dummy = 0; + if (xmlAccess::readXmlAttribute(name, node, dummy)) + { + output = static_cast<xmlAccess::ColumnTypes>(dummy); + return true; + } + else + return false; +} + + +//################################################################################################################ +void FfsXmlParser::readXmlLocalConfig(const TiXmlElement& folderPair, FolderPairEnh& enhPair) +{ + //read folder pairs + readXmlElementLogging("Left", &folderPair, enhPair.leftDirectory); + readXmlElementLogging("Right", &folderPair, enhPair.rightDirectory); + + +//########################################################### + //alternate sync configuration + const TiXmlElement* altSyncConfig = TiXmlHandleConst(&folderPair).FirstChild("AlternateSyncConfig").ToElement(); + if (altSyncConfig) + { + AlternateSyncConfig* altSyncCfg = new AlternateSyncConfig; + enhPair.altSyncConfig.reset(altSyncCfg); + + const TiXmlElement* syncCfg = TiXmlHandleConst(altSyncConfig).FirstChild("Synchronization").ToElement(); + const TiXmlElement* syncDirections = TiXmlHandleConst(syncCfg).FirstChild("Directions").ToElement(); + + //read sync configuration + readXmlElementLogging("Automatic", syncCfg, altSyncCfg->syncConfiguration.automatic); + readXmlElementLogging("LeftOnly", syncDirections, altSyncCfg->syncConfiguration.exLeftSideOnly); + readXmlElementLogging("RightOnly", syncDirections, altSyncCfg->syncConfiguration.exRightSideOnly); + readXmlElementLogging("LeftNewer", syncDirections, altSyncCfg->syncConfiguration.leftNewer); + readXmlElementLogging("RightNewer", syncDirections, altSyncCfg->syncConfiguration.rightNewer); + readXmlElementLogging("Different", syncDirections, altSyncCfg->syncConfiguration.different); + readXmlElementLogging("Conflict", syncDirections, altSyncCfg->syncConfiguration.conflict); + + const TiXmlElement* miscSettings = TiXmlHandleConst(&folderPair).FirstChild("AlternateSyncConfig").FirstChild("Miscellaneous").ToElement(); + readXmlElementLogging("DeletionPolicy", miscSettings, altSyncCfg->handleDeletion); + readXmlElementLogging("CustomDeletionFolder", miscSettings, altSyncCfg->customDeletionDirectory); + } + +//########################################################### + //alternate filter configuration + const TiXmlElement* filterCfg = TiXmlHandleConst(&folderPair).FirstChild("LocalFilter").ToElement(); + if (filterCfg) + { + //read filter settings + readXmlElementLogging("Include", filterCfg, enhPair.localFilter.includeFilter); + readXmlElementLogging("Exclude", filterCfg, enhPair.localFilter.excludeFilter); + } +} + + +void FfsXmlParser::readXmlMainConfig(MainConfiguration& mainCfg) +{ + TiXmlHandleConst hRoot(getRoot()); //custom const handle: TiXml API seems broken in this regard + +//########################################################### + 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* syncCfg = hRoot.FirstChild("MainConfig").FirstChild("Synchronization").ToElement(); + const TiXmlElement* syncDirections = TiXmlHandleConst(syncCfg).FirstChild("Directions").ToElement(); + + //read sync configuration + readXmlElementLogging("Automatic", syncCfg, mainCfg.syncConfiguration.automatic); + readXmlElementLogging("LeftOnly", syncDirections, mainCfg.syncConfiguration.exLeftSideOnly); + readXmlElementLogging("RightOnly", syncDirections, mainCfg.syncConfiguration.exRightSideOnly); + readXmlElementLogging("LeftNewer", syncDirections, mainCfg.syncConfiguration.leftNewer); + readXmlElementLogging("RightNewer", syncDirections, mainCfg.syncConfiguration.rightNewer); + readXmlElementLogging("Different", syncDirections, mainCfg.syncConfiguration.different); + readXmlElementLogging("Conflict", syncDirections, mainCfg.syncConfiguration.conflict); + +//########################################################### + const TiXmlElement* miscSettings = hRoot.FirstChild("MainConfig").FirstChild("Miscellaneous").ToElement(); + + //misc + readXmlElementLogging("DeletionPolicy", miscSettings, mainCfg.handleDeletion); + readXmlElementLogging("CustomDeletionFolder", miscSettings, mainCfg.customDeletionDirectory); +//########################################################### + const TiXmlElement* filter = TiXmlHandleConst(miscSettings).FirstChild("Filter").ToElement(); + + //read filter settings + Zstring includeFilter; + Zstring excludeFilter; + readXmlElementLogging("Include", filter, includeFilter); + readXmlElementLogging("Exclude", filter, excludeFilter); + + mainCfg.globalFilter = FilterConfig(includeFilter, excludeFilter); + +//########################################################### + const TiXmlElement* pairs = hRoot.FirstChild("MainConfig").FirstChild("FolderPairs").FirstChild("Pair").ToElement(); + + //read all folder pairs + mainCfg.additionalPairs.clear(); + bool firstLoop = true; + while (pairs) + { + FolderPairEnh newPair; + readXmlLocalConfig(*pairs, newPair); + + if (firstLoop) //read first folder pair + { + firstLoop = false; + mainCfg.firstPair = newPair; + } + else //read additional folder pairs + mainCfg.additionalPairs.push_back(newPair); + + pairs = pairs->NextSiblingElement(); + } +} + + +void FfsXmlParser::readXmlGuiConfig(xmlAccess::XmlGuiConfig& outputCfg) +{ + //read main config + readXmlMainConfig(outputCfg.mainCfg); + + //read GUI specific config data + const TiXmlElement* guiConfig = TiXmlHandleConst(getRoot()).FirstChild("GuiConfig").ToElement(); + + readXmlElementLogging("HideFiltered", guiConfig, outputCfg.hideFilteredElements); + + xmlAccess::OnError errorHand = ON_ERROR_POPUP; + readXmlElementLogging("HandleError", guiConfig, errorHand); + outputCfg.ignoreErrors = errorHand == xmlAccess::ON_ERROR_IGNORE; + + readXmlElementLogging("SyncPreviewActive", guiConfig, outputCfg.syncPreviewEnabled); +} + + +void FfsXmlParser::readXmlBatchConfig(xmlAccess::XmlBatchConfig& outputCfg) +{ + //read main config + readXmlMainConfig(outputCfg.mainCfg); + + //read batch specific config + const TiXmlElement* batchConfig = TiXmlHandleConst(getRoot()).FirstChild("BatchConfig").ToElement(); + + readXmlElementLogging("Silent", batchConfig, outputCfg.silent); + readXmlElementLogging("LogfileDirectory", batchConfig, outputCfg.logFileDirectory); + readXmlElementLogging("HandleError", batchConfig, outputCfg.handleError); +} + + +void FfsXmlParser::readXmlGlobalSettings(xmlAccess::XmlGlobalSettings& outputCfg) +{ + //read global settings + const TiXmlElement* global = TiXmlHandleConst(getRoot()).FirstChild("Shared").ToElement(); + + //try to read program language setting + readXmlElementLogging("Language", global, outputCfg.programLanguage); + + //ignore +/- 1 hour due to DST change + readXmlElementLogging("IgnoreOneHourDifference", global, outputCfg.ignoreOneHourDiff); + + //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(getRoot()).FirstChild("Shared").FirstChild("ShowOptionalDialogs").ToElement(); + + //folder dependency check + readXmlElementLogging("CheckForDependentFolders", optionalDialogs, outputCfg.optDialogs.warningDependentFolders); + //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(getRoot()).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); + +//########################################################### + //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(); + } + + //load folder history elements + const TiXmlElement* historyLeft = TiXmlHandleConst(mainWindow).FirstChild("FolderHistoryLeft").ToElement(); + //load max. history size + readXmlAttributeLogging("MaximumSize", historyLeft, outputCfg.gui.folderHistLeftMax); + //load config history elements + readXmlElementLogging("Folder", historyLeft, outputCfg.gui.folderHistoryLeft); + + + const TiXmlElement* historyRight = TiXmlHandleConst(mainWindow).FirstChild("FolderHistoryRight").ToElement(); + //load max. history size + readXmlAttributeLogging("MaximumSize", historyRight, outputCfg.gui.folderHistRightMax); + //load config history elements + readXmlElementLogging("Folder", historyRight, outputCfg.gui.folderHistoryRight); + + + readXmlElementLogging("SelectedTabBottomLeft", mainWindow, outputCfg.gui.selectedTabBottomLeft); + + + //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 max. history size + readXmlAttributeLogging("MaximumSize", cfgHistory, outputCfg.gui.cfgHistoryMax); + + //load config history elements + 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(); +} + + +void addXmlElement(const std::string& name, const CompareVariant variant, TiXmlElement* parent) +{ + switch (variant) + { + case ffs3::CMP_BY_TIME_SIZE: + xmlAccess::addXmlElement(name, std::string("ByTimeAndSize"), parent); + break; + case ffs3::CMP_BY_CONTENT: + xmlAccess::addXmlElement(name, std::string("ByContent"), parent); + break; + } +} + + +void addXmlElement(const std::string& name, const SyncDirection value, TiXmlElement* parent) +{ + switch (value) + { + case SYNC_DIR_LEFT: + xmlAccess::addXmlElement(name, std::string("left"), parent); + break; + case SYNC_DIR_RIGHT: + xmlAccess::addXmlElement(name, std::string("right"), parent); + break; + case SYNC_DIR_NONE: + xmlAccess::addXmlElement(name, std::string("none"), parent); + break; + } +} + + +void addXmlElement(const std::string& name, const xmlAccess::OnError value, TiXmlElement* parent) +{ + switch (value) + { + case xmlAccess::ON_ERROR_IGNORE: + xmlAccess::addXmlElement(name, std::string("Ignore"), parent); + break; + case xmlAccess::ON_ERROR_EXIT: + xmlAccess::addXmlElement(name, std::string("Exit"), parent); + break; + case xmlAccess::ON_ERROR_POPUP: + xmlAccess::addXmlElement(name, std::string("Popup"), parent); + break; + } +} + + +void addXmlElement(const std::string& name, const ffs3::DeletionPolicy value, TiXmlElement* parent) +{ + switch (value) + { + case ffs3::DELETE_PERMANENTLY: + xmlAccess::addXmlElement(name, std::string("DeletePermanently"), parent); + break; + case ffs3::MOVE_TO_RECYCLE_BIN: + xmlAccess::addXmlElement(name, std::string("MoveToRecycleBin"), parent); + break; + case ffs3::MOVE_TO_CUSTOM_DIRECTORY: + xmlAccess::addXmlElement(name, std::string("MoveToCustomDirectory"), parent); + break; + } +} + + +void addXmlElement(const std::string& name, const ffs3::SymLinkHandling value, TiXmlElement* parent) +{ + switch (value) + { + case ffs3::SYMLINK_IGNORE: + xmlAccess::addXmlElement(name, std::string("Ignore"), parent); + break; + case ffs3::SYMLINK_USE_DIRECTLY: + xmlAccess::addXmlElement(name, std::string("UseDirectly"), parent); + break; + case ffs3::SYMLINK_FOLLOW_LINK: + xmlAccess::addXmlElement(name, std::string("FollowLink"), parent); + break; + } +} + + +void addXmlElement(const std::string& name, const Zstring& value, TiXmlElement* parent) +{ + xmlAccess::addXmlElement(name, wxString(zToWx(value)), parent); +} + + +void addXmlAttribute(const std::string& name, const xmlAccess::ColumnTypes value, TiXmlElement* node) +{ + xmlAccess::addXmlAttribute(name, static_cast<int>(value), node); +} + + +void writeXmlLocalConfig(const FolderPairEnh& enhPair, TiXmlElement& parent) +{ + //write folder pairs + TiXmlElement* newfolderPair = new TiXmlElement("Pair"); + parent.LinkEndChild(newfolderPair); + + addXmlElement("Left", enhPair.leftDirectory, newfolderPair); + addXmlElement("Right", enhPair.rightDirectory, newfolderPair); + + + //alternate sync configuration + const AlternateSyncConfig* altSyncConfig = enhPair.altSyncConfig.get(); + if (altSyncConfig) + { + TiXmlElement* syncCfg = new TiXmlElement("AlternateSyncConfig"); + newfolderPair->LinkEndChild(syncCfg); + + TiXmlElement* syncSettings = new TiXmlElement("Synchronization"); + syncCfg->LinkEndChild(syncSettings); + + //write sync configuration + addXmlElement("Automatic", altSyncConfig->syncConfiguration.automatic, syncSettings); + + TiXmlElement* syncDirections = new TiXmlElement("Directions"); + syncSettings->LinkEndChild(syncDirections); + + addXmlElement("LeftOnly", altSyncConfig->syncConfiguration.exLeftSideOnly, syncDirections); + addXmlElement("RightOnly", altSyncConfig->syncConfiguration.exRightSideOnly, syncDirections); + addXmlElement("LeftNewer", altSyncConfig->syncConfiguration.leftNewer, syncDirections); + addXmlElement("RightNewer", altSyncConfig->syncConfiguration.rightNewer, syncDirections); + addXmlElement("Different", altSyncConfig->syncConfiguration.different, syncDirections); + addXmlElement("Conflict", altSyncConfig->syncConfiguration.conflict, syncDirections); + + + TiXmlElement* miscSettings = new TiXmlElement("Miscellaneous"); + syncCfg->LinkEndChild(miscSettings); + + //misc + addXmlElement("DeletionPolicy", altSyncConfig->handleDeletion, miscSettings); + addXmlElement("CustomDeletionFolder", altSyncConfig->customDeletionDirectory, miscSettings); + } + +//########################################################### + //alternate filter configuration + TiXmlElement* filterCfg = new TiXmlElement("LocalFilter"); + newfolderPair->LinkEndChild(filterCfg); + + //write filter settings + addXmlElement("Include", enhPair.localFilter.includeFilter, filterCfg); + addXmlElement("Exclude", enhPair.localFilter.excludeFilter, filterCfg); +} + + +bool writeXmlMainConfig(const MainConfiguration& mainCfg, TiXmlDocument& doc) +{ + TiXmlElement* root = doc.RootElement(); + if (!root) return false; + + TiXmlElement* settings = new TiXmlElement("MainConfig"); + root->LinkEndChild(settings); + +//########################################################### + TiXmlElement* cmpSettings = new TiXmlElement("Comparison"); + settings->LinkEndChild(cmpSettings); + + //write compare algorithm + addXmlElement("Variant", mainCfg.compareVar, cmpSettings); + + //include symbolic links at all? + addXmlElement("HandleSymlinks", mainCfg.handleSymlinks, cmpSettings); + +//########################################################### + TiXmlElement* syncSettings = new TiXmlElement("Synchronization"); + settings->LinkEndChild(syncSettings); + + //write sync configuration + addXmlElement("Automatic", mainCfg.syncConfiguration.automatic, syncSettings); + + TiXmlElement* syncDirections = new TiXmlElement("Directions"); + syncSettings->LinkEndChild(syncDirections); + + addXmlElement("LeftOnly", mainCfg.syncConfiguration.exLeftSideOnly, syncDirections); + addXmlElement("RightOnly", mainCfg.syncConfiguration.exRightSideOnly, syncDirections); + addXmlElement("LeftNewer", mainCfg.syncConfiguration.leftNewer, syncDirections); + addXmlElement("RightNewer", mainCfg.syncConfiguration.rightNewer, syncDirections); + addXmlElement("Different", mainCfg.syncConfiguration.different, syncDirections); + addXmlElement("Conflict", mainCfg.syncConfiguration.conflict, syncDirections); + +//########################################################### + TiXmlElement* miscSettings = new TiXmlElement("Miscellaneous"); + settings->LinkEndChild(miscSettings); + + //write filter settings + TiXmlElement* filter = new TiXmlElement("Filter"); + miscSettings->LinkEndChild(filter); + + addXmlElement("Include", mainCfg.globalFilter.includeFilter, filter); + addXmlElement("Exclude", mainCfg.globalFilter.excludeFilter, filter); + + //other + addXmlElement("DeletionPolicy", mainCfg.handleDeletion, miscSettings); + addXmlElement("CustomDeletionFolder", mainCfg.customDeletionDirectory, miscSettings); + +//########################################################### + TiXmlElement* pairs = new TiXmlElement("FolderPairs"); + settings->LinkEndChild(pairs); + + //write first folder pair + writeXmlLocalConfig(mainCfg.firstPair, *pairs); + + //write additional folder pairs + for (std::vector<FolderPairEnh>::const_iterator i = mainCfg.additionalPairs.begin(); i != mainCfg.additionalPairs.end(); ++i) + writeXmlLocalConfig(*i, *pairs); + + return true; +} + + +bool writeXmlGuiConfig(const xmlAccess::XmlGuiConfig& inputCfg, TiXmlDocument& doc) +{ + //write main config + if (!writeXmlMainConfig(inputCfg.mainCfg, doc)) + return false; + + //write GUI specific config + TiXmlElement* root = doc.RootElement(); + if (!root) return false; + + TiXmlElement* guiConfig = new TiXmlElement("GuiConfig"); + root->LinkEndChild(guiConfig); + + addXmlElement("HideFiltered", inputCfg.hideFilteredElements, guiConfig); + + addXmlElement("HandleError", inputCfg.ignoreErrors ? xmlAccess::ON_ERROR_IGNORE : xmlAccess::ON_ERROR_POPUP, guiConfig); + + addXmlElement("SyncPreviewActive", inputCfg.syncPreviewEnabled, guiConfig); + + return true; +} + + +bool writeXmlBatchConfig(const xmlAccess::XmlBatchConfig& inputCfg, TiXmlDocument& doc) +{ + //write main config + if (!writeXmlMainConfig(inputCfg.mainCfg, doc)) + return false; + + //write GUI specific config + TiXmlElement* root = doc.RootElement(); + if (!root) return false; + + TiXmlElement* batchConfig = new TiXmlElement("BatchConfig"); + root->LinkEndChild(batchConfig); + + addXmlElement("Silent", inputCfg.silent, batchConfig); + addXmlElement("LogfileDirectory", inputCfg.logFileDirectory, batchConfig); + addXmlElement("HandleError", inputCfg.handleError, batchConfig); + + return true; +} + + +bool writeXmlGlobalSettings(const xmlAccess::XmlGlobalSettings& inputCfg, TiXmlDocument& doc) +{ + TiXmlElement* root = doc.RootElement(); + if (!root) return false; + + //################################################################### + //write global settings + TiXmlElement* global = new TiXmlElement("Shared"); + root->LinkEndChild(global); + + //program language + addXmlElement("Language", inputCfg.programLanguage, global); + + //ignore +/- 1 hour due to DST change + addXmlElement("IgnoreOneHourDifference", inputCfg.ignoreOneHourDiff, global); + + //copy locked files using VSS + addXmlElement("CopyLockedFiles", inputCfg.copyLockedFiles, global); + + //file permissions + addXmlElement("CopyFilePermissions", inputCfg.copyFilePermissions, global); + + //verify file copying + addXmlElement("VerifyCopiedFiles", inputCfg.verifyFileCopy, global); + + //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); + + //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); + + TiXmlElement* mainWindow = new TiXmlElement("Main"); + windows->LinkEndChild(mainWindow); + + //window size + addXmlElement("Width", inputCfg.gui.widthNotMaximized, mainWindow); + addXmlElement("Height", inputCfg.gui.heightNotMaximized, mainWindow); + + //window position + addXmlElement("PosX", inputCfg.gui.posXNotMaximized, mainWindow); + addXmlElement("PosY", inputCfg.gui.posYNotMaximized, mainWindow); + addXmlElement("Maximized", inputCfg.gui.isMaximized, mainWindow); + + addXmlElement("ManualDeletionOnBothSides", inputCfg.gui.deleteOnBothSides, mainWindow); + addXmlElement("ManualDeletionUseRecycler", inputCfg.gui.useRecyclerForManualDeletion, mainWindow); + + addXmlElement("RespectCaseOnSearch", inputCfg.gui.textSearchRespectCase, mainWindow); + + //write column attributes + TiXmlElement* leftColumn = new TiXmlElement("LeftColumns"); + mainWindow->LinkEndChild(leftColumn); + + addXmlAttribute("AutoAdjust", inputCfg.gui.autoAdjustColumnsLeft, leftColumn); + addXmlAttribute("ShowFileIcons", inputCfg.gui.showFileIconsLeft, leftColumn); + + 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); + + const ColumnAttrib& colAttrib = columnAtrribLeftCopy[i]; + addXmlAttribute("Type", colAttrib.type, subElement); + addXmlAttribute("Visible", colAttrib.visible, subElement); + addXmlAttribute("Width", colAttrib.width, subElement); + } + + TiXmlElement* rightColumn = new TiXmlElement("RightColumns"); + mainWindow->LinkEndChild(rightColumn); + + addXmlAttribute("AutoAdjust", inputCfg.gui.autoAdjustColumnsRight, rightColumn); + addXmlAttribute("ShowFileIcons", inputCfg.gui.showFileIconsRight, rightColumn); + + 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); + + const ColumnAttrib& colAttrib = columnAtrribRightCopy[i]; + addXmlAttribute("Type", colAttrib.type, subElement); + addXmlAttribute("Visible", colAttrib.visible, subElement); + addXmlAttribute("Width", colAttrib.width, subElement); + } + + //write folder history elements + TiXmlElement* historyLeft = new TiXmlElement("FolderHistoryLeft"); + mainWindow->LinkEndChild(historyLeft); + TiXmlElement* historyRight = new TiXmlElement("FolderHistoryRight"); + mainWindow->LinkEndChild(historyRight); + + addXmlAttribute("MaximumSize", inputCfg.gui.folderHistLeftMax, historyLeft); + addXmlAttribute("MaximumSize", inputCfg.gui.folderHistRightMax, historyRight); + + addXmlElement("Folder", inputCfg.gui.folderHistoryLeft, historyLeft); + addXmlElement("Folder", inputCfg.gui.folderHistoryRight, historyRight); + + addXmlElement("SelectedTabBottomLeft", inputCfg.gui.selectedTabBottomLeft, mainWindow); + + //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); + + addXmlAttribute("Description", i->first, newEntry); + newEntry->LinkEndChild(new TiXmlText(i->second.ToUTF8())); //commandline + } + + //write config file history + TiXmlElement* cfgHistory = new TiXmlElement("ConfigHistory"); + gui->LinkEndChild(cfgHistory); + + addXmlAttribute("MaximumSize", inputCfg.gui.cfgHistoryMax, cfgHistory); + addXmlElement("File", inputCfg.gui.cfgFileHistory, cfgHistory); + + + //last update check + addXmlElement("LastUpdateCheck", inputCfg.gui.lastUpdateCheck, gui); + + //################################################################### + //write global batch settings + + TiXmlElement* batch = new TiXmlElement("Batch"); + root->LinkEndChild(batch); + + return true; +} + + +int xmlAccess::retrieveSystemLanguage() +{ + return wxLocale::GetSystemLanguage(); +} + + +wxString xmlAccess::getGlobalConfigFile() +{ + return ffs3::getConfigDir() + wxT("GlobalSettings.xml"); +} + + +void xmlAccess::OptionalDialogs::resetDialogs() +{ + warningDependentFolders = true; + warningSignificantDifference = true; + warningNotEnoughDiskSpace = true; + warningUnresolvedConflicts = true; + warningSyncDatabase = true; + popupOnConfigChange = true; + showSummaryBeforeSync = true; +} + + +xmlAccess::XmlGuiConfig xmlAccess::convertBatchToGui(const xmlAccess::XmlBatchConfig& batchCfg) +{ + XmlGuiConfig output; + output.mainCfg = batchCfg.mainCfg; + return output; +} + + +xmlAccess::XmlBatchConfig xmlAccess::convertGuiToBatch(const xmlAccess::XmlGuiConfig& guiCfg) +{ + XmlBatchConfig output; + output.mainCfg = guiCfg.mainCfg; + + if (guiCfg.ignoreErrors) + output.handleError = xmlAccess::ON_ERROR_IGNORE; + else + output.handleError = xmlAccess::ON_ERROR_POPUP; + + return output; +} + + +xmlAccess::MergeType xmlAccess::getMergeType(const std::vector<wxString>& filenames) //throw () +{ + bool guiCfgExists = false; + bool batchCfgExists = false; + + for (std::vector<wxString>::const_iterator i = filenames.begin(); i != filenames.end(); ++i) + { + switch (xmlAccess::getXmlType(*i)) //throw() + { + case XML_GUI_CONFIG: + guiCfgExists = true; + break; + + case XML_BATCH_CONFIG: + batchCfgExists = true; + break; + + case XML_GLOBAL_SETTINGS: + case XML_REAL_CONFIG: + case XML_OTHER: + return MERGE_OTHER; + } + } + + 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; +} + + +namespace +{ +template <class XmlCfg> +XmlCfg loadCfgImpl(const wxString& filename, std::auto_ptr<xmlAccess::XmlError>& exeption) //throw (xmlAccess::XmlError) +{ + 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; +} + + +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; + + std::vector<ffs3::MainConfiguration> mainCfgs; + std::auto_ptr<XmlError> savedException; + + for (std::vector<wxString>::const_iterator i = filenames.begin(); i != filenames.end(); ++i) + { + switch (getXmlType(*i)) + { + case XML_GUI_CONFIG: + mainCfgs.push_back(loadCfgImpl<XmlGuiConfig>(*i, savedException).mainCfg); //throw (xmlAccess::XmlError) + break; + + case XML_BATCH_CONFIG: + mainCfgs.push_back(loadCfgImpl<XmlBatchConfig>(*i, savedException).mainCfg); //throw (xmlAccess::XmlError) + break; + + case XML_GLOBAL_SETTINGS: + case XML_REAL_CONFIG: + case XML_OTHER: + break; + } + } + + if (mainCfgs.empty()) + throw XmlError(_("Invalid FreeFileSync config file!")); + + try //...to init all non-"mainCfg" settings with first config file + { + xmlAccess::readConfig(filenames[0], config); //throw (xmlAccess::XmlError); + } + catch (...) {} + + config.mainCfg = merge(mainCfgs); + + if (savedException.get()) //"re-throw" exception + throw *savedException; +} +} + + +void xmlAccess::convertConfig(const std::vector<wxString>& filenames, XmlGuiConfig& config) //throw (xmlAccess::XmlError) +{ + mergeConfigFilesImpl(filenames, config); //throw (xmlAccess::XmlError) +} + + +void xmlAccess::convertConfig(const std::vector<wxString>& filenames, XmlBatchConfig& config) //throw (xmlAccess::XmlError); +{ + mergeConfigFilesImpl(filenames, config); //throw (xmlAccess::XmlError) +} |