settings.hpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2014  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    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.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
 
#ifndef SETTINGS_HPP
#define SETTINGS_HPP
 
#include <string>
#include <map>
 
#ifndef RELEASE
#include <cassert>
#endif
 
#include "ui/error.hpp"
#include "documentation/doc_helper.hpp"
 
#define SETTING_B_DEVELOPERMODE       "internal.developermode"
#define SETTING_B_DEBUGGER            "internal.debugger"
#define SETTING_B_SYSTEMPRINTS        "internal.usesystemprints"
#define SETTING_B_DRAFTMODE           "plotting.draftmode"
#define SETTING_B_COMPACT             "table.compact"
#define SETTING_B_LOADEMPTYCOLS       "table.loademptycols"
#define SETTING_B_SHOWHINTS           "ui.showhints"
#define SETTING_B_USECUSTOMLANG       "ui.usecustomlang"
#define SETTING_B_EXTERNALDOCWINDOW   "ui.externaldocwindow"
#define SETTING_B_EXTENDEDFILEINFO    "io.extendedfileinfo"
#define SETTING_B_LOGFILE             "io.logfile"
#define SETTING_B_DEFCONTROL          "io.defcontrol"
#define SETTING_B_TABLEREFS           "flowctrl.alwaysreferencetables"
#define SETTING_B_USEESCINSCRIPTS     "flowctrl.useescinscripts"
#define SETTING_B_ENABLEEXECUTE       "flowctrl.enableexecute"
#define SETTING_B_MASKDEFAULT         "flowctrl.maskdefault"
#define SETTING_B_DECODEARGUMENTS     "debugger.decodearguments"
#define SETTING_B_GREETING            "terminal.greeting"
#define SETTING_V_PRECISION           "terminal.precision"
#define SETTING_V_WINDOW_X            "terminal.windowsize.x"
#define SETTING_V_WINDOW_Y            "terminal.windowsize.y"
#define SETTING_V_BUFFERSIZE          "terminal.buffersize"
#define SETTING_S_TERMINALFONT        "terminal.font"
#define SETTING_S_HISTORYFONT         "history.font"
#define SETTING_V_AUTOSAVE            "table.autosave"
#define SETTING_S_EXEPATH             "path.exepath"
#define SETTING_S_SAVEPATH            "path.savepath"
#define SETTING_S_LOADPATH            "path.loadpath"
#define SETTING_S_PLOTPATH            "path.plotpath"
#define SETTING_S_SCRIPTPATH          "path.scriptpath"
#define SETTING_S_PROCPATH            "path.procpath"
#define SETTING_S_WORKPATH            "path.workpath"
#define SETTING_S_PLOTFONT            "plotting.plotfont"
 
