StyleOptions.h

/*
  Copyright (C) 2016-2026 Laurentiu-Gheorghe Crisan
  Copyright (C) 2016-2026 Marc Boris Duerner
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  As a special exception, you may use this file as part of a free
  software library without restriction. Specifically, if other files
  instantiate templates or use macros or inline functions from this
  file, or you compile this file and link it with other files to
  produce an executable, this file does not by itself cause the
  resulting executable to be covered by the GNU General Public
  License. This exception does not however invalidate any other
  reasons why the executable file might be covered by the GNU Library
  General Public License.
 
  This library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the:
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  Boston, MA 02110-1301 USA
*/
 
#ifndef Pt_Forms_StyleOptions_h
#define Pt_Forms_StyleOptions_h
 
#include <Pt/Forms/Api.h>
#include <Pt/Gfx/Pen.h>
#include <Pt/Gfx/Brush.h>
#include <Pt/Gfx/Font.h>
#include <Pt/Gfx/Color.h>
#include <Pt/SmartPtr.h>
 
#include <cstddef>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <vector>
 
namespace Pt {
 
namespace Forms {
 
class StyleOptions;

class PT_FORMS_API StyleOption
{
    public:
        virtual ~StyleOption();

        virtual StyleOption* clone() const = 0;

        virtual const std::type_info& typeId() const = 0;

        virtual const char* name() const = 0;

        virtual void bind(const StyleOptions* /*inherited*/)
        {}
};

class BackgroundOption : public StyleOption
{
    public:
        explicit BackgroundOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit BackgroundOption(const Gfx::Brush& brush)
        : _value(brush)
        {}
 
        const Gfx::Brush& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new BackgroundOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(BackgroundOption); }
 
        virtual const char* name() const override
        { return "background"; }
 
    private:
        Gfx::Brush _value;
};

class ForegroundOption : public StyleOption
{
    public:
        explicit ForegroundOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit ForegroundOption(const Gfx::Brush& brush)
        : _value(brush)
        {}
 
        const Gfx::Brush& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new ForegroundOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(ForegroundOption); }
 
        virtual const char* name() const override
        { return "foreground"; }
 
    private:
        Gfx::Brush _value;
};

class ContourOption : public StyleOption
{
    public:
        explicit ContourOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit ContourOption(const Gfx::Pen& pen)
        : _value(pen)
        {}
 
        const Gfx::Pen& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new ContourOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(ContourOption); }
 
        virtual const char* name() const override
        { return "contour"; }
 
    private:
        Gfx::Pen _value;
};

class AccentColorOption : public StyleOption
{
    public:
        explicit AccentColorOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        const Gfx::Color& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new AccentColorOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(AccentColorOption); }
 
        virtual const char* name() const override
        { return "accentColor"; }
 
    private:
        Gfx::Color _value;
};

class ViewBackgroundOption : public StyleOption
{
    public:
        explicit ViewBackgroundOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit ViewBackgroundOption(const Gfx::Brush& brush)
        : _value(brush)
        {}
 
        const Gfx::Brush& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new ViewBackgroundOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(ViewBackgroundOption); }
 
        virtual const char* name() const override
        { return "viewBackground"; }
 
    private:
        Gfx::Brush _value;
};

class HighlightColorOption : public StyleOption
{
    public:
        explicit HighlightColorOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        const Gfx::Color& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new HighlightColorOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(HighlightColorOption); }
 
        virtual const char* name() const override
        { return "highlightColor"; }
 
    private:
        Gfx::Color _value;
};

class HoverBackgroundOption : public StyleOption
{
    public:
        explicit HoverBackgroundOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit HoverBackgroundOption(const Gfx::Brush& brush)
        : _value(brush)
        {}
 
        const Gfx::Brush& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new HoverBackgroundOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(HoverBackgroundOption); }
 
        virtual const char* name() const override
        { return "hoverBackground"; }
 
    private:
        Gfx::Brush _value;
};

class TextBackgroundOption : public StyleOption
{
    public:
        explicit TextBackgroundOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit TextBackgroundOption(const Gfx::Brush& brush)
        : _value(brush)
        {}
 
        const Gfx::Brush& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new TextBackgroundOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(TextBackgroundOption); }
 
        virtual const char* name() const override
        { return "textBackground"; }
 
    private:
        Gfx::Brush _value;
};

class TextColorOption : public StyleOption
{
    public:
        explicit TextColorOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        const Gfx::Color& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new TextColorOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(TextColorOption); }
 
        virtual const char* name() const override
        { return "textColor"; }
 
    private:
        Gfx::Color _value;
};

class PlaceholderTextColorOption : public StyleOption
{
    public:
        explicit PlaceholderTextColorOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        const Gfx::Color& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new PlaceholderTextColorOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(PlaceholderTextColorOption); }
 
        virtual const char* name() const override
        { return "placeholderTextColor"; }
 
    private:
        Gfx::Color _value;
};

