lluictrl.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:11k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lluictrl.h
  3.  * @author James Cook, Richard Nelson, Tom Yedwab
  4.  * @brief Abstract base class for UI controls
  5.  *
  6.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2001-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  33. #ifndef LL_LLUICTRL_H
  34. #define LL_LLUICTRL_H
  35. //#include "llboost.h"
  36. #include "llrect.h"
  37. #include "llsd.h"
  38. #include <boost/function.hpp>
  39. #include <boost/signals2.hpp>
  40. #include "llinitparam.h"
  41. #include "llview.h"
  42. #include "llviewmodel.h" // *TODO move dependency to .cpp file
  43. const BOOL TAKE_FOCUS_YES = TRUE;
  44. const BOOL TAKE_FOCUS_NO  = FALSE;
  45. // NOTE: the LLFocusableElement class declaration has been moved from here to llfocusmgr.h.
  46. class LLUICtrl
  47. : public LLView, public boost::signals2::trackable
  48. {
  49. public:
  50. typedef boost::function<void (LLUICtrl* ctrl, const LLSD& param)> commit_callback_t;
  51. typedef boost::signals2::signal<void (LLUICtrl* ctrl, const LLSD& param)> commit_signal_t;
  52. // *TODO: add xml support for this type of signal in the future
  53. typedef boost::signals2::signal<void (LLUICtrl* ctrl, S32 x, S32 y, MASK mask)> mouse_signal_t;
  54. typedef boost::function<bool (LLUICtrl* ctrl, const LLSD& param)> enable_callback_t;
  55. typedef boost::signals2::signal<bool (LLUICtrl* ctrl, const LLSD& param), boost_boolean_combiner> enable_signal_t;
  56. struct CallbackParam : public LLInitParam::Block<CallbackParam>
  57. {
  58. Ignored name;
  59. Optional<std::string> function_name;
  60. Optional<LLSD> parameter;
  61. Optional<std::string> control_name;
  62. CallbackParam();
  63. };
  64. struct CommitCallbackParam : public LLInitParam::Block<CommitCallbackParam, CallbackParam >
  65. {
  66. Optional<commit_callback_t> function;
  67. };
  68. // also used for visible callbacks
  69. struct EnableCallbackParam : public LLInitParam::Block<EnableCallbackParam, CallbackParam >
  70. {
  71. Optional<enable_callback_t> function;
  72. };
  73. struct EnableControls : public LLInitParam::Choice<EnableControls>
  74. {
  75. Alternative<std::string> enabled;
  76. Alternative<std::string> disabled;
  77. EnableControls();
  78. };
  79. struct ControlVisibility : public LLInitParam::Choice<ControlVisibility>
  80. {
  81. Alternative<std::string> visible;
  82. Alternative<std::string> invisible;
  83. ControlVisibility();
  84. };
  85. struct Params : public LLInitParam::Block<Params, LLView::Params>
  86. {
  87. Optional<std::string> label;
  88. Optional<bool> tab_stop,
  89. chrome;
  90. Optional<LLSD> initial_value;
  91. Optional<CommitCallbackParam> init_callback,
  92. commit_callback;
  93. Optional<EnableCallbackParam> validate_callback;
  94. Optional<CommitCallbackParam> mouseenter_callback;
  95. Optional<CommitCallbackParam> mouseleave_callback;
  96. Optional<std::string> control_name;
  97. Optional<EnableControls> enabled_controls;
  98. Optional<ControlVisibility> controls_visibility;
  99. // font params
  100. Optional<const LLFontGL*> font;
  101. Optional<LLFontGL::HAlign> font_halign;
  102. Optional<LLFontGL::VAlign> font_valign;
  103. // cruft from LLXMLNode implementation
  104. Ignored type,
  105. length;
  106. Params();
  107. };
  108. /*virtual*/ ~LLUICtrl();
  109. void initFromParams(const Params& p);
  110. protected:
  111. friend class LLUICtrlFactory;
  112. static const Params& getDefaultParams();
  113. LLUICtrl(const Params& p = getDefaultParams(),
  114.              const LLViewModelPtr& viewmodel=LLViewModelPtr(new LLViewModel));
  115. commit_signal_t::slot_type initCommitCallback(const CommitCallbackParam& cb);
  116. enable_signal_t::slot_type initEnableCallback(const EnableCallbackParam& cb);
  117. // We need this virtual so we can override it with derived versions
  118. virtual LLViewModel* getViewModel() const;
  119.     // We shouldn't ever need to set this directly
  120.     //virtual void    setViewModel(const LLViewModelPtr&);
  121. public:
  122. // LLView interface
  123. /*virtual*/ BOOL setLabelArg( const std::string& key, const LLStringExplicit& text );
  124. /*virtual*/ BOOL isCtrl() const;
  125. /*virtual*/ void setTentative(BOOL b);
  126. /*virtual*/ BOOL getTentative() const;
  127. /*virtual*/ void onMouseEnter(S32 x, S32 y, MASK mask);
  128. /*virtual*/ void onMouseLeave(S32 x, S32 y, MASK mask);
  129. /*virtual*/ BOOL canFocusChildren() const;
  130. /*virtual*/ BOOL  handleMouseDown(S32 x, S32 y, MASK mask);
  131. /*virtual*/ BOOL  handleMouseUp(S32 x, S32 y, MASK mask);
  132. /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
  133. /*virtual*/ BOOL handleRightMouseUp(S32 x, S32 y, MASK mask);
  134. /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
  135. // From LLFocusableElement
  136. /*virtual*/ void setFocus( BOOL b );
  137. /*virtual*/ BOOL hasFocus() const;
  138. // New virtuals
  139. // Return NULL by default (overrride if the class has the appropriate interface)
  140. virtual class LLCtrlSelectionInterface* getSelectionInterface();
  141. virtual class LLCtrlListInterface* getListInterface();
  142. virtual class LLCtrlScrollInterface* getScrollInterface();
  143. bool setControlValue(const LLSD& value);
  144. void setControlVariable(LLControlVariable* control);
  145. virtual void setControlName(const std::string& control, LLView *context = NULL);
  146. LLControlVariable* getControlVariable() { return mControlVariable; } 
  147. void setEnabledControlVariable(LLControlVariable* control);
  148. void setDisabledControlVariable(LLControlVariable* control);
  149. void setMakeVisibleControlVariable(LLControlVariable* control);
  150. void setMakeInvisibleControlVariable(LLControlVariable* control);
  151. virtual void setValue(const LLSD& value);
  152. virtual LLSD getValue() const;
  153.     /// When two widgets are displaying the same data (e.g. during a skin
  154.     /// change), share their ViewModel.
  155.     virtual void    shareViewModelFrom(const LLUICtrl& other);
  156. virtual BOOL setTextArg(  const std::string& key, const LLStringExplicit& text );
  157. virtual void setIsChrome(BOOL is_chrome);
  158. virtual BOOL acceptsTextInput() const; // Defaults to false
  159. // A control is dirty if the user has modified its value.
  160. // Editable controls should override this.
  161. virtual BOOL isDirty() const; // Defauls to false
  162. virtual void resetDirty(); //Defaults to no-op
  163. // Call appropriate callback
  164. virtual void onCommit();
  165. // Default to no-op:
  166. virtual void onTabInto();
  167. // Clear any user-provided input (text in a text editor, checked checkbox,
  168. // selected radio button, etc.).  Defaults to no-op.
  169. virtual void clear();
  170. virtual void setColor(const LLColor4& color);
  171. BOOL focusNextItem(BOOL text_entry_only);
  172. BOOL focusPrevItem(BOOL text_entry_only);
  173. BOOL  focusFirstItem(BOOL prefer_text_fields = FALSE, BOOL focus_flash = TRUE );
  174. BOOL focusLastItem(BOOL prefer_text_fields = FALSE);
  175. // Non Virtuals
  176. LLHandle<LLUICtrl> getUICtrlHandle() const { return mUICtrlHandle; }
  177. BOOL getIsChrome() const;
  178. void setTabStop( BOOL b );
  179. BOOL hasTabStop() const;
  180. LLUICtrl* getParentUICtrl() const;
  181. // return true if help topic found by crawling through parents -
  182. // topic then put in help_topic_out
  183. bool                    findHelpTopic(std::string& help_topic_out);
  184. boost::signals2::connection setCommitCallback( const commit_signal_t::slot_type& cb );
  185. boost::signals2::connection setValidateCallback( const enable_signal_t::slot_type& cb );
  186. boost::signals2::connection setMouseEnterCallback( const commit_signal_t::slot_type& cb );
  187. boost::signals2::connection setMouseLeaveCallback( const commit_signal_t::slot_type& cb );
  188. boost::signals2::connection setMouseDownCallback( const mouse_signal_t::slot_type& cb );
  189. boost::signals2::connection setMouseUpCallback( const mouse_signal_t::slot_type& cb );
  190. boost::signals2::connection setRightMouseDownCallback( const mouse_signal_t::slot_type& cb );
  191. boost::signals2::connection setRightMouseUpCallback( const mouse_signal_t::slot_type& cb );
  192. boost::signals2::connection setDoubleClickCallback( const mouse_signal_t::slot_type& cb );
  193. // *TODO: Deprecate; for backwards compatability only:
  194. boost::signals2::connection setCommitCallback( boost::function<void (LLUICtrl*,void*)> cb, void* data);
  195. boost::signals2::connection setValidateBeforeCommit( boost::function<bool (const LLSD& data)> cb );
  196. LLUICtrl* findRootMostFocusRoot();
  197. class LLTextInputFilter : public LLQueryFilter, public LLSingleton<LLTextInputFilter>
  198. {
  199. /*virtual*/ filterResult_t operator() (const LLView* const view, const viewList_t & children) const 
  200. {
  201. return filterResult_t(view->isCtrl() && static_cast<const LLUICtrl *>(view)->acceptsTextInput(), TRUE);
  202. }
  203. };
  204. template <typename F, typename DERIVED> class CallbackRegistry : public LLRegistrySingleton<std::string, F, DERIVED >
  205. {};
  206. class CommitCallbackRegistry : public CallbackRegistry<commit_callback_t, CommitCallbackRegistry>{};
  207. // the enable callback registry is also used for visiblity callbacks
  208. class EnableCallbackRegistry : public CallbackRegistry<enable_callback_t, EnableCallbackRegistry>{};
  209. protected:
  210. static bool controlListener(const LLSD& newvalue, LLHandle<LLUICtrl> handle, std::string type);
  211. commit_signal_t* mCommitSignal;
  212. enable_signal_t* mValidateSignal;
  213. commit_signal_t* mMouseEnterSignal;
  214. commit_signal_t* mMouseLeaveSignal;
  215. mouse_signal_t* mMouseDownSignal;
  216. mouse_signal_t* mMouseUpSignal;
  217. mouse_signal_t* mRightMouseDownSignal;
  218. mouse_signal_t* mRightMouseUpSignal;
  219. mouse_signal_t* mDoubleClickSignal;
  220.     LLViewModelPtr  mViewModel;
  221. LLControlVariable* mControlVariable;
  222. boost::signals2::connection mControlConnection;
  223. LLControlVariable* mEnabledControlVariable;
  224. boost::signals2::connection mEnabledControlConnection;
  225. LLControlVariable* mDisabledControlVariable;
  226. boost::signals2::connection mDisabledControlConnection;
  227. LLControlVariable* mMakeVisibleControlVariable;
  228. boost::signals2::connection mMakeVisibleControlConnection;
  229. LLControlVariable* mMakeInvisibleControlVariable;
  230. boost::signals2::connection mMakeInvisibleControlConnection;
  231. private:
  232. BOOL mTabStop;
  233. BOOL mIsChrome;
  234. BOOL mTentative;
  235. LLRootHandle<LLUICtrl> mUICtrlHandle;
  236. class DefaultTabGroupFirstSorter;
  237. };
  238. // Build time optimization, generate once in .cpp file
  239. #ifndef LLUICTRL_CPP
  240. extern template class LLUICtrl* LLView::getChild<class LLUICtrl>(
  241. const std::string& name, BOOL recurse) const;
  242. #endif
  243. #endif  // LL_LLUICTRL_H