xbmc/addons/Skin.h

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #pragma once
  10
  11 #include "addons/Addon.h"
  12 #include "addons/gui/skin/SkinTimerManager.h"
  13 #include "guilib/GUIIncludes.h" // needed for the GUIInclude member
  14 #include "windowing/GraphicContext.h" // needed for the RESOLUTION members
  15
  16 #include <map>
  17 #include <memory>
  18 #include <set>
  19 #include <utility>
  20 #include <vector>
  21
  22 #define CREDIT_LINE_LENGTH 50
  23
  24 class CSetting;
  25 struct IntegerSettingOption;
  26 struct StringSettingOption;
  27
  28 namespace ADDON
  29 {
  30
  31 class CSkinSettingUpdateHandler;
  32
  33 class CSkinSetting
  34 {
  35 public:
  36   virtual ~CSkinSetting() = default;
  37
  38   bool Serialize(TiXmlElement* parent) const;
  39
  40   virtual std::string GetType() const = 0;
  41
  42   virtual bool Deserialize(const TiXmlElement* element);
  43
  44   std::string name;
  45
  46 protected:
  47   virtual bool SerializeSetting(TiXmlElement* element) const = 0;
  48 };
  49
  50 typedef std::shared_ptr<CSkinSetting> CSkinSettingPtr;
  51
  52 class CSkinSettingString : public CSkinSetting
  53 {
  54 public:
  55   ~CSkinSettingString() override = default;
  56
  57   std::string GetType() const override { return "string"; }
  58
  59   bool Deserialize(const TiXmlElement* element) override;
  60
  61   std::string value;
  62
  63 protected:
  64   bool SerializeSetting(TiXmlElement* element) const override;
  65 };
  66
  67 typedef std::shared_ptr<CSkinSettingString> CSkinSettingStringPtr;
  68
  69 class CSkinSettingBool : public CSkinSetting
  70 {
  71 public:
  72   ~CSkinSettingBool() override = default;
  73
  74   std::string GetType() const override { return "bool"; }
  75
  76   bool Deserialize(const TiXmlElement* element) override;
  77
  78   bool value = false;
  79
  80 protected:
  81   bool SerializeSetting(TiXmlElement* element) const override;
  82 };
  83
  84 typedef std::shared_ptr<CSkinSettingBool> CSkinSettingBoolPtr;
  85
  86 class CSkinInfo : public CAddon
  87 {
  88 public:
  89   class CStartupWindow
  90   {
  91   public:
  92     CStartupWindow(int id, const char *name):
  93         m_id(id), m_name(name)
  94     {
  95     };
  96     int m_id;
  97     std::string m_name;
  98   };
  99
 100   explicit CSkinInfo(const AddonInfoPtr& addonInfo);
 101   //FIXME: CAddonCallbacksGUI/WindowXML hack
 102   explicit CSkinInfo(
 103       const AddonInfoPtr& addonInfo,
 104       const RESOLUTION_INFO& resolution);
 105
 106   CSkinInfo(
 107       const AddonInfoPtr& addonInfo,
 108       const RESOLUTION_INFO& resolution,
 109       const std::vector<RESOLUTION_INFO>& resolutions,
 110       float effectsSlowDown,
 111       bool debugging);
 112
 113   ~CSkinInfo() override;
 114
 115   /*! \brief Load resolution information from directories in Path().
 116    */
 117   void Start();
 118
 119   bool HasSkinFile(const std::string &strFile) const;
 120
 121   /*! \brief Get the full path to the specified file in the skin
 122    We search for XML files in the skin folder that best matches the current resolution.
 123    \param file XML file to look for
 124    \param res [out] If non-NULL, the resolution that the returned XML file is in is returned.  Defaults to NULL.
 125    \param baseDir [in] If non-empty, the given directory is searched instead of the skin's directory.  Defaults to empty.
 126    \return path to the XML file
 127    */
 128   std::string GetSkinPath(const std::string& file,
 129                           RESOLUTION_INFO* res = nullptr,
 130                           const std::string& baseDir = "") const;
 131
 132   /*! \brief Return whether skin debugging is enabled
 133    \return true if skin debugging (set via <debugging>true</debugging> in addon.xml) is enabled.
 134    */
 135   bool IsDebugging() const { return m_debugging; }
 136
 137   /*! \brief Get the id of the first window to load
 138    The first window is generally Startup.xml unless it doesn't exist or if the skinner
 139    has specified which start windows they support and the user is going to somewhere other
 140    than the home screen.
 141    \return id of the first window to load
 142    */
 143   int GetFirstWindow() const;
 144
 145   /*! \brief Get the id of the window the user wants to start in after any skin animation
 146    \return id of the start window
 147    */
 148   int GetStartWindow() const;
 149
 150   /*! \brief Translate a resolution string
 151    \param name the string to translate
 152    \param res [out] the resolution structure if name is valid
 153    \return true if the resolution is valid, false otherwise
 154    */
 155   static bool TranslateResolution(const std::string &name, RESOLUTION_INFO &res);
 156
 157   void ResolveIncludes(TiXmlElement* node,
 158                        std::map<INFO::InfoPtr, bool>* xmlIncludeConditions = nullptr);
 159
 160   float GetEffectsSlowdown() const { return m_effectsSlowDown; }
 161
 162   const std::vector<CStartupWindow>& GetStartupWindows() const { return m_startupWindows; }
 163
 164   /*! \brief Retrieve the skin paths to search for skin XML files
 165    \param paths [out] vector of paths to search, in order.
 166    */
 167   void GetSkinPaths(std::vector<std::string> &paths) const;
 168
 169   bool IsInUse() const override;
 170
 171   const std::string& GetCurrentAspect() const { return m_currentAspect; }
 172
 173   void LoadIncludes();
 174
 175   /*! \brief Load the defined skin timers
 176    \details Skin timers are defined in Timers.xml \sa Skin_Timers
 177    */
 178   void LoadTimers();
 179
 180   /*! \brief Starts evaluating timers
 181    */
 182   void ProcessTimers();
 183
 184   /*! \brief Called when unloading a skin, allows to cleanup specific
 185    * skin resources.
 186    */
 187   void Unload();
 188
 189   void ToggleDebug();
 190   const INFO::CSkinVariableString* CreateSkinVariable(const std::string& name, int context);
 191
 192   static void SettingOptionsSkinColorsFiller(const std::shared_ptr<const CSetting>& setting,
 193                                              std::vector<StringSettingOption>& list,
 194                                              std::string& current,
 195                                              void* data);
 196   static void SettingOptionsSkinFontsFiller(const std::shared_ptr<const CSetting>& setting,
 197                                             std::vector<StringSettingOption>& list,
 198                                             std::string& current,
 199                                             void* data);
 200   static void SettingOptionsSkinThemesFiller(const std::shared_ptr<const CSetting>& setting,
 201                                              std::vector<StringSettingOption>& list,
 202                                              std::string& current,
 203                                              void* data);
 204   static void SettingOptionsStartupWindowsFiller(const std::shared_ptr<const CSetting>& setting,
 205                                                  std::vector<IntegerSettingOption>& list,
 206                                                  int& current,
 207                                                  void* data);
 208
 209   /*! \brief Don't handle skin settings like normal addon settings
 210    */
 211   bool HasSettings(AddonInstanceId id = ADDON_SETTINGS_ID) override { return false; }
 212   bool HasUserSettings(AddonInstanceId id = ADDON_SETTINGS_ID) override { return false; }
 213
 214   int TranslateString(const std::string &setting);
 215   const std::string& GetString(int setting) const;
 216   void SetString(int setting, const std::string &label);
 217
 218   int TranslateBool(const std::string &setting);
 219   bool GetBool(int setting) const;
 220   void SetBool(int setting, bool set);
 221
 222   /*! \brief Get the skin setting value as an integer value
 223    * \param setting - the setting id
 224    * \return the setting value as an integer, -1 if no conversion is possible
 225    */
 226   int GetInt(int setting) const;
 227
 228   std::set<CSkinSettingPtr> GetSkinSettings() const;
 229   CSkinSettingPtr GetSkinSetting(const std::string& settingId);
 230   std::shared_ptr<const CSkinSetting> GetSkinSetting(const std::string& settingId) const;
 231
 232   void Reset(const std::string &setting);
 233   void Reset();
 234
 235   static std::set<CSkinSettingPtr> ParseSettings(const TiXmlElement* rootElement);
 236
 237   void OnPreInstall() override;
 238   void OnPostInstall(bool update, bool modal) override;
 239
 240   // skin timer methods
 241
 242   /*! \brief Checks if the timer with name `timer` is running
 243    \param timer the name of the skin timer
 244    \return true if the given timer exists and is running, false otherwise
 245    */
 246   bool TimerIsRunning(const std::string& timer) const;
 247
 248   /*! \brief Get the elapsed seconds since the timer with name `timer` was started
 249    \param timer the name of the skin timer
 250    \return the elapsed time in seconds the given timer is running (0 if not running or if it does not exist)
 251    */
 252   float GetTimerElapsedSeconds(const std::string& timer) const;
 253
 254   /*! \brief Starts/Enables a given skin timer
 255    \param timer the name of the skin timer
 256    */
 257   void TimerStart(const std::string& timer) const;
 258
 259   /*! \brief Stops/Disables a given skin timer
 260    \param timer the name of the skin timer
 261    */
 262   void TimerStop(const std::string& timer) const;
 263
 264 protected:
 265   bool LoadStartupWindows(const AddonInfoPtr& addonInfo);
 266
 267   static CSkinSettingPtr ParseSetting(const TiXmlElement* element);
 268
 269   bool SettingsLoaded(AddonInstanceId id = ADDON_SETTINGS_ID) const override;
 270   bool SettingsFromXML(const CXBMCTinyXML& doc,
 271                        bool loadDefaults,
 272                        AddonInstanceId id = ADDON_SETTINGS_ID) override;
 273   bool SettingsToXML(CXBMCTinyXML& doc, AddonInstanceId id = ADDON_SETTINGS_ID) const override;
 274
 275   RESOLUTION_INFO m_defaultRes;
 276   std::vector<RESOLUTION_INFO> m_resolutions;
 277
 278   float m_effectsSlowDown;
 279   CGUIIncludes m_includes;
 280   std::string m_currentAspect;
 281
 282   std::vector<CStartupWindow> m_startupWindows;
 283   bool m_debugging;
 284
 285   /*! Manager/Owner of skin timers */
 286   std::unique_ptr<CSkinTimerManager> m_skinTimerManager;
 287
 288 private:
 289   std::map<int, CSkinSettingStringPtr> m_strings;
 290   std::map<int, CSkinSettingBoolPtr> m_bools;
 291   std::map<std::string, CSkinSettingPtr> m_settings;
 292   std::unique_ptr<CSkinSettingUpdateHandler> m_settingsUpdateHandler;
 293 };
 294
 295 } /*namespace ADDON*/
 296
 297 extern std::shared_ptr<ADDON::CSkinInfo> g_SkinInfo;