class HighlightedTextColorOption : public StyleOption
{
    public:
        explicit HighlightedTextColorOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        const Gfx::Color& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new HighlightedTextColorOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(HighlightedTextColorOption); }
 
        virtual const char* name() const override
        { return "highlightedTextColor"; }
 
    private:
        Gfx::Color _value;
};

class AlternateViewBackgroundOption : public StyleOption
{
    public:
        explicit AlternateViewBackgroundOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit AlternateViewBackgroundOption(const Gfx::Brush& brush)
        : _value(brush)
        {}
 
        const Gfx::Brush& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new AlternateViewBackgroundOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(AlternateViewBackgroundOption); }
 
        virtual const char* name() const override
        { return "alternateViewBackground"; }
 
    private:
        Gfx::Brush _value;
};

class PopupBackgroundOption : public StyleOption
{
    public:
        explicit PopupBackgroundOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        explicit PopupBackgroundOption(const Gfx::Brush& brush)
        : _value(brush)
        {}
 
        const Gfx::Brush& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new PopupBackgroundOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(PopupBackgroundOption); }
 
        virtual const char* name() const override
        { return "popupBackground"; }
 
    private:
        Gfx::Brush _value;
};

class PopupTextColorOption : public StyleOption
{
    public:
        explicit PopupTextColorOption(const Gfx::Color& color)
        : _value(color)
        {}
 
        const Gfx::Color& value() const
        { return _value; }
 
        virtual StyleOption* clone() const
        { return new PopupTextColorOption(*this); }
 
        virtual const std::type_info& typeId() const
        { return typeid(PopupTextColorOption); }
 
        virtual const char* name() const override
        { return "popupTextColor"; }
 
    private:
        Gfx::Color _value;
};

class PT_FORMS_API FontOption : public StyleOption
{
    public:
        FontOption();

        FontOption(const FontOption& o);

        FontOption& operator=(const FontOption& o);

        virtual StyleOption* clone() const;

        virtual const std::type_info& typeId() const;

        virtual const char* name() const override
        { return "font"; }

        bool isSet() const;

        const Gfx::Font& value() const;

        void setFont(const Gfx::Font& font);

        void setSize(std::size_t size);

        void setWeight(Gfx::Font::Weight weight);

        void setSlant(Gfx::Font::Slant slant);

        virtual void bind(const StyleOptions* inherited);

        Gfx::Font getFont(const Gfx::Font& baseFont) const;
 
    private:
        enum Override
        {
            All    = 0x1,
            Size   = 0x2,
            Weight = 0x4,
            Slant  = 0x8
        };
 
    private:
        AutoPtr<Gfx::Font>    _font;
        std::size_t           _size;
        Gfx::Font::Weight     _weight;
        Gfx::Font::Slant      _slant;
        Gfx::Font             _resolvedFont;
        unsigned              _overrides;
};

class PT_FORMS_API StyleOptions
{
    public:
        static const std::size_t InvalidGeneration = 0;
 
    public:
        StyleOptions();

        StyleOptions(const StyleOptions& o);

        ~StyleOptions();

        StyleOptions& operator=(const StyleOptions& o);

        static StyleOptions defaults();

        std::size_t generation() const;

        bool hasOptions() const;

        bool isDefault(const StyleOptions& base) const;

        void bind(const StyleOptions* inherited);

        const StyleOptions* parent() const;

        template <typename T>
        const T* findLocal() const;

        template <typename T>
        const T* find() const;

        template <typename T>
        const T& get() const;

        template <typename T>
        void set(const T& option);

        template <typename T>
        void reset();
 
    private:
        bool hasLocalOptions() const;
 
        StyleOption* findOption(const std::type_info& ti) const;
 
        void replaceOption(StyleOption* option);
 
        void removeOption(const std::type_info& ti);
 
        void clearOptions();
 
    private:
        std::size_t               _generation;
        std::size_t               _boundGeneration;
        const StyleOptions*       _parent;
        std::vector<StyleOption*> _options;
};
 
 
template <typename T>
const T* StyleOptions::findLocal() const
{
    return static_cast<const T*>( findOption(typeid(T)) );
}
 
 
template <typename T>
const T* StyleOptions::find() const
{
    const T* option = findLocal<T>();
    if(option)
        return option;
 
    if( _parent )
        return _parent->find<T>();
 
    return 0;
}
 
 
template <typename T>
const T& StyleOptions::get() const
{
    const T* option = find<T>();
    if(option)
        return *option;
 
    throw std::logic_error("invalid style option");
}
 
 
template <typename T>
void StyleOptions::set(const T& option)
{
    StyleOption* localOption = option.clone();
    localOption->bind(_parent);
    replaceOption(localOption);
}
 
 
template <typename T>
void StyleOptions::reset()
{
    removeOption(typeid(T));
}
 
} // namespace
 
} // namespace
 
#endif