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