Skin.h

/*
 *  Copyright (C) 2005-2018 Team Kodi
 *  This file is part of Kodi - https://kodi.tv
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 *  See LICENSES/README.md for more information.
 */

#pragma once

#include "addons/Addon.h"
#include "addons/gui/skin/SkinTimerManager.h"
#include "guilib/GUIIncludes.h" // needed for the GUIInclude member
#include "windowing/GraphicContext.h" // needed for the RESOLUTION members

#include <map>
#include <memory>
#include <set>
#include <utility>
#include <vector>

#define CREDIT_LINE_LENGTH 50

class CSetting;
struct IntegerSettingOption;
struct StringSettingOption;

namespace ADDON
{

class CSkinSettingUpdateHandler;

class CSkinSetting
{
public:
  virtual ~CSkinSetting() = default;

  bool Serialize(TiXmlElement* parent) const;

  virtual std::string GetType() const = 0;

  virtual bool Deserialize(const TiXmlElement* element);

  std::string name;

protected:
  virtual bool SerializeSetting(TiXmlElement* element) const = 0;
};

typedef std::shared_ptr<CSkinSetting> CSkinSettingPtr;

class CSkinSettingString : public CSkinSetting
{
public:
  ~CSkinSettingString() override = default;

  std::string GetType() const override { return "string"; }

  bool Deserialize(const TiXmlElement* element) override;

  std::string value;

protected:
  bool SerializeSetting(TiXmlElement* element) const override;
};

typedef std::shared_ptr<CSkinSettingString> CSkinSettingStringPtr;

class CSkinSettingBool : public CSkinSetting
{
public:
  ~CSkinSettingBool() override = default;

  std::string GetType() const override { return "bool"; }

  bool Deserialize(const TiXmlElement* element) override;

  bool value = false;

protected:
  bool SerializeSetting(TiXmlElement* element) const override;
};

typedef std::shared_ptr<CSkinSettingBool> CSkinSettingBoolPtr;

class CSkinInfo : public CAddon
{
public:
  class CStartupWindow
  {
  public:
    CStartupWindow(int id, const char *name):
        m_id(id), m_name(name)
    {
    };
    int m_id;
    std::string m_name;
  };

  explicit CSkinInfo(const AddonInfoPtr& addonInfo);
  //FIXME: CAddonCallbacksGUI/WindowXML hack
  explicit CSkinInfo(
      const AddonInfoPtr& addonInfo,
      const RESOLUTION_INFO& resolution);

  CSkinInfo(
      const AddonInfoPtr& addonInfo,
      const RESOLUTION_INFO& resolution,
      const std::vector<RESOLUTION_INFO>& resolutions,
      float effectsSlowDown,
      bool debugging);

  ~CSkinInfo() override;

  void Start();

  bool HasSkinFile(const std::string &strFile) const;

  std::string GetSkinPath(const std::string& file,
                          RESOLUTION_INFO* res = nullptr,
                          const std::string& baseDir = "") const;

  bool IsDebugging() const { return m_debugging; }

  int GetFirstWindow() const;

  int GetStartWindow() const;

  static bool TranslateResolution(const std::string &name, RESOLUTION_INFO &res);

  void ResolveIncludes(TiXmlElement* node,
                       std::map<INFO::InfoPtr, bool>* xmlIncludeConditions = nullptr);

  float GetEffectsSlowdown() const { return m_effectsSlowDown; }

  const std::vector<CStartupWindow>& GetStartupWindows() const { return m_startupWindows; }

  void GetSkinPaths(std::vector<std::string> &paths) const;

  bool IsInUse() const override;

  const std::string& GetCurrentAspect() const { return m_currentAspect; }

  void LoadIncludes();

  void LoadTimers();

  void ProcessTimers();

  void Unload();

  void ToggleDebug();
  const INFO::CSkinVariableString* CreateSkinVariable(const std::string& name, int context);

  static void SettingOptionsSkinColorsFiller(const std::shared_ptr<const CSetting>& setting,
                                             std::vector<StringSettingOption>& list,
                                             std::string& current,
                                             void* data);
  static void SettingOptionsSkinFontsFiller(const std::shared_ptr<const CSetting>& setting,
                                            std::vector<StringSettingOption>& list,
                                            std::string& current,
                                            void* data);
  static void SettingOptionsSkinThemesFiller(const std::shared_ptr<const CSetting>& setting,
                                             std::vector<StringSettingOption>& list,
                                             std::string& current,
                                             void* data);
  static void SettingOptionsStartupWindowsFiller(const std::shared_ptr<const CSetting>& setting,
                                                 std::vector<IntegerSettingOption>& list,
                                                 int& current,
                                                 void* data);

  bool HasSettings(AddonInstanceId id = ADDON_SETTINGS_ID) override { return false; }
  bool HasUserSettings(AddonInstanceId id = ADDON_SETTINGS_ID) override { return false; }

  int TranslateString(const std::string &setting);
  const std::string& GetString(int setting) const;
  void SetString(int setting, const std::string &label);

  int TranslateBool(const std::string &setting);
  bool GetBool(int setting) const;
  void SetBool(int setting, bool set);

  int GetInt(int setting) const;

  std::set<CSkinSettingPtr> GetSkinSettings() const;
  CSkinSettingPtr GetSkinSetting(const std::string& settingId);
  std::shared_ptr<const CSkinSetting> GetSkinSetting(const std::string& settingId) const;

  void Reset(const std::string &setting);
  void Reset();

  static std::set<CSkinSettingPtr> ParseSettings(const TiXmlElement* rootElement);

  void OnPreInstall() override;
  void OnPostInstall(bool update, bool modal) override;

  // skin timer methods

  bool TimerIsRunning(const std::string& timer) const;

  float GetTimerElapsedSeconds(const std::string& timer) const;

  void TimerStart(const std::string& timer) const;

  void TimerStop(const std::string& timer) const;

protected:
  bool LoadStartupWindows(const AddonInfoPtr& addonInfo);

  static CSkinSettingPtr ParseSetting(const TiXmlElement* element);

  bool SettingsLoaded(AddonInstanceId id = ADDON_SETTINGS_ID) const override;
  bool SettingsFromXML(const CXBMCTinyXML& doc,
                       bool loadDefaults,
                       AddonInstanceId id = ADDON_SETTINGS_ID) override;
  bool SettingsToXML(CXBMCTinyXML& doc, AddonInstanceId id = ADDON_SETTINGS_ID) const override;

  RESOLUTION_INFO m_defaultRes;
  std::vector<RESOLUTION_INFO> m_resolutions;

  float m_effectsSlowDown;
  CGUIIncludes m_includes;
  std::string m_currentAspect;

  std::vector<CStartupWindow> m_startupWindows;
  bool m_debugging;

  CSkinTimerManager m_skinTimerManager;

private:
  std::map<int, CSkinSettingStringPtr> m_strings;
  std::map<int, CSkinSettingBoolPtr> m_bools;
  std::map<std::string, CSkinSettingPtr> m_settings;
  std::unique_ptr<CSkinSettingUpdateHandler> m_settingsUpdateHandler;
};

} /*namespace ADDON*/

extern std::shared_ptr<ADDON::CSkinInfo> g_SkinInfo;