ApplicationOptions.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/String.h>
#include <NDEVR/GenericOption.h>
#include <NDEVR/INIFactory.h>
#include <NDEVR/Dictionary.h>
namespace NDEVR
{
    class INIFactory;
    class INIOption;
    class ResourceListener;
 
    /**--------------------------------------------------------------------------------------------------
    Class: ApplicationOptionBase
 
    \brief The core of the default object to store data of any type that should persist through sessions 
    of the application. Developers should use ApplicationOption.
 
    Stores data of any type that can easily be saved or retrieved at runtime. Option belongs to a
    specific group for easy sorting and can be used to automatically generate widgets.
    *-----------------------------------------------------------------------------------------------**/
    class ApplicationOptionBase
    {
    public:
        virtual ~ApplicationOptionBase() {};
        virtual String toString() const = 0;
        virtual void fromString(const String&) = 0;
        virtual bool isDefault() const = 0;
        virtual void setToDefaultValue() = 0;
        virtual INIOption* iniOption() = 0;
    };
    /**--------------------------------------------------------------------------------------------------
    Class: ApplicationOptions
 
    \brief The container for storing N-number of ApplicationOption for the program. Almost all options are 
    typically "user options" and are added to that container by default.
 
    Stores data of any type that can easily be saved or retrieved at runtime. Option belongs to a
    specific group for easy sorting and can be used to automatically generate widgets.
    *-----------------------------------------------------------------------------------------------**/
    class NDEVR_BASE_API ApplicationOptions
    {
    public:
        ApplicationOptions();
        void addOption(const TranslatedString& name, ApplicationOptionBase* value)
        {
            addOption(TranslatedString(), name, value);
        }
        void addOption(const TranslatedString& group_name, const TranslatedString& name, ApplicationOptionBase* value)
        {
            lib_assert(!m_options[group_name].hasKey(name), "Duplicate entry");
            m_options[group_name][name] = value;
        }
        const ApplicationOptionBase* getOption(const TranslatedString& group,const TranslatedString& name) const
        {
            return m_options[group][name];
        }
        const ApplicationOptionBase* getOption(const TranslatedString& name) const
        {
            return getOption(TranslatedString(), name);
        }
        void addToINI(INIFactory& factory);
        void addToINI(const TranslatedString& group_name, INIFactory& factory);
        void setToDefaults();
        void setToDefaults(const TranslatedString& group_name);
        void logOptions(ProgressInfo* log, bool log_only_non_defaults);
        static ApplicationOptions& UserOptions();
    protected:
        Dictionary<TranslatedString, Dictionary<TranslatedString, ApplicationOptionBase*>> m_options;
    };
 
    /**--------------------------------------------------------------------------------------------------
    Class: ApplicationOption
 
    \brief The default object to store data of any type that should persist through sessions of the 
    application.
 
    Stores data of any type that can easily be saved or retrieved at runtime. Option belongs to a 
    specific group for easy sorting and can be used to automatically generate widgets.
    *-----------------------------------------------------------------------------------------------**/
    template<class t_type>
    class ApplicationOption : public ApplicationOptionBase
    {
    public:
        ApplicationOption(const TranslatedString& group, const TranslatedString& label, const t_type& value, ApplicationOptions& options = ApplicationOptions::UserOptions())
            : m_group(group)
            , m_label(label)
            , m_value(value)
            , m_options(options)
            , m_default_value(value)
        {
            m_options.addOption(group, label, this);
        }
        ApplicationOption(const TranslatedString& label, const t_type& value, ApplicationOptions& options = ApplicationOptions::UserOptions())
            : m_label(label)
            , m_value(value)
            , m_options(options)
            , m_default_value(value)
        {
            m_options.addOption(label, this);
        }
        t_type get() const
        {
            return m_value.get();// m_options.getValue<t_type>(m_group, m_label);
        }
        Resource<t_type>& getResource()
        {
            return m_value;
        }
        void set(const t_type& value, bool make_default = false)
        {
            if (make_default)
                m_default_value = value;
            return m_value.set(value);
        }
        void setDefaultValue(const t_type& value)
        {
            m_default_value = value;
        }
        void addListener(ResourceListener* listener, bool silent_add = false)
        {
            m_value.addListener(listener, silent_add);
        }
        virtual String toString() const override
        {
            return String(m_value.get());
        }
        virtual void fromString(const String& value) override
        {
            m_value.set(value.getAs<t_type>());
        }
        virtual bool isDefault() const override
        {
            return m_value.get() == m_default_value;
        }
        virtual void setToDefaultValue() override
        {
            m_value.set(m_default_value);
        }
        virtual INIOption* iniOption() override
        {
            return INIFactory::ToOption(m_value);
        }
        const TranslatedString& label() const
        {
            return m_label;
        }
        const TranslatedString& group() const
        {
            return m_group;
        }
    protected:
        const TranslatedString m_group;
        const TranslatedString m_label;
        Resource<t_type> m_value;
        ApplicationOptions& m_options;
        t_type m_default_value;
    };
 
    /*template<class t_type>
    class ApplicationUserSetting
    {
    public:
        ApplicationUserSetting(const TranslatedString& label, const t_type& value)
            : ApplicationOption(_t("User Options"), label, value)
        {}
    };*/
}