code.vuplus.com Git - vuplus_xbmc/blob - xbmc/settings/Setting.h

   1 #pragma once
   2 /*
   3  *      Copyright (C) 2013 Team XBMC
   4  *      http://xbmc.org
   5  *
   6  *  This Program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2, or (at your option)
   9  *  any later version.
  10  *
  11  *  This Program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with XBMC; see the file COPYING.  If not, see
  18  *  <http://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 #include <map>
  23 #include <set>
  24 #include <string>
  25 #include <vector>
  26
  27 #include <boost/shared_ptr.hpp>
  28
  29 #include "ISetting.h"
  30 #include "ISettingCallback.h"
  31 #include "ISettingControl.h"
  32 #include "SettingDependency.h"
  33 #include "SettingUpdate.h"
  34 #include "threads/SharedSection.h"
  35
  36 /*!
  37  \ingroup settings
  38  \brief Basic setting types available in the settings system.
  39  */
  40 typedef enum {
  41   SettingTypeNone = 0,
  42   SettingTypeBool,
  43   SettingTypeInteger,
  44   SettingTypeNumber,
  45   SettingTypeString,
  46   SettingTypeAction,
  47   SettingTypeList
  48 } SettingType;
  49
  50 /*!
  51  \ingroup settings
  52  \brief Levels which every setting is assigned to.
  53  */
  54 typedef enum {
  55   SettingLevelBasic  = 0,
  56   SettingLevelStandard,
  57   SettingLevelAdvanced,
  58   SettingLevelExpert,
  59   SettingLevelInternal
  60 } SettingLevel;
  61
  62 typedef enum {
  63   SettingOptionsTypeNone = 0,
  64   SettingOptionsTypeStatic,
  65   SettingOptionsTypeDynamic
  66 } SettingOptionsType;
  67
  68 typedef std::pair<int, int> StaticIntegerSettingOption;
  69 typedef std::vector<StaticIntegerSettingOption> StaticIntegerSettingOptions;
  70 typedef std::pair<std::string, int> DynamicIntegerSettingOption;
  71 typedef std::vector<DynamicIntegerSettingOption> DynamicIntegerSettingOptions;
  72 typedef std::pair<std::string, std::string> DynamicStringSettingOption;
  73 typedef std::vector<DynamicStringSettingOption> DynamicStringSettingOptions;
  74
  75 /*!
  76  \ingroup settings
  77  \brief Setting base class containing all the properties which are common to
  78  all settings independent of the setting type.
  79  */
  80 class CSetting : public ISetting,
  81                  protected ISettingCallback
  82 {
  83 public:
  84   CSetting(const std::string &id, CSettingsManager *settingsManager = NULL);
  85   CSetting(const std::string &id, const CSetting &setting);
  86   virtual ~CSetting();
  87
  88   virtual CSetting* Clone(const std::string &id) const = 0;
  89
  90   virtual bool Deserialize(const TiXmlNode *node, bool update = false);
  91
  92   virtual int GetType() const = 0;
  93   virtual bool FromString(const std::string &value) = 0;
  94   virtual std::string ToString() const = 0;
  95   virtual bool Equals(const std::string &value) const = 0;
  96   virtual bool CheckValidity(const std::string &value) const = 0;
  97   virtual void Reset() = 0;
  98
  99   int GetLabel() const { return m_label; }
 100   void SetLabel(int label) { m_label = label; }
 101   int GetHelp() const { return m_help; }
 102   void SetHelp(int help) { m_help = help; }
 103   bool IsEnabled() const;
 104   const std::string& GetParent() const { return m_parentSetting; }
 105   SettingLevel GetLevel() const { return m_level; }
 106   const ISettingControl* GetControl() const { return m_control; }
 107   void SetControl(ISettingControl* control) { m_control = control; }
 108   const SettingDependencies& GetDependencies() const { return m_dependencies; }
 109   const std::set<CSettingUpdate>& GetUpdates() const { return m_updates; }
 110
 111   // overrides of ISetting
 112   virtual bool IsVisible() const;
 113
 114 protected:
 115   friend class CSettingsManager;
 116
 117   virtual bool OnSettingChanging(const CSetting *setting);
 118   virtual void OnSettingChanged(const CSetting *setting);
 119   virtual void OnSettingAction(const CSetting *setting);
 120   virtual bool OnSettingUpdate(CSetting* &setting, const char *oldSettingId, const TiXmlNode *oldSettingNode);
 121   virtual void OnSettingPropertyChanged(const CSetting *setting, const char *propertyName);
 122
 123   void Copy(const CSetting &setting);
 124
 125   ISettingCallback *m_callback;
 126   int m_label;
 127   int m_help;
 128   std::string m_parentSetting;
 129   SettingLevel m_level;
 130   ISettingControl *m_control;
 131   SettingDependencies m_dependencies;
 132   std::set<CSettingUpdate> m_updates;
 133   bool m_changed;
 134   CSharedSection m_critical;
 135 };
 136
 137 typedef boost::shared_ptr<CSetting> SettingPtr;
 138
 139 typedef std::vector<CSetting *> SettingList;
 140 typedef std::vector<SettingPtr> SettingPtrList;
 141
 142 /*!
 143  \ingroup settings
 144  \brief List setting implementation
 145  \sa CSetting
 146  */
 147 class CSettingList : public CSetting
 148 {
 149 public:
 150   CSettingList(const std::string &id, CSetting *settingDefinition, CSettingsManager *settingsManager = NULL);
 151   CSettingList(const std::string &id, const CSettingList &setting);
 152   virtual ~CSettingList();
 153
 154   virtual CSetting* Clone(const std::string &id) const;
 155
 156   virtual bool Deserialize(const TiXmlNode *node, bool update = false);
 157
 158   virtual int GetType() const { return SettingTypeList; }
 159   virtual bool FromString(const std::string &value);
 160   virtual std::string ToString() const;
 161   virtual bool Equals(const std::string &value) const;
 162   virtual bool CheckValidity(const std::string &value) const;
 163   virtual void Reset();
 164
 165   int GetElementType() const;
 166   const CSetting* GetDefinition() const { return m_definition; }
 167
 168   bool FromString(const std::vector<std::string> &value);
 169
 170   const SettingPtrList& GetValue() const { return m_values; }
 171   bool SetValue(const SettingPtrList &values);
 172   const SettingPtrList& GetDefault() const { return m_defaults; }
 173   void SetDefault(const SettingPtrList &values);
 174
 175 protected:
 176   void copy(const CSettingList &setting);
 177   static void copy(const SettingPtrList &srcValues, SettingPtrList &dstValues);
 178   bool fromString(const std::string &strValue, SettingPtrList &values) const;
 179   bool fromValues(const std::vector<std::string> &strValues, SettingPtrList &values) const;
 180   std::string toString(const SettingPtrList &values) const;
 181
 182   SettingPtrList m_values;
 183   SettingPtrList m_defaults;
 184   CSetting *m_definition;
 185   std::string m_delimiter;
 186   int m_minimum;
 187   int m_maximum;
 188 };
 189
 190 /*!
 191  \ingroup settings
 192  \brief Boolean setting implementation.
 193  \sa CSetting
 194  */
 195 class CSettingBool : public CSetting
 196 {
 197 public:
 198   CSettingBool(const std::string &id, CSettingsManager *settingsManager = NULL);
 199   CSettingBool(const std::string &id, const CSettingBool &setting);
 200   CSettingBool(const std::string &id, int label, bool value, CSettingsManager *settingsManager = NULL);
 201   virtual ~CSettingBool() { }
 202
 203   virtual CSetting* Clone(const std::string &id) const;
 204
 205   virtual bool Deserialize(const TiXmlNode *node, bool update = false);
 206
 207   virtual int GetType() const { return SettingTypeBool; }
 208   virtual bool FromString(const std::string &value);
 209   virtual std::string ToString() const;
 210   virtual bool Equals(const std::string &value) const;
 211   virtual bool CheckValidity(const std::string &value) const;
 212   virtual void Reset() { SetValue(m_default); }
 213
 214   bool GetValue() const { CSharedLock lock(m_critical); return m_value; }
 215   bool SetValue(bool value);
 216   bool GetDefault() const { return m_default; }
 217   void SetDefault(bool value);
 218
 219 private:
 220   void copy(const CSettingBool &setting);
 221   bool fromString(const std::string &strValue, bool &value) const;
 222
 223   bool m_value;
 224   bool m_default;
 225 };
 226
 227 /*!
 228  \ingroup settings
 229  \brief Integer setting implementation
 230  \sa CSetting
 231  */
 232 class CSettingInt : public CSetting
 233 {
 234 public:
 235   CSettingInt(const std::string &id, CSettingsManager *settingsManager = NULL);
 236   CSettingInt(const std::string &id, const CSettingInt &setting);
 237   CSettingInt(const std::string &id, int label, int value, int minimum, int step, int maximum, CSettingsManager *settingsManager = NULL);
 238   CSettingInt(const std::string &id, int label, int value, const StaticIntegerSettingOptions &options, CSettingsManager *settingsManager = NULL);
 239   virtual ~CSettingInt() { }
 240
 241   virtual CSetting* Clone(const std::string &id) const;
 242
 243   virtual bool Deserialize(const TiXmlNode *node, bool update = false);
 244
 245   virtual int GetType() const { return SettingTypeInteger; }
 246   virtual bool FromString(const std::string &value);
 247   virtual std::string ToString() const;
 248   virtual bool Equals(const std::string &value) const;
 249   virtual bool CheckValidity(const std::string &value) const;
 250   virtual bool CheckValidity(int value) const;
 251   virtual void Reset() { SetValue(m_default); }
 252
 253   int GetValue() const { CSharedLock lock(m_critical); return m_value; }
 254   bool SetValue(int value);
 255   int GetDefault() const { return m_default; }
 256   void SetDefault(int value);
 257
 258   int GetMinimum() const { return m_min; }
 259   int GetStep() const { return m_step; }
 260   int GetMaximum() const { return m_max; }
 261
 262   SettingOptionsType GetOptionsType() const;
 263   const StaticIntegerSettingOptions& GetOptions() const { return m_options; }
 264   const std::string& GetOptionsFiller() const { return m_optionsFiller; }
 265   DynamicIntegerSettingOptions UpdateDynamicOptions();
 266
 267 private:
 268   void copy(const CSettingInt &setting);
 269   static bool fromString(const std::string &strValue, int &value);
 270
 271   int m_value;
 272   int m_default;
 273   int m_min;
 274   int m_step;
 275   int m_max;
 276   StaticIntegerSettingOptions m_options;
 277   std::string m_optionsFiller;
 278   DynamicIntegerSettingOptions m_dynamicOptions;
 279 };
 280
 281 /*!
 282  \ingroup settings
 283  \brief Real number setting implementation.
 284  \sa CSetting
 285  */
 286 class CSettingNumber : public CSetting
 287 {
 288 public:
 289   CSettingNumber(const std::string &id, CSettingsManager *settingsManager = NULL);
 290   CSettingNumber(const std::string &id, const CSettingNumber &setting);
 291   CSettingNumber(const std::string &id, int label, float value, float minimum, float step, float maximum, CSettingsManager *settingsManager = NULL);
 292   virtual ~CSettingNumber() { }
 293
 294   virtual CSetting* Clone(const std::string &id) const;
 295
 296   virtual bool Deserialize(const TiXmlNode *node, bool update = false);
 297
 298   virtual int GetType() const { return SettingTypeNumber; }
 299   virtual bool FromString(const std::string &value);
 300   virtual std::string ToString() const;
 301   virtual bool Equals(const std::string &value) const;
 302   virtual bool CheckValidity(const std::string &value) const;
 303   virtual bool CheckValidity(double value) const;
 304   virtual void Reset() { SetValue(m_default); }
 305
 306   double GetValue() const { CSharedLock lock(m_critical); return m_value; }
 307   bool SetValue(double value);
 308   double GetDefault() const { return m_default; }
 309   void SetDefault(double value);
 310
 311   double GetMinimum() const { return m_min; }
 312   double GetStep() const { return m_step; }
 313   double GetMaximum() const { return m_max; }
 314
 315 private:
 316   virtual void copy(const CSettingNumber &setting);
 317   static bool fromString(const std::string &strValue, double &value);
 318
 319   double m_value;
 320   double m_default;
 321   double m_min;
 322   double m_step;
 323   double m_max;
 324 };
 325
 326 /*!
 327  \ingroup settings
 328  \brief String setting implementation.
 329  \sa CSetting
 330  */
 331 class CSettingString : public CSetting
 332 {
 333 public:
 334   CSettingString(const std::string &id, CSettingsManager *settingsManager = NULL);
 335   CSettingString(const std::string &id, const CSettingString &setting);
 336   CSettingString(const std::string &id, int label, const std::string &value, CSettingsManager *settingsManager = NULL);
 337   virtual ~CSettingString() { }
 338
 339   virtual CSetting* Clone(const std::string &id) const;
 340
 341   virtual bool Deserialize(const TiXmlNode *node, bool update = false);
 342
 343   virtual int GetType() const { return SettingTypeString; }
 344   virtual bool FromString(const std::string &value) { return SetValue(value); }
 345   virtual std::string ToString() const { return m_value; }
 346   virtual bool Equals(const std::string &value) const { return m_value == value; }
 347   virtual bool CheckValidity(const std::string &value) const;
 348   virtual void Reset() { SetValue(m_default); }
 349
 350   virtual const std::string& GetValue() const { CSharedLock lock(m_critical); return m_value; }
 351   virtual bool SetValue(const std::string &value);
 352   virtual const std::string& GetDefault() const { return m_default; }
 353   virtual void SetDefault(const std::string &value);
 354
 355   virtual bool AllowEmpty() const { return m_allowEmpty; }
 356
 357   SettingOptionsType GetOptionsType() const;
 358   const std::string& GetOptionsFiller() const { return m_optionsFiller; }
 359   DynamicStringSettingOptions UpdateDynamicOptions();
 360
 361 protected:
 362   virtual void copy(const CSettingString &setting);
 363
 364   std::string m_value;
 365   std::string m_default;
 366   bool m_allowEmpty;
 367   std::string m_optionsFiller;
 368   DynamicStringSettingOptions m_dynamicOptions;
 369 };
 370
 371 /*!
 372  \ingroup settings
 373  \brief Action setting implementation.
 374
 375  A setting action will trigger a call to the OnSettingAction() callback method
 376  when activated.
 377
 378  \sa CSetting
 379  */
 380 class CSettingAction : public CSetting
 381 {
 382 public:
 383   CSettingAction(const std::string &id, CSettingsManager *settingsManager = NULL);
 384   CSettingAction(const std::string &id, const CSettingAction &setting);
 385   virtual ~CSettingAction() { }
 386
 387   virtual CSetting* Clone(const std::string &id) const;
 388
 389   virtual bool Deserialize(const TiXmlNode *node, bool update = false);
 390
 391   virtual int GetType() const { return SettingTypeAction; }
 392   virtual bool FromString(const std::string &value) { return false; }
 393   virtual std::string ToString() const { return ""; }
 394   virtual bool Equals(const std::string &value) const { return false; }
 395   virtual bool CheckValidity(const std::string &value) const { return false; }
 396   virtual void Reset() { }
 397
 398   // this needs to be public so it can be triggered when activated
 399   // by the user in the GUI.
 400   virtual void OnSettingAction(const CSetting *setting) { return CSetting::OnSettingAction(this); }
 401 };