// Setting value definitions for the GUI
#define SETTING_S_LATEXROOT           "path.latexpath"
#define SETTING_V_CARETBLINKTIME      "ui.caretblinktime"
#define SETTING_V_FOCUSEDLINE         "debugger.focusedline"
#define SETTING_B_LINESINSTACK        "debugger.linenumbersinstacktrace"
#define SETTING_B_MODULESINSTACK      "debugger.modulesinstacktrace"
#define SETTING_B_GLOBALVARS          "debugger.showglobalvars"
#define SETTING_B_PROCEDUREARGS       "debugger.showarguments"
#define SETTING_B_FLASHTASKBAR        "debugger.flashtaskbar"
#define SETTING_B_TOOLBARTEXT         "ui.showtoolbartext"
#define SETTING_B_PATHSONTABS         "ui.showpathsontabs"
#define SETTING_B_ICONSONTABS         "ui.showiconsontabs"
#define SETTING_V_POS_SASH_V          "ui.position.verticalsash"
#define SETTING_V_POS_SASH_H          "ui.position.horizontalsash"
#define SETTING_V_POS_SASH_T          "ui.position.terminalsash"
#define SETTING_S_WINDOWSIZE          "ui.windowsize"
#define SETTING_B_PRINTINCOLOR        "print.usecolor"
#define SETTING_B_PRINTLINENUMBERS    "print.linenumbers"
#define SETTING_B_SAVESESSION         "save.session"
#define SETTING_B_SAVEBOOKMARKS       "save.bookmarks"
#define SETTING_B_FORMATBEFORESAVING  "save.format"
#define SETTING_B_USEREVISIONS        "save.revisions"
#define SETTING_B_AUTOSAVEEXECUTION   "save.beforeexecution"
#define SETTING_B_SAVESASHS           "save.sashs"
#define SETTING_B_SAVEWINDOWSIZE      "save.windowsize"
#define SETTING_B_FOLDLOADEDFILE      "editor.foldloadedfile"
#define SETTING_B_HIGHLIGHTLOCALS     "editor.highlightlocals"
#define SETTING_B_USETABS             "editor.usetabs"
#define SETTING_B_LINELENGTH          "editor.linelengthindicator"
#define SETTING_B_HOMEENDCANCELS      "editor.autocomp.homeendcancels"
#define SETTING_B_BRACEAUTOCOMP       "editor.autocomp.braces"
#define SETTING_B_QUOTEAUTOCOMP       "editor.autocomp.quotes"
#define SETTING_B_BLOCKAUTOCOMP       "editor.autocomp.blocks"
#define SETTING_B_SMARTSENSE          "editor.autocomp.smartsense"
#define SETTING_S_EDITORFONT          "editor.font"
#define SETTING_B_AN_START            "editor.analyzer._"
#define SETTING_B_AN_USENOTES         "editor.analyzer.usenotes"
#define SETTING_B_AN_USEWARNINGS      "editor.analyzer.usewarnings"
#define SETTING_B_AN_USEERRORS        "editor.analyzer.useerrors"
#define SETTING_B_AN_MAGICNUMBERS     "editor.analyzer.style.magicnumbers"
#define SETTING_B_AN_UNDERSCOREARGS   "editor.analyzer.style.underscoredarguments"
#define SETTING_B_AN_THISFILE         "editor.analyzer.namespace.thisfile"
#define SETTING_B_AN_COMMENTDENS      "editor.analyzer.metrics.commentdensity"
#define SETTING_B_AN_LOC              "editor.analyzer.metrics.linesofcode"
#define SETTING_B_AN_COMPLEXITY       "editor.analyzer.metrics.complexity"
#define SETTING_B_AN_ALWAYSMETRICS    "editor.analyzer.metrics.showalways"
#define SETTING_B_AN_RESULTSUP        "editor.analyzer.result.suppression"
#define SETTING_B_AN_RESULTASS        "editor.analyzer.result.assignment"
#define SETTING_B_AN_TYPING           "editor.analyzer.variables.typing"
#define SETTING_B_AN_MISLEADINGTYPE   "editor.analyzer.variables.misleadingtype"
#define SETTING_B_AN_VARLENGTH        "editor.analyzer.variables.length"
#define SETTING_B_AN_UNUSEDVARS       "editor.analyzer.variables.unused"
#define SETTING_B_AN_GLOBALVARS       "editor.analyzer.variables.globals"
#define SETTING_B_AN_CONSTANTS        "editor.analyzer.runtime.constants"
#define SETTING_B_AN_INLINEIF         "editor.analyzer.runtime.inlineif"
#define SETTING_B_AN_PROCLENGTH       "editor.analyzer.runtime.procedurelength"
#define SETTING_B_AN_PROGRESS         "editor.analyzer.runtime.progress"
#define SETTING_B_AN_FALLTHROUGH      "editor.analyzer.switch.fallthrough"
#define SETTING_S_ST_START            "editor.style._"
#define SETTING_S_ST_STANDARD         "editor.style.standard.editor"
#define SETTING_S_ST_CONSOLESTD       "editor.style.standard.terminal"
#define SETTING_S_ST_COMMAND          "editor.style.command.default"
#define SETTING_S_ST_PROCCOMMAND      "editor.style.command.procedure"
#define SETTING_S_ST_COMMENT          "editor.style.comment"
#define SETTING_S_ST_DOCCOMMENT       "editor.style.documentation.comment"
#define SETTING_S_ST_DOCKEYWORD       "editor.style.documentation.keyword"
#define SETTING_S_ST_OPTION           "editor.style.option"
#define SETTING_S_ST_FUNCTION         "editor.style.function.builtin"
#define SETTING_S_ST_CUSTOMFUNC       "editor.style.function.custom"
#define SETTING_S_ST_CLUSTER          "editor.style.cluster"
#define SETTING_S_ST_CONSTANT         "editor.style.constant"
#define SETTING_S_ST_SPECIALVAL       "editor.style.specialval"
#define SETTING_S_ST_STRING           "editor.style.string.literals"
#define SETTING_S_ST_STRINGPARSER     "editor.style.string.parser"
#define SETTING_S_ST_INCLUDES         "editor.style.includes"
#define SETTING_S_ST_OPERATOR         "editor.style.operator"
#define SETTING_S_ST_PROCEDURE        "editor.style.procedure"
#define SETTING_S_ST_NUMBER           "editor.style.number"
#define SETTING_S_ST_METHODS          "editor.style.methods"
#define SETTING_S_ST_INSTALL          "editor.style.install"
#define SETTING_S_ST_DEFVARS          "editor.style.defaultvariables"
#define SETTING_S_ST_ACTIVELINE       "editor.style.activeline"
 
