diff options
Diffstat (limited to 'src/__TODO/SettingsPaths.cpp')
| -rw-r--r-- | src/__TODO/SettingsPaths.cpp | 309 |
1 files changed, 309 insertions, 0 deletions
diff --git a/src/__TODO/SettingsPaths.cpp b/src/__TODO/SettingsPaths.cpp new file mode 100644 index 0000000..a8016f7 --- /dev/null +++ b/src/__TODO/SettingsPaths.cpp @@ -0,0 +1,309 @@ +/*************************************************************************** + * Copyright (C) 2006-2012 by Thomas Schweitzer * + * thomas-schweitzer(at)arcor.de * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License version 2.0 as * + * published by the Free Software Foundation. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program in the file LICENSE.GPL; if not, write to the * + * Free Software Foundation, Inc., * + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + ***************************************************************************/ + +#include "SettingsPaths.h" + +#include <tqcoreapplication.h> +#include <tntqfile.h> +#include <tntqdir.h> +#include <tqdiriterator.h> +#include <tntqstack.h> +#include <tqtdebug.h> + +#include <stdlib.h> + +//! \defgroup grp_Settings All concerning applications settings. + +/*! + \class SettingsPaths + \ingroup grp_Settings + \brief SettingsPaths is a pure static functions class from which info about the + paths needed for settings can be retrieved. +*/ + +bool SettingsPaths::_alreadyInitialized = false; +TQString SettingsPaths::_applicationBinaryPath = ""; +TQString SettingsPaths::_settingsPath = ""; +TQString SettingsPaths::_globalFilesPath = ""; +TQString SettingsPaths::_indenterPath = ""; +TQString SettingsPaths::_tempPath = ""; +bool SettingsPaths::_portableMode = false; + +/*! + \brief Initializes all available information about the paths. + + Mainly during this init it is detected whether to start in portable mode or not. This is + done by testing whether the directory "config" is in the same directory as this + applications executable file. + In portable mode all data is ONLY written to subdirectories of the applications executable file. + Means also that the directory "indenters" has to be there. + In not portable mode (multiuser mode) only users home directory is used for writing config data. + */ +void SettingsPaths::init() +{ + _alreadyInitialized = true; + + tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Initializing application paths."; + + // Get the applications binary path, with respect to MacOSXs use of the .app folder. + _applicationBinaryPath = TQCoreApplication::applicationDirPath(); + // Remove any trailing slashes + while (_applicationBinaryPath.right(1) == "/") + { + _applicationBinaryPath.chop(1); + } + +#ifdef UNIVERSALINDENTGUI_NPP_EXPORTS + _applicationBinaryPath += "/plugins/uigui"; +#endif + +#ifdef Q_OS_MAC + // Because on Mac universal binaries are used, the binary path is not equal + // to the applications (.app) path. So get the .apps path here. + int indexOfDotApp = _applicationBinaryPath.indexOf(".app"); + if (indexOfDotApp != -1) + { + // Cut off after the dot of ".app". + _applicationBinaryPath = _applicationBinaryPath.left(indexOfDotApp - 1); + // Cut off after the first slash that was in front of ".app" (normally this is the word + // "UniversalIndentGUI") + _applicationBinaryPath = _applicationBinaryPath.left(_applicationBinaryPath.lastIndexOf("/")); + } +#endif + + // If the "config" directory is a subdir of the applications binary path, use this one (portable + // mode) + _settingsPath = _applicationBinaryPath + "/config"; + if (TQFile::exists(_settingsPath)) + { + _portableMode = true; + TQDir dirCreator; + _globalFilesPath = _applicationBinaryPath; + _indenterPath = _applicationBinaryPath + "/indenters"; + dirCreator.mkpath(_settingsPath); + _tempPath = _applicationBinaryPath + "/temp"; + //TODO: If the portable drive has write protection, use local temp path and clean it up on exit. + dirCreator.mkpath(_tempPath); + } + // ... otherwise use the system specific global application data path. + else + { + _portableMode = false; + TQDir dirCreator; +#ifdef Q_OS_WIN + // Get the local users application settings directory. + // Remove any trailing slashes. + _settingsPath = TQDir::fromNativeSeparators(qgetenv("APPDATA")); + while (_settingsPath.right(1) == "/") + { + _settingsPath.chop(1); + } + _settingsPath = _settingsPath + "/UniversalIndentGUI"; + + // On windows systems the directories "indenters", "translations" are subdirs of the + // _applicationBinaryPath. + _globalFilesPath = _applicationBinaryPath; +#else + // Remove any trailing slashes. + _settingsPath = TQDir::homePath(); + while (_settingsPath.right(1) == "/") + { + _settingsPath.chop(1); + } + _settingsPath = _settingsPath + "/.universalindentgui"; + _globalFilesPath = "/usr/share/universalindentgui"; +#endif + dirCreator.mkpath(_settingsPath); + // If a highlighter config file does not exist in the users home config dir + // copy the default config file over there. + if (!TQFile::exists(_settingsPath + "/UiGuiSyntaxHighlightConfig.ini")) + { + TQFile::copy(_globalFilesPath + "/config/UiGuiSyntaxHighlightConfig.ini", + _settingsPath + "/UiGuiSyntaxHighlightConfig.ini"); + } + _indenterPath = _globalFilesPath + "/indenters"; + + // On different systems it may be that "TQDir::tempPath()" ends with a "/" or not. So check + // this. + // Remove any trailing slashes. + _tempPath = TQDir::tempPath(); + while (_tempPath.right(1) == "/") + { + _tempPath.chop(1); + } + _tempPath = _tempPath + "/UniversalIndentGUI"; + +#if defined (Q_OS_WIN32) + dirCreator.mkpath(_tempPath); +#else + // On Unix based systems create a random temporary directory for security + // reasons. Otherwise an evil human being could create a symbolic link + // to an important existing file which gets overwritten when UiGUI writes + // into this normally temporary but linked file. + char *pathTemplate = new char[_tempPath.length() + 8]; + TQByteArray pathTemplateTQBA = TQString(_tempPath + "-XXXXXX").toAscii(); + delete[] pathTemplate; + pathTemplate = pathTemplateTQBA.data(); + pathTemplate = mkdtemp(pathTemplate); + _tempPath = pathTemplate; +#endif + } + + tqDebug() << __LINE__ << " " << __FUNCTION__ << ": Paths are:" \ + "<ul><li>_applicationBinaryPath=" << + _applicationBinaryPath << "</li><li>_settingsPath=" << _settingsPath << + "</li><li>_globalFilesPath=" << _globalFilesPath << "</li><li>_indenterPath=" << + _indenterPath << "</li><li>_tempPath=" << _tempPath << + "</li><li>Running in portable mode=" << _portableMode << "</li></ul>"; +} + +/*! + \brief Returns the path of the applications executable. + */ +const TQString SettingsPaths::getApplicationBinaryPath() +{ + if (!_alreadyInitialized) + { + SettingsPaths::init(); + } + return _applicationBinaryPath; +} + +/*! + \brief Returns the path where all settings are being/should be written to. + */ +const TQString SettingsPaths::getSettingsPath() +{ + if (!_alreadyInitialized) + { + SettingsPaths::init(); + } + return _settingsPath; +} + +/*! + \brief Returns the path where the files concerning all users reside. For example translations. + */ +const TQString SettingsPaths::getGlobalFilesPath() +{ + if (!_alreadyInitialized) + { + SettingsPaths::init(); + } + return _globalFilesPath; +} + +/*! + \brief Returns the path where the indenter executables reside. + */ +const TQString SettingsPaths::getIndenterPath() +{ + if (!_alreadyInitialized) + { + SettingsPaths::init(); + } + return _indenterPath; +} + +/*! + \brief Returns the path where the where all temporary data should be written to. + */ +const TQString SettingsPaths::getTempPath() +{ + if (!_alreadyInitialized) + { + SettingsPaths::init(); + } + return _tempPath; +} + +/*! + \brief Returns true if portable mode shall be used. + */ +bool SettingsPaths::getPortableMode() +{ + if (!_alreadyInitialized) + { + SettingsPaths::init(); + } + return _portableMode; +} + +/*! + \brief Completely deletes the created temporary directory with all of its content. + */ +void SettingsPaths::cleanAndRemoveTempDir() +{ + TQDirIterator dirIterator(_tempPath, TQDirIterator::Subdirectories); + TQStack<TQString> directoryStack; + bool noErrorsOccurred = true; + + while (dirIterator.hasNext()) + { + TQString currentDirOrFile = dirIterator.next(); + // If this dummy call isn't done here, calling "dirIterator.fileInfo().isDir()" later somehow + // fails. + dirIterator.fileInfo(); + + if (!currentDirOrFile.isEmpty() && dirIterator.fileName() != "." && + dirIterator.fileName() != "..") + { + // There is a path on the stack but the current path doesn't start with that path. + // So we changed into another parent directory and the one on the stack can be deleted + // since it must be empty. + if (!directoryStack.isEmpty() && !currentDirOrFile.startsWith(directoryStack.top())) + { + TQString dirToBeRemoved = directoryStack.pop(); + bool couldRemoveDir = TQDir(dirToBeRemoved).rmdir(dirToBeRemoved); + noErrorsOccurred &= couldRemoveDir; + if (couldRemoveDir == false) + { + tqWarning() << __LINE__ << " " << __FUNCTION__ << "Could not remove the directory: " << + dirToBeRemoved; + } + //tqDebug() << "Removing Dir " << directoryStack.pop(); + } + + // If the iterator currently points to a directory push it onto the stack. + if (dirIterator.fileInfo().isDir()) + { + directoryStack.push(currentDirOrFile); + //tqDebug() << "Pushing onto Stack " << currentDirOrFile; + } + // otherwise it must be a file, so delete it. + else + { + bool couldRemoveFile = TQFile::remove(currentDirOrFile); + noErrorsOccurred &= couldRemoveFile; + if (couldRemoveFile == false) + { + tqWarning() << __LINE__ << " " << __FUNCTION__ << "Could not remove the file: " << + currentDirOrFile; + } + //tqDebug() << "Removing File " << currentDirOrFile; + } + } + } + noErrorsOccurred &= TQDir(_tempPath).rmdir(_tempPath); + if (noErrorsOccurred == false) + { + tqWarning() << __LINE__ << " " << __FUNCTION__ << + "While cleaning up the temp dir an error occurred."; + } +} |