theme.hpp

Go to the documentation of this file.

/*
    Copyright 2019-2020 natinusala
    Copyright 2019 p-sam
    Copyright 2026 JigSawFr
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
        http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/
 
#pragma once
 
#include <nanovg.h>
 
#include <cstdint>
#include <ctime>
#include <initializer_list>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace aurore
{
 
enum class ThemeVariant
{
    LIGHT,
    DARK
};
 
class ThemeValues
{
  public:
    ThemeValues(std::initializer_list<std::pair<std::string, NVGcolor>> list);
 
    void addColor(const std::string&, NVGcolor color);
    NVGcolor getColor(const std::string&);
    bool hasColor(const std::string&) const;
 
    void setOverlay(const std::unordered_map<std::string, NVGcolor>& overlay);
 
    const std::unordered_map<std::string, NVGcolor>& getColors() const { return this->values; }
    const std::unordered_map<std::string, NVGcolor>& getBaseColors() const { return this->base; }
 
  private:
    std::unordered_map<std::string, NVGcolor> base;
    std::unordered_map<std::string, NVGcolor> overlay;
    std::unordered_map<std::string, NVGcolor> values; 
};
 
enum class BackgroundFit
{
    COVER, 
    CONTAIN, 
    TILE, 
    CENTER, 
};
 
struct ThemeBackground
{
    static constexpr float DEFAULT_DIM = 0.35f;
 
    std::string image;
    BackgroundFit fit = BackgroundFit::COVER;
    float dim = DEFAULT_DIM;
    float surfaceOpacity = 1.0f;
 
    bool hasImage() const { return !this->image.empty(); }
};
 
struct ThemeIcon
{
    std::string image; 
    bool tint = false;
 
    bool operator==(const ThemeIcon&) const = default;
};
 
struct ThemePictures
{
    std::string logo; 
    std::string preview; 
    std::map<std::string, ThemeIcon> icons; 
    std::map<std::string, std::string> images; 
 
    bool empty() const { return this->logo.empty() && this->preview.empty() && this->icons.empty() && this->images.empty(); }
    bool operator==(const ThemePictures&) const = default;
};
 
struct ThemeImage;
 
// ---------------------------------------------------------------------------
// Decorations (docs/themes.md, Decorations): pictures over the surfaces of
// a few areas, strips along the screen's edges, particles
// ---------------------------------------------------------------------------
 
enum class ThemeArea
{
    NONE,
    HEADER, 
    SIDEBAR, 
    DIALOG, 
    TOP, 
    BOTTOM, 
};
constexpr int THEME_AREA_COUNT = 5; 
 
struct ThemePicture
{
    std::string image; 
    BackgroundFit fit = BackgroundFit::COVER;
    float opacity     = 1.0f; 
    float height = 0.0f;
 
    bool hasImage() const { return !this->image.empty(); }
};
 
enum class ParticleKind
{
    NONE,
    SNOW,
    LEAVES,
    PETALS,
    EMBERS,
    CONFETTI,
    SPARKLES,
    HEARTS,
    BUBBLES,
};
 
enum class ParticleLayer
{
    BACK,
    FRONT,
};
 
struct ThemeParticles
{
    static constexpr float LOW = 0.3f, MEDIUM = 0.6f, HIGH = 1.0f;
    static constexpr int MAX_COLORS = 5;
 
    ParticleKind kind   = ParticleKind::NONE;
    float density       = LOW; 
    float speed         = 1.0f; 
    ParticleLayer layer = ParticleLayer::BACK;
    std::vector<NVGcolor> colors;
 
    bool enabled() const { return this->kind != ParticleKind::NONE && this->density > 0.0f; }
};
 
struct ThemeDecor
{
    ThemePicture pictures[THEME_AREA_COUNT]; 
    ThemeParticles particles;
 
    const ThemePicture& picture(ThemeArea area) const { return this->pictures[(int)area - 1]; }
    bool hasPictures() const
    {
        for (const ThemePicture& picture : this->pictures)
            if (picture.hasImage())
                return true;
        return false;
    }
};
 
struct ThemeInfo
{
    std::string path; 
    std::string id; 
    std::string name; 
    std::string author; 
    std::string version; 
    std::string description; 
    std::string backgroundImage;
    std::string icon;
 
    std::string counterpart;
 
    bool light = false;
    bool dark  = false;
 
    struct Preview
    {
        NVGcolor background;
        NVGcolor surface;
        NVGcolor text;
        NVGcolor accent;
        NVGcolor highlight;
    };
    Preview lightPreview {};
    Preview darkPreview {};
 
    ThemeBackground lightBackground;
    ThemeBackground darkBackground;
    const ThemeBackground& background(ThemeVariant variant) const
    {
        return variant == ThemeVariant::LIGHT ? this->lightBackground : this->darkBackground;
    }
 
    ThemePictures lightPictures;
    ThemePictures darkPictures;
    const ThemePictures& pictures(ThemeVariant variant) const
    {
        return variant == ThemeVariant::LIGHT ? this->lightPictures : this->darkPictures;
    }
 
    ThemeDecor lightDecor;
    ThemeDecor darkDecor;
    const ThemeDecor& decor(ThemeVariant variant) const
    {
        return variant == ThemeVariant::LIGHT ? this->lightDecor : this->darkDecor;
    }
 
    std::vector<std::string> errors;
    std::vector<std::string> warnings;
 
    bool ok() const { return this->errors.empty(); }
    ThemeVariant variant() const { return this->light && !this->dark ? ThemeVariant::LIGHT : ThemeVariant::DARK; }
    bool styles(ThemeVariant variant) const { return variant == ThemeVariant::LIGHT ? this->light : this->dark; }
};
 
class Theme
{
  public:
    Theme(ThemeValues* values);
    NVGcolor operator[](const std::string& name);
 
    void addColor(const std::string&, NVGcolor color);
    NVGcolor getColor(const std::string& name);
    bool hasColor(const std::string& name);
    ThemeValues* getValues() { return this->values; }
 
    static Theme& getLightTheme();
    static Theme& getDarkTheme();
    static Theme& get(ThemeVariant variant);
 
    static bool loadFile(const std::string& path, ThemeVariant* variant = nullptr);
 
    static bool load(const std::string& text, ThemeVariant* variant = nullptr, const std::string& directory = "");
 
    static void reset();
 
    static void followCalendar();
 
    static std::string seasonalTheme(std::time_t when);
 
    static const std::string& getCurrentPath();
 
    static bool styles(ThemeVariant variant);
 
    static std::string getBackgroundImage();
 
    static ThemeBackground getBackground(ThemeVariant variant);
 
    static ThemeDecor getDecor(ThemeVariant variant);
 
    static bool resolveAsset(const std::string& name, const std::string& directory, const std::string& root,
        std::string* path, std::string* error);
 
    static bool recheckAsset(const std::string& path, std::string* error = nullptr);
 
    static ThemePictures getPictures(ThemeVariant variant);
 
    static void addIconNames(const std::vector<std::string>& names);
 
    static void addImageSlot(const std::string& key, const std::string& fallback = "", int maxSide = 0);
 
    static std::vector<std::string> getImageSlots();
 
    static std::shared_ptr<ThemeImage> image(const std::string& key);
 
    static std::shared_ptr<ThemeImage> logo();
 
    static std::shared_ptr<ThemeImage> icon(const std::string& name, bool* tint = nullptr);
 
    static void addSurfaceKey(const std::string& key);
 
    static ThemeInfo inspect(const std::string& path, bool decodePictures = false);
 
    static std::vector<ThemeInfo> listThemes(const std::string& directory, bool decodePictures = false);
 
    static std::vector<ThemeInfo> builtinThemes();
 
    static bool parseColor(const std::string& text, NVGcolor* color);
 
    static float contrast(NVGcolor a, NVGcolor b);
 
    static void addContrastCheck(const std::string& ink, const std::string& surface, float minimum = 4.5f);
 
    static std::vector<std::string> checkContrast(ThemeVariant variant);
 
    static std::vector<std::string> checkBackgroundContrast(ThemeVariant variant);
 
    static uint64_t getGeneration();
 
  private:
    ThemeValues* values;
};
 
} // namespace aurore