// Default color values
#define DEFAULT_ST_STANDARD      "0:0:0-255:255:255-0100"
#define DEFAULT_ST_CONSOLESTD    "0:0:100-255:255:255-0000"
#define DEFAULT_ST_COMMAND       "0:128:255-255:255:255-1011"
#define DEFAULT_ST_PROCCOMMAND   "128:0:0-255:255:255-1011"
#define DEFAULT_ST_COMMENT       "0:128:0-255:255:183-0000"
#define DEFAULT_ST_DOCCOMMENT    "0:128:192-255:255:183-1000"
#define DEFAULT_ST_DOCKEYWORD    "128:0:0-255:255:183-1000"
#define DEFAULT_ST_OPTION        "0:128:100-255:255:255-0001"
#define DEFAULT_ST_FUNCTION      "0:0:255-255:255:255-1001"
#define DEFAULT_ST_CUSTOMFUNC    "0:0:160-255:255:255-0001"
#define DEFAULT_ST_CLUSTER       "96:96:96-255:255:255-0001"
#define DEFAULT_ST_CONSTANT      "255:0:128-255:255:255-1001"
#define DEFAULT_ST_SPECIALVAL    "0:0:0-255:255:255-1001"
#define DEFAULT_ST_STRING        "128:128:255-255:255:255-0001"
#define DEFAULT_ST_STRINGPARSER  "0:128:192-255:255:255-1001"
#define DEFAULT_ST_INCLUDES      "128:0:0-255:255:255-1001"
#define DEFAULT_ST_OPERATOR      "255:0:0-255:255:255-0001"
#define DEFAULT_ST_PROCEDURE     "128:0:0-255:255:255-1001"
#define DEFAULT_ST_NUMBER        "176:150:0-255:255:255-0001"
#define DEFAULT_ST_METHODS       "0:180:50-255:255:255-1001"
#define DEFAULT_ST_INSTALL       "128:128:128-255:255:255-0001"
#define DEFAULT_ST_DEFVARS       "0:0:160-255:255:255-1101"
#define DEFAULT_ST_ACTIVELINE    "0:0:0-221:230:255-0000"
 
 
 
/*
 * Headerdatei zur Settings-Klasse
 */
 
 
 
 
class SettingsValue
{
    public:
        enum SettingsValueType
        {
            TYPELESS,
            BOOL,
            UINT,
            STRING
        };
 
        enum SettingsValueProperties
        {
            NONE = 0x0,
            SAVE = 0x1,
            HIDDEN = 0x2,
            PATH = 0x4,
            IMMUTABLE = 0x8,
            UIREFRESH = 0x10
        };
 
    private:
        void* m_value;
        SettingsValueType m_type;
        int m_valueProperties;
        size_t m_min;
        size_t m_max;
 
        void assign(bool value)
        {
            m_type = BOOL;
            m_value = static_cast<void*>(new bool);
            *(static_cast<bool*>(m_value)) = value;
        }
 
        void assign(size_t value)
        {
            m_type = UINT;
            m_value = static_cast<void*>(new size_t);
            *(static_cast<size_t*>(m_value)) = value;
        }
 
        void assign(const std::string& value)
        {
            m_type = STRING;
            m_value = static_cast<void*>(new std::string);
            *(static_cast<std::string*>(m_value)) = value;
        }
 
