开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llcontrol.h
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：15k
源码类别：

游戏引擎

开发平台：

C++ Builder

llcontrol.h：源码内容
  1. /** 
  2.  * @file llcontrol.h
  3.  * @brief A mechanism for storing "control state" for a program
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #ifndef LL_LLCONTROL_H
  34. #define LL_LLCONTROL_H
  36. #include "llboost.h"
  37. #include "llevent.h"
  38. #include "llnametable.h"
  39. #include "llmap.h"
  40. #include "llstring.h"
  41. #include "llrect.h"
  42. #include "llrefcount.h"
  43. #include "llinstancetracker.h"
  45. #include "llcontrolgroupreader.h"
  47. #include <vector>
  49. // *NOTE: boost::visit_each<> generates warning 4675 on .net 2003
  50. // Disable the warning for the boost includes.
  51. #if LL_WINDOWS
  52. # if (_MSC_VER >= 1300 && _MSC_VER < 1400)
  53. #   pragma warning(push)
  54. #   pragma warning( disable : 4675 )
  55. # endif
  56. #endif
  58. #include <boost/bind.hpp>
  60. #if LL_WINDOWS
  61. #pragma warning (push)
  62. #pragma warning (disable : 4263) // boost::signals2::expired_slot::what() has const mismatch
  63. #pragma warning (disable : 4264) 
  64. #endif
  65. #include <boost/signals2.hpp>
  66. #if LL_WINDOWS
  67. #pragma warning (pop)
  68. #endif
  70. #if LL_WINDOWS
  71. # if (_MSC_VER >= 1300 && _MSC_VER < 1400)
  72. #   pragma warning(pop)
  73. # endif
  74. #endif
  76. class LLVector3;
  77. class LLVector3d;
  78. class LLColor4;
  79. class LLColor3;
  81. const BOOL NO_PERSIST = FALSE;
  83. typedef enum e_control_type
  84. {
  85. TYPE_U32 = 0,
  86. TYPE_S32,
  87. TYPE_F32,
  88. TYPE_BOOLEAN,
  89. TYPE_STRING,
  90. TYPE_VEC3,
  91. TYPE_VEC3D,
  92. TYPE_RECT,
  93. TYPE_COL4,
  94. TYPE_COL3,
  95. TYPE_LLSD,
  96. TYPE_COUNT
  97. } eControlType;
  99. class LLControlVariable : public LLRefCount
  100. {
  101. friend class LLControlGroup;
  103. public:
  104. typedef boost::signals2::signal<bool(LLControlVariable* control, const LLSD&), boost_boolean_combiner> validate_signal_t;
  105. typedef boost::signals2::signal<void(LLControlVariable* control, const LLSD&)> commit_signal_t;
  107. private:
  108. std::string mName;
  109. std::string mComment;
  110. eControlType mType;
  111. bool mPersist;
  112. bool mHideFromSettingsEditor;
  113. std::vector<LLSD> mValues;
  115. commit_signal_t mCommitSignal;
  116. validate_signal_t mValidateSignal;
  118. public:
  119. LLControlVariable(const std::string& name, eControlType type,
  120.   LLSD initial, const std::string& comment,
  121.   bool persist = true, bool hidefromsettingseditor = false);
  123. virtual ~LLControlVariable();
  125. const std::string& getName() const { return mName; }
  126. const std::string& getComment() const { return mComment; }
  128. eControlType type() { return mType; }
  129. bool isType(eControlType tp) { return tp == mType; }
  131. void resetToDefault(bool fire_signal = false);
  133. commit_signal_t* getSignal() { return &mCommitSignal; } // shorthand for commit signal
  134. commit_signal_t* getCommitSignal() { return &mCommitSignal; }
  135. validate_signal_t* getValidateSignal() { return &mValidateSignal; }
  137. bool isDefault() { return (mValues.size() == 1); }
  138. bool isSaveValueDefault();
  139. bool isPersisted() { return mPersist; }
  140. bool isHiddenFromSettingsEditor() { return mHideFromSettingsEditor; }
  141. LLSD get() const { return getValue(); }
  142. LLSD getValue() const { return mValues.back(); }
  143. LLSD getDefault() const { return mValues.front(); }
  144. LLSD getSaveValue() const;
  146. void set(const LLSD& val) { setValue(val); }
  147. void setValue(const LLSD& value, bool saved_value = TRUE);
  148. void setDefaultValue(const LLSD& value);
  149. void setPersist(bool state);
  150. void setHiddenFromSettingsEditor(bool hide);
  151. void setComment(const std::string& comment);
  153. void firePropertyChanged()
  154. {
  155. mCommitSignal(this, mValues.back());
  156. }
  157. private:
  158. LLSD getComparableValue(const LLSD& value);
  159. bool llsd_compare(const LLSD& a, const LLSD & b);
  160. };
  162. typedef LLPointer<LLControlVariable> LLControlVariablePtr;
  164. //! Helper functions for converting between static types and LLControl values
  165. template <class T> 
  166. eControlType get_control_type()
  167. {
  168. llwarns << "Usupported control type: " << typeid(T).name() << "." << llendl;
  169. return TYPE_COUNT;
  170. }
  172. template <class T> 
  173. LLSD convert_to_llsd(const T& in)
  174. {
  175. // default implementation
  176. return LLSD(in);
  177. }
  179. template <class T>
  180. T convert_from_llsd(const LLSD& sd, eControlType type, const std::string& control_name)
  181. {
  182. // needs specialization
  183. return T(sd);
  184. }
  186. //const U32 STRING_CACHE_SIZE = 10000;
  187. class LLControlGroup : public LLInstanceTracker<LLControlGroup, std::string>
  188. {
  189. protected:
  190. typedef std::map<std::string, LLControlVariablePtr > ctrl_name_table_t;
  191. ctrl_name_table_t mNameTable;
  192. std::string mTypeString[TYPE_COUNT];
  194. eControlType typeStringToEnum(const std::string& typestr);
  195. std::string typeEnumToString(eControlType typeenum);
  196. public:
  197. LLControlGroup(const std::string& name);
  198. ~LLControlGroup();
  199. void cleanup();
  201. typedef LLInstanceTracker<LLControlGroup, std::string>::instance_iter instance_iter;
  203. LLControlVariablePtr getControl(const std::string& name);
  205. struct ApplyFunctor
  206. {
  207. virtual ~ApplyFunctor() {};
  208. virtual void apply(const std::string& name, LLControlVariable* control) = 0;
  209. };
  210. void applyToAll(ApplyFunctor* func);
  212. BOOL declareControl(const std::string& name, eControlType type, const LLSD initial_val, const std::string& comment, BOOL persist, BOOL hidefromsettingseditor = FALSE);
  213. BOOL declareU32(const std::string& name, U32 initial_val, const std::string& comment, BOOL persist = TRUE);
  214. BOOL declareS32(const std::string& name, S32 initial_val, const std::string& comment, BOOL persist = TRUE);
  215. BOOL declareF32(const std::string& name, F32 initial_val, const std::string& comment, BOOL persist = TRUE);
  216. BOOL declareBOOL(const std::string& name, BOOL initial_val, const std::string& comment, BOOL persist = TRUE);
  217. BOOL declareString(const std::string& name, const std::string &initial_val, const std::string& comment, BOOL persist = TRUE);
  218. BOOL declareVec3(const std::string& name, const LLVector3 &initial_val,const std::string& comment,  BOOL persist = TRUE);
  219. BOOL declareVec3d(const std::string& name, const LLVector3d &initial_val, const std::string& comment, BOOL persist = TRUE);
  220. BOOL declareRect(const std::string& name, const LLRect &initial_val, const std::string& comment, BOOL persist = TRUE);
  221. BOOL declareColor4(const std::string& name, const LLColor4 &initial_val, const std::string& comment, BOOL persist = TRUE);
  222. BOOL declareColor3(const std::string& name, const LLColor3 &initial_val, const std::string& comment, BOOL persist = TRUE);
  223. BOOL declareLLSD(const std::string& name, const LLSD &initial_val, const std::string& comment, BOOL persist = TRUE);
  225. std::string getString(const std::string& name);
  226. std::string getText(const std::string& name);
  227. BOOL getBOOL(const std::string& name);
  228. S32 getS32(const std::string& name);
  229. F32 getF32(const std::string& name);
  230. U32 getU32(const std::string& name);
  232. LLWString getWString(const std::string& name);
  233. LLVector3 getVector3(const std::string& name);
  234. LLVector3d getVector3d(const std::string& name);
  235. LLRect getRect(const std::string& name);
  236. LLSD        getLLSD(const std::string& name);
  239. LLColor4 getColor(const std::string& name);
  240. LLColor4 getColor4(const std::string& name);
  241. LLColor3 getColor3(const std::string& name);
  243. // generic getter
  244. template<typename T> T get(const std::string& name)
  245. {
  246. LLControlVariable* control = getControl(name);
  247. LLSD value;
  248. eControlType type = TYPE_COUNT;
  250. if (control)
  251. {
  252. value = control->get();
  253. type = control->type();
  254. }
  255. else
  256. {
  257. llwarns << "Control " << name << " not found." << llendl;
  258. }
  259. return convert_from_llsd<T>(value, type, name);
  260. }
  262. void setBOOL(const std::string& name, BOOL val);
  263. void setS32(const std::string& name, S32 val);
  264. void setF32(const std::string& name, F32 val);
  265. void setU32(const std::string& name, U32 val);
  266. void setString(const std::string&  name, const std::string& val);
  267. void setVector3(const std::string& name, const LLVector3 &val);
  268. void setVector3d(const std::string& name, const LLVector3d &val);
  269. void setRect(const std::string& name, const LLRect &val);
  270. void setColor4(const std::string& name, const LLColor4 &val);
  271. void    setLLSD(const std::string& name, const LLSD& val);
  273. // type agnostic setter that takes LLSD
  274. void setUntypedValue(const std::string& name, const LLSD& val);
  276. // generic setter
  277. template<typename T> void set(const std::string& name, const T& val)
  278. {
  279. LLControlVariable* control = getControl(name);
  281. if (control && control->isType(get_control_type<T>()))
  282. {
  283. control->set(convert_to_llsd(val));
  284. }
  285. else
  286. {
  287. llwarns << "Invalid control " << name << llendl;
  288. }
  289. }
  291. BOOL    controlExists(const std::string& name);
  293. // Returns number of controls loaded, 0 if failed
  294. // If require_declaration is false, will auto-declare controls it finds
  295. // as the given type.
  296. U32 loadFromFileLegacy(const std::string& filename, BOOL require_declaration = TRUE, eControlType declare_as = TYPE_STRING);
  297.   U32 saveToFile(const std::string& filename, BOOL nondefault_only);
  298.   U32 loadFromFile(const std::string& filename, bool default_values = false);
  299. void resetToDefaults();
  300. };
  303. //! Publish/Subscribe object to interact with LLControlGroups.
  305. //! Use an LLCachedControl instance to connect to a LLControlVariable
  306. //! without have to manually create and bind a listener to a local
  307. //! object.
  308. template <class T>
  309. class LLControlCache : public LLRefCount, public LLInstanceTracker<LLControlCache<T>, std::string>
  310. {
  311. public:
  312. // This constructor will declare a control if it doesn't exist in the contol group
  313. LLControlCache(LLControlGroup& group,
  314. const std::string& name, 
  315. const T& default_value, 
  316. const std::string& comment)
  317. : LLInstanceTracker<LLControlCache<T>, std::string >(name)
  318. {
  319. if(!group.controlExists(name))
  320. {
  321. if(!declareTypedControl(group, name, default_value, comment))
  322. {
  323. llerrs << "The control could not be created!!!" << llendl;
  324. }
  325. }
  327. bindToControl(group, name);
  328. }
  330. LLControlCache(LLControlGroup& group,
  331. const std::string& name)
  332. : LLInstanceTracker<LLControlCache<T>, std::string >(name)
  333. {
  334. if(!group.controlExists(name))
  335. {
  336. llerrs << "Control named " << name << "not found." << llendl;
  337. }
  339. bindToControl(group, name);
  340. }
  342. ~LLControlCache()
  343. {
  344. }
  346. const T& getValue() const { return mCachedValue; }
  348. private:
  349. void bindToControl(LLControlGroup& group, const std::string& name)
  350. {
  351. LLControlVariablePtr controlp = group.getControl(name);
  352. mType = controlp->type();
  353. mCachedValue = convert_from_llsd<T>(controlp->get(), mType, name);
  355. // Add a listener to the controls signal...
  356. mConnection = controlp->getSignal()->connect(
  357. boost::bind(&LLControlCache<T>::handleValueChange, this, _2)
  358. );
  359. mType = controlp->type();
  360. }
  361. bool declareTypedControl(LLControlGroup& group,
  362. const std::string& name, 
  363.  const T& default_value,
  364.  const std::string& comment)
  365. {
  366. LLSD init_value;
  367. eControlType type = get_control_type<T>();
  368. init_value = convert_to_llsd(default_value);
  369. if(type < TYPE_COUNT)
  370. {
  371. group.declareControl(name, type, init_value, comment, FALSE);
  372. return true;
  373. }
  374. return false;
  375. }
  377. bool handleValueChange(const LLSD& newvalue)
  378. {
  379. mCachedValue = convert_from_llsd<T>(newvalue, mType, "");
  380. return true;
  381. }
  383. private:
  384.     T mCachedValue;
  385. eControlType mType;
  386.     boost::signals2::scoped_connection mConnection;
  387. };
  389. template <typename T>
  390. class LLCachedControl
  391. {
  392. public:
  393. LLCachedControl(LLControlGroup& group,
  394. const std::string& name, 
  395. const T& default_value, 
  396. const std::string& comment = "Declared In Code")
  397. {
  398. mCachedControlPtr = LLControlCache<T>::getInstance(name);
  399. if (mCachedControlPtr.isNull())
  400. {
  401. mCachedControlPtr = new LLControlCache<T>(group, name, default_value, comment);
  402. }
  403. }
  405. LLCachedControl(LLControlGroup& group,
  406. const std::string& name)
  407. {
  408. mCachedControlPtr = LLControlCache<T>::getInstance(name);
  409. if (mCachedControlPtr.isNull())
  410. {
  411. mCachedControlPtr = new LLControlCache<T>(group, name);
  412. }
  413. }
  415. operator const T&() const { return mCachedControlPtr->getValue(); }
  416. operator boost::function<const T&()> () const { return boost::function<const T&()>(*this); }
  417. const T& operator()() { return mCachedControlPtr->getValue(); }
  419. private:
  420. LLPointer<LLControlCache<T> > mCachedControlPtr;
  421. };
  423. template <> eControlType get_control_type<U32>();
  424. template <> eControlType get_control_type<S32>();
  425. template <> eControlType get_control_type<F32>();
  426. template <> eControlType get_control_type<bool>(); 
  427. // Yay BOOL, its really an S32.
  428. //template <> eControlType get_control_type<BOOL> () 
  429. template <> eControlType get_control_type<std::string>();
  430. template <> eControlType get_control_type<LLVector3>();
  431. template <> eControlType get_control_type<LLVector3d>(); 
  432. template <> eControlType get_control_type<LLRect>();
  433. template <> eControlType get_control_type<LLColor4>();
  434. template <> eControlType get_control_type<LLColor3>();
  435. template <> eControlType get_control_type<LLSD>();
  437. template <> LLSD convert_to_llsd<U32>(const U32& in);
  438. template <> LLSD convert_to_llsd<LLVector3>(const LLVector3& in);
  439. template <> LLSD convert_to_llsd<LLVector3d>(const LLVector3d& in); 
  440. template <> LLSD convert_to_llsd<LLRect>(const LLRect& in);
  441. template <> LLSD convert_to_llsd<LLColor4>(const LLColor4& in);
  442. template <> LLSD convert_to_llsd<LLColor3>(const LLColor3& in);
  444. template<> std::string convert_from_llsd<std::string>(const LLSD& sd, eControlType type, const std::string& control_name);
  445. template<> LLWString convert_from_llsd<LLWString>(const LLSD& sd, eControlType type, const std::string& control_name);
  446. template<> LLVector3 convert_from_llsd<LLVector3>(const LLSD& sd, eControlType type, const std::string& control_name);
  447. template<> LLVector3d convert_from_llsd<LLVector3d>(const LLSD& sd, eControlType type, const std::string& control_name);
  448. template<> LLRect convert_from_llsd<LLRect>(const LLSD& sd, eControlType type, const std::string& control_name);
  449. template<> bool convert_from_llsd<bool>(const LLSD& sd, eControlType type, const std::string& control_name);
  450. template<> S32 convert_from_llsd<S32>(const LLSD& sd, eControlType type, const std::string& control_name);
  451. template<> F32 convert_from_llsd<F32>(const LLSD& sd, eControlType type, const std::string& control_name);
  452. template<> U32 convert_from_llsd<U32>(const LLSD& sd, eControlType type, const std::string& control_name);
  453. template<> LLColor3 convert_from_llsd<LLColor3>(const LLSD& sd, eControlType type, const std::string& control_name);
  454. template<> LLColor4 convert_from_llsd<LLColor4>(const LLSD& sd, eControlType type, const std::string& control_name);
  455. template<> LLSD convert_from_llsd<LLSD>(const LLSD& sd, eControlType type, const std::string& control_name);
  457. //#define TEST_CACHED_CONTROL 1
  458. #ifdef TEST_CACHED_CONTROL
  459. void test_cached_control();
  460. #endif // TEST_CACHED_CONTROL
  462. #endif