xbmc/settings/DisplaySettings.h

   1 /*
   2  *  Copyright (C) 2013-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 "settings/ISubSettings.h"
  12 #include "settings/lib/ISettingCallback.h"
  13 #include "threads/CriticalSection.h"
  14 #include "utils/Observer.h"
  15 #include "windowing/Resolution.h"
  16
  17 #include <map>
  18 #include <set>
  19 #include <utility>
  20 #include <vector>
  21
  22 class TiXmlNode;
  23 struct IntegerSettingOption;
  24 struct StringSettingOption;
  25
  26 class CDisplaySettings : public ISettingCallback, public ISubSettings,
  27                          public Observable
  28 {
  29 public:
  30   static CDisplaySettings& GetInstance();
  31
  32   bool Load(const TiXmlNode *settings) override;
  33   bool Save(TiXmlNode *settings) const override;
  34   void Clear() override;
  35
  36   void OnSettingAction(const std::shared_ptr<const CSetting>& setting) override;
  37   bool OnSettingChanging(const std::shared_ptr<const CSetting>& setting) override;
  38   bool OnSettingUpdate(const std::shared_ptr<CSetting>& setting,
  39                        const char* oldSettingId,
  40                        const TiXmlNode* oldSettingNode) override;
  41   void OnSettingChanged(const std::shared_ptr<const CSetting>& setting) override;
  42
  43   /*!
  44    \brief Returns the currently active resolution
  45
  46    This resolution might differ from the display resolution which is based on
  47    the user's settings.
  48
  49    \sa SetCurrentResolution
  50    \sa GetResolutionInfo
  51    \sa GetDisplayResolution
  52    */
  53   RESOLUTION GetCurrentResolution() const { return m_currentResolution; }
  54   void SetCurrentResolution(RESOLUTION resolution, bool save = false);
  55   /*!
  56    \brief Returns the best-matching resolution of the videoscreen.screenmode setting value
  57
  58    This resolution might differ from the current resolution which is based on
  59    the properties of the operating system and the attached displays.
  60
  61    \sa GetCurrentResolution
  62    */
  63   RESOLUTION GetDisplayResolution() const;
  64
  65   const RESOLUTION_INFO& GetResolutionInfo(size_t index) const;
  66   const RESOLUTION_INFO& GetResolutionInfo(RESOLUTION resolution) const;
  67   RESOLUTION_INFO& GetResolutionInfo(size_t index);
  68   RESOLUTION_INFO& GetResolutionInfo(RESOLUTION resolution);
  69   size_t ResolutionInfoSize() const { return m_resolutions.size(); }
  70   void AddResolutionInfo(const RESOLUTION_INFO &resolution);
  71
  72   const RESOLUTION_INFO& GetCurrentResolutionInfo() const { return GetResolutionInfo(m_currentResolution); }
  73   RESOLUTION_INFO& GetCurrentResolutionInfo() { return GetResolutionInfo(m_currentResolution); }
  74   RESOLUTION GetResFromString(const std::string &strResolution) { return GetResolutionFromString(strResolution); }
  75   std::string GetStringFromRes(const RESOLUTION resolution, float refreshrate = 0.0f) { return GetStringFromResolution(resolution, refreshrate); }
  76
  77   void ApplyCalibrations();
  78   void UpdateCalibrations();
  79   void ClearCalibrations();
  80   void ClearCustomResolutions();
  81
  82   float GetZoomAmount() const { return m_zoomAmount; }
  83   void SetZoomAmount(float zoomAmount) { m_zoomAmount = zoomAmount; }
  84   float GetPixelRatio() const { return m_pixelRatio; }
  85   void SetPixelRatio(float pixelRatio) { m_pixelRatio = pixelRatio; }
  86   float GetVerticalShift() const { return m_verticalShift; }
  87   void SetVerticalShift(float verticalShift) { m_verticalShift = verticalShift; }
  88   bool IsNonLinearStretched() const { return m_nonLinearStretched; }
  89   void SetNonLinearStretched(bool nonLinearStretch) { m_nonLinearStretched = nonLinearStretch; }
  90   void SetMonitor(const std::string& monitor);
  91
  92   static void SettingOptionsModesFiller(const std::shared_ptr<const CSetting>& setting,
  93                                         std::vector<StringSettingOption>& list,
  94                                         std::string& current,
  95                                         void* data);
  96   static void SettingOptionsRefreshChangeDelaysFiller(
  97       const std::shared_ptr<const CSetting>& setting,
  98       std::vector<IntegerSettingOption>& list,
  99       int& current,
 100       void* data);
 101   static void SettingOptionsRefreshRatesFiller(const std::shared_ptr<const CSetting>& setting,
 102                                                std::vector<StringSettingOption>& list,
 103                                                std::string& current,
 104                                                void* data);
 105   static void SettingOptionsResolutionsFiller(const std::shared_ptr<const CSetting>& setting,
 106                                               std::vector<IntegerSettingOption>& list,
 107                                               int& current,
 108                                               void* data);
 109   static void SettingOptionsDispModeFiller(const std::shared_ptr<const CSetting>& setting,
 110                                            std::vector<IntegerSettingOption>& list,
 111                                            int& current,
 112                                            void* data);
 113   static void SettingOptionsStereoscopicModesFiller(const std::shared_ptr<const CSetting>& setting,
 114                                                     std::vector<IntegerSettingOption>& list,
 115                                                     int& current,
 116                                                     void* data);
 117   static void SettingOptionsPreferredStereoscopicViewModesFiller(
 118       const std::shared_ptr<const CSetting>& setting,
 119       std::vector<IntegerSettingOption>& list,
 120       int& current,
 121       void* data);
 122   static void SettingOptionsMonitorsFiller(const std::shared_ptr<const CSetting>& setting,
 123                                            std::vector<StringSettingOption>& list,
 124                                            std::string& current,
 125                                            void* data);
 126   static void SettingOptionsCmsModesFiller(const std::shared_ptr<const CSetting>& setting,
 127                                            std::vector<IntegerSettingOption>& list,
 128                                            int& current,
 129                                            void* data);
 130   static void SettingOptionsCmsWhitepointsFiller(const std::shared_ptr<const CSetting>& setting,
 131                                                  std::vector<IntegerSettingOption>& list,
 132                                                  int& current,
 133                                                  void* data);
 134   static void SettingOptionsCmsPrimariesFiller(const std::shared_ptr<const CSetting>& setting,
 135                                                std::vector<IntegerSettingOption>& list,
 136                                                int& current,
 137                                                void* data);
 138   static void SettingOptionsCmsGammaModesFiller(const std::shared_ptr<const CSetting>& setting,
 139                                                 std::vector<IntegerSettingOption>& list,
 140                                                 int& current,
 141                                                 void* data);
 142
 143
 144 protected:
 145   CDisplaySettings();
 146   CDisplaySettings(const CDisplaySettings&) = delete;
 147   CDisplaySettings& operator=(CDisplaySettings const&) = delete;
 148   ~CDisplaySettings() override;
 149
 150   DisplayMode GetCurrentDisplayMode() const;
 151
 152   static RESOLUTION GetResolutionFromString(const std::string &strResolution);
 153   static std::string GetStringFromResolution(RESOLUTION resolution, float refreshrate = 0.0f);
 154   static RESOLUTION GetResolutionForScreen();
 155
 156   static RESOLUTION FindBestMatchingResolution(const std::map<RESOLUTION, RESOLUTION_INFO> &resolutionInfos, int width, int height, float refreshrate, unsigned int flags);
 157
 158 private:
 159   // holds the real gui resolution
 160   RESOLUTION m_currentResolution;
 161
 162   typedef std::vector<RESOLUTION_INFO> ResolutionInfos;
 163   ResolutionInfos m_resolutions;
 164   ResolutionInfos m_calibrations;
 165
 166   float m_zoomAmount;         // current zoom amount
 167   float m_pixelRatio;         // current pixel ratio
 168   float m_verticalShift;      // current vertical shift
 169   bool  m_nonLinearStretched;   // current non-linear stretch
 170
 171   bool m_resolutionChangeAborted;
 172   mutable CCriticalSection m_critical;
 173 };