        void clear()
        {
            switch (m_type)
            {
                case BOOL:
                    delete (bool*)m_value;
                    break;
                case UINT:
                    delete (size_t*)m_value;
                    break;
                case STRING:
                    delete (std::string*)m_value;
                    break;
                case TYPELESS:
                    break;
            }
 
            m_type = TYPELESS;
            m_value = nullptr;
        }
 
    public:
        SettingsValue() : m_value(nullptr), m_type(TYPELESS), m_valueProperties(SettingsValue::NONE), m_min(0), m_max(0) {}
 
        explicit SettingsValue(bool value, int properties = SettingsValue::SAVE) : m_min(0), m_max(0)
        {
            m_valueProperties = properties;
            assign(value);
        }
 
        SettingsValue(size_t value, size_t _min, size_t _max, int properties = SettingsValue::SAVE)
        {
            m_valueProperties = properties;
            m_min = _min;
            m_max = _max;
            assign(value);
        }
 
        explicit SettingsValue(const char* value, int properties = SettingsValue::SAVE) : m_min(0), m_max(0)
        {
            m_valueProperties = properties;
            assign(std::string(value));
        }
 
        SettingsValue(const std::string& value, int properties = SettingsValue::SAVE) : m_min(0), m_max(0)
        {
            m_valueProperties = properties;
            assign(value);
        }
 
        ~SettingsValue()
        {
            clear();
        }
 
        SettingsValue(const SettingsValue& value)
        {
            m_valueProperties = value.m_valueProperties;
            m_min = value.m_min;
            m_max = value.m_max;
 
            switch (value.m_type)
            {
                case BOOL:
                    assign(*(bool*)value.m_value);
                    break;
                case UINT:
                    assign(*(size_t*)value.m_value);
                    break;
                case STRING:
                    assign(*(std::string*)value.m_value);
                    break;
                case TYPELESS:
                    break;
            }
        }
 
        SettingsValue& operator=(const SettingsValue& value)
        {
            clear();
            m_valueProperties = value.m_valueProperties;
            m_min = value.m_min;
            m_max = value.m_max;
 
            switch (value.m_type)
            {
                case BOOL:
                    assign(*(bool*)value.m_value);
                    break;
                case UINT:
                    assign(*(size_t*)value.m_value);
                    break;
                case STRING:
                    assign(*(std::string*)value.m_value);
                    break;
                case TYPELESS:
                    break;
            }
 
            return *this;
        }
 
        SettingsValueType getType() const
        {
            return m_type;
        }
 
        bool shallSave() const
        {
            return m_valueProperties & SAVE;
        }
 
        bool isHidden() const
        {
            return m_valueProperties & HIDDEN;
        }
 
        bool isPath() const
        {
#ifndef RELEASE
            assert(m_type == STRING);
#endif
            return m_valueProperties & PATH;
        }
 
        bool isMutable() const
        {
            return !(m_valueProperties & (IMMUTABLE | HIDDEN));
        }
 
        bool isUiModifying() const
        {
            return m_valueProperties & UIREFRESH;
        }
 
        size_t min() const
        {
#ifndef RELEASE
            assert(m_type == UINT);
#endif
            return m_min;
        }
 
        size_t max() const
        {
#ifndef RELEASE
            assert(m_type == UINT);
#endif
            return m_max;
        }
 
        bool& active()
        {
#ifndef RELEASE
            assert(m_type != TYPELESS);
            assert(m_value != nullptr);
            assert(m_type == BOOL);
#endif
            return *static_cast<bool*>(m_value);
        }
 
        size_t& value()
        {
#ifndef RELEASE
            assert(m_type != TYPELESS);
            assert(m_value != nullptr);
            assert(m_type == UINT);
#endif
            return *static_cast<size_t*>(m_value);
        }
 
        std::string& stringval()
        {
#ifndef RELEASE
            assert(m_type != TYPELESS);
            assert(m_value != nullptr);
            assert(m_type == STRING);
#endif
            return *static_cast<std::string*>(m_value);
        }
 
        bool active() const
        {
#ifndef RELEASE
            assert(m_type != TYPELESS);
            assert(m_value != nullptr);
            assert(m_type == BOOL);
#endif
            return *static_cast<bool*>(m_value);
        }
 
