Merge branch 'master' of https://github.com/minetest/minetest

[dragonfireclient.git] / src / gui / StyleSpec.h

diff --git a/src/gui/StyleSpec.h b/src/gui/StyleSpec.h
index 3e842e82636ccd15f66b347f4757a4a954c1b218..f2844ce2839411cfcdbe3b63d1dce03c579ddcd3 100644 (file)
--- a/src/gui/StyleSpec.h
+++ b/src/gui/StyleSpec.h
@@ -18,10 +18,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 */
 
 #include "client/tile.h" // ITextureSource
+#include "client/fontengine.h"
 #include "debug.h"
 #include "irrlichttypes_extrabloated.h"
 #include "util/string.h"
+#include <algorithm>
 #include <array>
+#include <vector>
 
 #pragma once
 
@@ -46,6 +49,12 @@ class StyleSpec
                ALPHA,
                CONTENT_OFFSET,
                PADDING,
+               FONT,
+               FONT_SIZE,
+               COLORS,
+               BORDERCOLORS,
+               BORDERWIDTHS,
+               SOUND,
                NUM_PROPERTIES,
                NONE
        };
@@ -98,6 +107,18 @@ class StyleSpec
                        return CONTENT_OFFSET;
                } else if (name == "padding") {
                        return PADDING;
+               } else if (name == "font") {
+                       return FONT;
+               } else if (name == "font_size") {
+                       return FONT_SIZE;
+               } else if (name == "colors") {
+                       return COLORS;
+               } else if (name == "bordercolors") {
+                       return BORDERCOLORS;
+               } else if (name == "borderwidths") {
+                       return BORDERWIDTHS;
+               } else if (name == "sound") {
+                       return SOUND;
                } else {
                        return NONE;
                }
@@ -179,6 +200,42 @@ class StyleSpec
                return color;
        }
 
+       std::array<video::SColor, 4> getColorArray(Property prop,
+               std::array<video::SColor, 4> def) const
+       {
+               const auto &val = properties[prop];
+               if (val.empty())
+                       return def;
+
+               std::vector<std::string> strs;
+               if (!parseArray(val, strs))
+                       return def;
+
+               for (size_t i = 0; i <= 3; i++) {
+                       video::SColor color;
+                       if (parseColorString(strs[i], color, false, 0xff))
+                               def[i] = color;
+               }
+
+               return def;
+       }
+
+       std::array<s32, 4> getIntArray(Property prop, std::array<s32, 4> def) const
+       {
+               const auto &val = properties[prop];
+               if (val.empty())
+                       return def;
+
+               std::vector<std::string> strs;
+               if (!parseArray(val, strs))
+                       return def;
+
+               for (size_t i = 0; i <= 3; i++)
+                       def[i] = stoi(strs[i]);
+
+               return def;
+       }
+
        irr::core::rect<s32> getRect(Property prop, irr::core::rect<s32> def) const
        {
                const auto &val = properties[prop];
@@ -225,6 +282,47 @@ class StyleSpec
                return vec;
        }
 
+       gui::IGUIFont *getFont() const
+       {
+               FontSpec spec(FONT_SIZE_UNSPECIFIED, FM_Standard, false, false);
+
+               const std::string &font = properties[FONT];
+               const std::string &size = properties[FONT_SIZE];
+
+               if (font.empty() && size.empty())
+                       return nullptr;
+
+               std::vector<std::string> modes = split(font, ',');
+
+               for (size_t i = 0; i < modes.size(); i++) {
+                       if (modes[i] == "normal")
+                               spec.mode = FM_Standard;
+                       else if (modes[i] == "mono")
+                               spec.mode = FM_Mono;
+                       else if (modes[i] == "bold")
+                               spec.bold = true;
+                       else if (modes[i] == "italic")
+                               spec.italic = true;
+               }
+
+               if (!size.empty()) {
+                       int calc_size = 1;
+
+                       if (size[0] == '*') {
+                               std::string new_size = size.substr(1); // Remove '*' (invalid for stof)
+                               calc_size = stof(new_size) * g_fontengine->getFontSize(spec.mode);
+                       } else if (size[0] == '+' || size[0] == '-') {
+                               calc_size = stoi(size) + g_fontengine->getFontSize(spec.mode);
+                       } else {
+                               calc_size = stoi(size);
+                       }
+
+                       spec.size = (unsigned)std::min(std::max(calc_size, 1), 999);
+               }
+
+               return g_fontengine->getFont(spec);
+       }
+
        video::ITexture *getTexture(Property prop, ISimpleTextureSource *tsrc,
                        video::ITexture *def) const
        {
@@ -285,6 +383,24 @@ class StyleSpec
        }
 
 private:
+       bool parseArray(const std::string &value, std::vector<std::string> &arr) const
+       {
+               std::vector<std::string> strs = split(value, ',');
+
+               if (strs.size() == 1) {
+                       arr = {strs[0], strs[0], strs[0], strs[0]};
+               } else if (strs.size() == 2) {
+                       arr = {strs[0], strs[1], strs[0], strs[1]};
+               } else if (strs.size() == 4) {
+                       arr = strs;
+               } else {
+                       warningstream << "Invalid array size (" << strs.size()
+                                       << " arguments): \"" << value << "\"" << std::endl;
+                       return false;
+               }
+               return true;
+       }
+
        bool parseRect(const std::string &value, irr::core::rect<s32> *parsed_rect) const
        {
                irr::core::rect<s32> rect;