        size_t value() const
        {
#ifndef RELEASE
            assert(m_type != TYPELESS);
            assert(m_value != nullptr);
            assert(m_type == UINT);
#endif
            return *static_cast<size_t*>(m_value);
        }
 
        std::string stringval() const
        {
#ifndef RELEASE
            assert(m_type != TYPELESS);
            assert(m_value != nullptr);
            assert(m_type == STRING);
#endif
            return *static_cast<std::string*>(m_value);
        }
 
};
 
 
 
 
 
class Settings : public Documentation
{
    private:
        std::string sSettings_ini;
 
        // Imports of different configuration file versions
        void import_v1x(const std::string& sSettings);
        bool set(const std::string&);
 
        // Helper
        std::string replaceExePath(const std::string& _sPath);
        void prepareFilePaths(const std::string& _sExePath);
 
    protected:
        std::map<std::string, SettingsValue> m_settings;
 
    public:
        Settings();
        Settings(const Settings& _settings);
 
        void copySettings(const Settings& _settings);
 
        Settings& operator=(const Settings& _settings)
        {
            copySettings(_settings);
            return *this;
        }
 
        // loading and saving configuration files
        void save(const std::string& _sWhere, bool bMkBackUp = false);
        void load(const std::string& _sWhere);
 
        SettingsValue& getSetting(const std::string& value)
        {
            auto iter = m_settings.find(value);
 
            if (iter != m_settings.end())
                return iter->second;
 
            throw SyntaxError(SyntaxError::INVALID_SETTING, "", value);
        }
 
        const SettingsValue& getSetting(const std::string& value) const
        {
            auto iter = m_settings.find(value);
 
            if (iter != m_settings.end())
                return iter->second;
 
            throw SyntaxError(SyntaxError::INVALID_SETTING, "", value);
        }
 
        std::map<std::string, SettingsValue>& getSettings()
        {
            return m_settings;
        }
 
        const std::map<std::string, SettingsValue>& getSettings() const
        {
            return m_settings;
        }
 
        void enable(const std::string& option)
        {
            auto iter = m_settings.find(option);
 
            if (iter != m_settings.end() && iter->second.getType() == SettingsValue::BOOL)
                iter->second.active() = true;
        }
 
        void disable(const std::string& option)
        {
            auto iter = m_settings.find(option);
 
            if (iter != m_settings.end() && iter->second.getType() == SettingsValue::BOOL)
                iter->second.active() = false;
        }
 
        bool isEnabled(const std::string& option) const
        {
            auto iter = m_settings.find(option);
 
            if (iter != m_settings.end() && iter->second.getType() == SettingsValue::BOOL)
                return iter->second.active();
 
            return false;
        }
 
        inline void enableSystemPrints(bool _bSystemPrints = true)
        {
            m_settings[SETTING_B_SYSTEMPRINTS].active() = _bSystemPrints;
        }
 
        inline void setDefaultPlotFont(const std::string& plotFont)
        {
            std::string _sPlotFont = plotFont;
 
            if (_sPlotFont == "palatino")
                _sPlotFont = "pagella";
 
            if (_sPlotFont == "times")
                _sPlotFont = "termes";
 
            if (_sPlotFont == "bookman")
                _sPlotFont = "bonum";
 
            if (_sPlotFont == "avantgarde")
                _sPlotFont = "adventor";
 
            if (_sPlotFont == "chancery")
                _sPlotFont = "chorus";
 
            if (_sPlotFont == "courier")
                _sPlotFont = "cursor";
 
            if (_sPlotFont == "helvetica")
                _sPlotFont = "heros";
 
            if (_sPlotFont == "pagella"
                    || _sPlotFont == "adventor"
                    || _sPlotFont == "bonum"
                    || _sPlotFont == "chorus"
                    || _sPlotFont == "cursor"
                    || _sPlotFont == "heros"
                    || _sPlotFont == "heroscn"
                    || _sPlotFont == "schola"
                    || _sPlotFont == "termes"
                )
            {
                m_settings[SETTING_S_PLOTFONT].stringval() = _sPlotFont;
            }
        }
 
        // Getter wrappers
        //
        inline bool isDeveloperMode() const
            {return m_settings.at(SETTING_B_DEVELOPERMODE).active();}
 
        inline bool isDraftMode() const
            {return m_settings.at(SETTING_B_DRAFTMODE).active();}
 
        inline bool createCompactTables() const
            {return m_settings.at(SETTING_B_COMPACT).active();}
 
        inline bool showGreeting() const
            {return m_settings.at(SETTING_B_GREETING).active();}
 
        inline bool showHints() const
            {return m_settings.at(SETTING_B_SHOWHINTS).active();}
 
        inline bool useEscInScripts() const
            {return m_settings.at(SETTING_B_USEESCINSCRIPTS).active();}
 
        inline bool controlDefinitions() const
            {return m_settings.at(SETTING_B_DEFCONTROL).active();}
 
        inline bool showExtendedFileInfo() const
            {return m_settings.at(SETTING_B_EXTENDEDFILEINFO).active();}
 
        inline bool useLogFile() const
            {return m_settings.at(SETTING_B_LOGFILE).active();}
 
        inline bool loadEmptyCols() const
            {return m_settings.at(SETTING_B_LOADEMPTYCOLS).active();}
 
        inline size_t getPrecision() const
            {return m_settings.at(SETTING_V_PRECISION).value();}
 
        inline std::string getExePath() const
            {return m_settings.at(SETTING_S_EXEPATH).stringval();}
 
        inline std::string getWorkPath() const
            {return m_settings.at(SETTING_S_WORKPATH).stringval();}
 
        inline std::string getSavePath() const
            {return m_settings.at(SETTING_S_SAVEPATH).stringval();}
 
        inline std::string getLoadPath() const
            {return m_settings.at(SETTING_S_LOADPATH).stringval();}
 
        inline std::string getPlotPath() const
            {return m_settings.at(SETTING_S_PLOTPATH).stringval();}
 
        inline std::string getScriptPath() const
            {return m_settings.at(SETTING_S_SCRIPTPATH).stringval();}
 
        inline std::string getProcPath() const
            {return m_settings.at(SETTING_S_PROCPATH).stringval();}
 
        inline size_t getAutoSaveInterval() const
            {return m_settings.at(SETTING_V_AUTOSAVE).value();}
 
        inline size_t getBuffer() const
            {return m_settings.at(SETTING_V_BUFFERSIZE).value();}
 
        inline size_t getWindow(int nWindow = 0) const
            {return nWindow ? m_settings.at(SETTING_V_WINDOW_Y).value()-1 : m_settings.at(SETTING_V_WINDOW_X).value()-1;}
 
        inline std::string getDefaultPlotFont() const
            {return m_settings.at(SETTING_S_PLOTFONT).stringval();}
 
        inline std::string getTokenPaths() const
        {
            return "<>="+m_settings.at(SETTING_S_EXEPATH).stringval()
                +";<wp>="+m_settings.at(SETTING_S_WORKPATH).stringval()
                +";<savepath>="+m_settings.at(SETTING_S_SAVEPATH).stringval()
                +";<loadpath>="+m_settings.at(SETTING_S_LOADPATH).stringval()
                +";<plotpath>="+m_settings.at(SETTING_S_PLOTPATH).stringval()
                +";<scriptpath>="+m_settings.at(SETTING_S_SCRIPTPATH).stringval()
                +";<procpath>="+m_settings.at(SETTING_S_PROCPATH).stringval()+";";
        }
 
        inline bool systemPrints() const
            {return m_settings.at(SETTING_B_SYSTEMPRINTS).active();}
 
        inline bool useDebugger() const
            {return m_settings.at(SETTING_B_DEBUGGER).active();}
 
        inline bool useCustomLangFiles() const
            {return m_settings.at(SETTING_B_USECUSTOMLANG).active();}
 
        inline bool useExternalDocWindow() const
            {return m_settings.at(SETTING_B_EXTERNALDOCWINDOW).active();}
 
        inline bool executeEnabled() const
            {return m_settings.at(SETTING_B_ENABLEEXECUTE).active();}
 
        inline bool useMaskDefault() const
            {return m_settings.at(SETTING_B_MASKDEFAULT).active();}
 
        inline bool decodeArguments() const
            {return m_settings.at(SETTING_B_DECODEARGUMENTS).active();}
 
};
 
 
#endif