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

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

游戏引擎

开发平台：

C++ Builder

llview.h：源码内容
  1. /** 
  2.  * @file llview.h
  3.  * @brief Container for other views, anything that draws.
  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_LLVIEW_H
  34. #define LL_LLVIEW_H
  36. // A view is an area in a window that can draw.  It might represent
  37. // the HUD or a dialog box or a button.  It can also contain sub-views
  38. // and child widgets
  40. #include "stdtypes.h"
  41. #include "llcoord.h"
  42. #include "llfontgl.h"
  43. #include "llmortician.h"
  44. #include "llmousehandler.h"
  45. #include "llstring.h"
  46. #include "llrect.h"
  47. #include "llui.h"
  48. #include "lluistring.h"
  49. #include "llviewquery.h"
  50. #include "stdenums.h"
  51. #include "lluistring.h"
  52. #include "llcursortypes.h"
  53. #include "lluictrlfactory.h"
  54. #include "lltreeiterators.h"
  55. #include "llfocusmgr.h"
  57. #include <list>
  59. class LLSD;
  61. const U32 FOLLOWS_NONE = 0x00;
  62. const U32 FOLLOWS_LEFT = 0x01;
  63. const U32 FOLLOWS_RIGHT = 0x02;
  64. const U32 FOLLOWS_TOP = 0x10;
  65. const U32 FOLLOWS_BOTTOM = 0x20;
  66. const U32 FOLLOWS_ALL = 0x33;
  68. const BOOL MOUSE_OPAQUE = TRUE;
  69. const BOOL NOT_MOUSE_OPAQUE = FALSE;
  71. const U32 GL_NAME_UI_RESERVED = 2;
  74. // maintains render state during traversal of UI tree
  75. class LLViewDrawContext
  76. {
  77. public:
  78. F32 mAlpha;
  80. LLViewDrawContext(F32 alpha = 1.f)
  81. : mAlpha(alpha)
  82. {
  83. if (!sDrawContextStack.empty())
  84. {
  85. LLViewDrawContext* context_top = sDrawContextStack.back();
  86. // merge with top of stack
  87. mAlpha *= context_top->mAlpha;
  88. }
  89. sDrawContextStack.push_back(this);
  90. }
  92. ~LLViewDrawContext()
  93. {
  94. sDrawContextStack.pop_back();
  95. }
  97. static const LLViewDrawContext& getCurrentContext();
  99. private:
  100. static std::vector<LLViewDrawContext*> sDrawContextStack;
  101. };
  103. class LLViewWidgetRegistry : public LLChildRegistry<LLViewWidgetRegistry>
  104. {};
  106. class LLView : public LLMouseHandler, public LLMortician, public LLFocusableElement
  107. {
  108. public:
  109. struct Follows : public LLInitParam::Choice<Follows>
  110. {
  111. Alternative<std::string> string;
  112. Alternative<U32> flags;
  114.         Follows();
  115. };
  117. struct Params : public LLInitParam::Block<Params>
  118. {
  119. Mandatory<std::string> name;
  121. Optional<bool> enabled,
  122. visible,
  123. mouse_opaque,
  124. use_bounding_rect,
  125. from_xui;
  127. Optional<S32> tab_group,
  128. default_tab_group;
  129. Optional<std::string> tool_tip;
  131. Optional<S32> sound_flags;
  132. Optional<Follows> follows;
  133. Optional<std::string> hover_cursor;
  135. Optional<std::string> layout;
  136. Optional<LLRect> rect;
  137. // Historical bottom-left layout used bottom_delta and left_delta
  138. // for relative positioning.  New layout "topleft" prefers specifying
  139. // based on top edge.
  140. Optional<S32> bottom_delta, // deprecated
  141. top_pad, // from last bottom to my top
  142. top_delta, // from last top to my top
  143. left_pad, // from last right to my left
  144. left_delta; // from last left to my left
  146. Optional<bool> center_horiz,
  147. center_vert;
  149. // these are nested attributes for LLLayoutPanel
  150. //FIXME: get parent context involved in parsing traversal
  151. Ignored user_resize,
  152. auto_resize,
  153. needs_translate,
  154. xmlns,
  155. xmlns_xsi,
  156. xsi_schemaLocation,
  157. xsi_type;
  159. Params();
  160. };
  162. typedef LLViewWidgetRegistry child_registry_t;
  164. void initFromParams(const LLView::Params&);
  166. protected:
  167. LLView(const LLView::Params&);
  168. friend class LLUICtrlFactory;
  170. private:
  171. // widgets in general are not copyable
  172. LLView(const LLView& other) {};
  173. public:
  174. #if LL_DEBUG
  175. static BOOL sIsDrawing;
  176. #endif
  177. enum ESoundFlags
  178. {
  179. SILENT = 0,
  180. MOUSE_DOWN = 1,
  181. MOUSE_UP = 2
  182. };
  184. enum ESnapType
  185. {
  186. SNAP_PARENT,
  187. SNAP_SIBLINGS,
  188. SNAP_PARENT_AND_SIBLINGS
  189. };
  191. enum ESnapEdge
  192. {
  193. SNAP_LEFT, 
  194. SNAP_TOP, 
  195. SNAP_RIGHT, 
  196. SNAP_BOTTOM
  197. };
  199. typedef std::list<LLView*> child_list_t;
  200. typedef child_list_t::iterator child_list_iter_t;
  201. typedef child_list_t::const_iterator   child_list_const_iter_t;
  202. typedef child_list_t::reverse_iterator  child_list_reverse_iter_t;
  203. typedef child_list_t::const_reverse_iterator  child_list_const_reverse_iter_t;
  205. typedef std::vector<class LLUICtrl *> ctrl_list_t;
  207. typedef std::pair<S32, S32> tab_order_t;
  208. typedef std::pair<LLUICtrl *, tab_order_t> tab_order_pair_t;
  209. // this structure primarily sorts by the tab group, secondarily by the insertion ordinal (lastly by the value of the pointer)
  210. typedef std::map<const LLUICtrl*, tab_order_t> child_tab_order_t;
  211. typedef child_tab_order_t::iterator child_tab_order_iter_t;
  212. typedef child_tab_order_t::const_iterator child_tab_order_const_iter_t;
  213. typedef child_tab_order_t::reverse_iterator child_tab_order_reverse_iter_t;
  214. typedef child_tab_order_t::const_reverse_iterator child_tab_order_const_reverse_iter_t;
  216. virtual ~LLView();
  218. // Some UI widgets need to be added as controls.  Others need to
  219. // be added as regular view children.  isCtrl should return TRUE
  220. // if a widget needs to be added as a ctrl
  221. virtual BOOL isCtrl() const;
  223. virtual BOOL isPanel() const;
  225. //
  226. // MANIPULATORS
  227. //
  228. void setMouseOpaque( BOOL b ) { mMouseOpaque = b; }
  229. BOOL getMouseOpaque() const { return mMouseOpaque; }
  230. void setToolTip( const LLStringExplicit& msg );
  231. BOOL setToolTipArg( const LLStringExplicit& key, const LLStringExplicit& text );
  232. void setToolTipArgs( const LLStringUtil::format_map_t& args );
  234. virtual void setRect(const LLRect &rect);
  235. void setFollows(U32 flags) { mReshapeFlags = flags; }
  237. // deprecated, use setFollows() with FOLLOWS_LEFT | FOLLOWS_TOP, etc.
  238. void setFollowsNone() { mReshapeFlags = FOLLOWS_NONE; }
  239. void setFollowsLeft() { mReshapeFlags |= FOLLOWS_LEFT; }
  240. void setFollowsTop() { mReshapeFlags |= FOLLOWS_TOP; }
  241. void setFollowsRight() { mReshapeFlags |= FOLLOWS_RIGHT; }
  242. void setFollowsBottom() { mReshapeFlags |= FOLLOWS_BOTTOM; }
  243. void setFollowsAll() { mReshapeFlags |= FOLLOWS_ALL; }
  245. void        setSoundFlags(U8 flags) { mSoundFlags = flags; }
  246. void setName(std::string name) { mName = name; }
  247. void setUseBoundingRect( BOOL use_bounding_rect );
  248. BOOL getUseBoundingRect();
  250. ECursorType getHoverCursor() { return mHoverCursor; }
  252. const std::string& getToolTip() const { return mToolTipMsg.getString(); }
  254. void sendChildToFront(LLView* child);
  255. void sendChildToBack(LLView* child);
  256. void moveChildToFrontOfTabGroup(LLUICtrl* child);
  257. void moveChildToBackOfTabGroup(LLUICtrl* child);
  259. virtual bool addChild(LLView* view, S32 tab_group = 0);
  261. // implemented in terms of addChild()
  262. bool addChildInBack(LLView* view,  S32 tab_group = 0);
  264. // remove the specified child from the view, and set it's parent to NULL.
  265. virtual void removeChild(LLView* view);
  267. virtual BOOL postBuild() { return TRUE; }
  269. child_tab_order_t getCtrlOrder() const { return mCtrlOrder; }
  270. ctrl_list_t getCtrlList() const;
  271. ctrl_list_t getCtrlListSorted() const;
  273. void setDefaultTabGroup(S32 d) { mDefaultTabGroup = d; }
  274. S32 getDefaultTabGroup() const { return mDefaultTabGroup; }
  275. S32 getLastTabGroup() { return mLastTabGroup; }
  277. bool        trueToRoot(const boost::function<bool (const LLView*)>& predicate) const;
  278. BOOL isInVisibleChain() const;
  279. BOOL isInEnabledChain() const;
  281. void setFocusRoot(BOOL b) { mIsFocusRoot = b; }
  282. BOOL isFocusRoot() const { return mIsFocusRoot; }
  283. virtual BOOL canFocusChildren() const;
  285. BOOL focusNextRoot();
  286. BOOL focusPrevRoot();
  288. // delete all children. Override this function if you need to
  289. // perform any extra clean up such as cached pointers to selected
  290. // children, etc.
  291. virtual void deleteAllChildren();
  293. virtual void setTentative(BOOL b);
  294. virtual BOOL getTentative() const;
  295. void  setAllChildrenEnabled(BOOL b);
  297. virtual void setVisible(BOOL visible);
  298. BOOL getVisible() const { return mVisible; }
  299. virtual void setEnabled(BOOL enabled);
  300. BOOL getEnabled() const { return mEnabled; }
  301. /// 'available' in this context means 'visible and enabled': in other
  302. /// words, can a user actually interact with this?
  303. virtual bool isAvailable() const;
  304. /// The static isAvailable() tests an LLView* that could be NULL.
  305. static bool isAvailable(const LLView* view);
  306. U8              getSoundFlags() const       { return mSoundFlags; }
  308. virtual BOOL setLabelArg( const std::string& key, const LLStringExplicit& text );
  310. virtual void handleVisibilityChange ( BOOL new_visibility );
  312. void pushVisible(BOOL visible) { mLastVisible = mVisible; setVisible(visible); }
  313. void popVisible() { setVisible(mLastVisible); }
  315. LLHandle<LLView> getHandle() { mHandle.bind(this); return mHandle; }
  317. U32 getFollows() const { return mReshapeFlags; }
  318. BOOL followsLeft() const { return mReshapeFlags & FOLLOWS_LEFT; }
  319. BOOL followsRight() const { return mReshapeFlags & FOLLOWS_RIGHT; }
  320. BOOL followsTop() const { return mReshapeFlags & FOLLOWS_TOP; }
  321. BOOL followsBottom() const { return mReshapeFlags & FOLLOWS_BOTTOM; }
  322. BOOL followsAll() const { return mReshapeFlags & FOLLOWS_ALL; }
  324. const LLRect& getRect() const { return mRect; }
  325. const LLRect& getBoundingRect() const { return mBoundingRect; }
  326. LLRect getLocalBoundingRect() const;
  327. LLRect calcScreenRect() const;
  328. LLRect calcScreenBoundingRect() const;
  329. LLRect getLocalRect() const;
  330. virtual LLRect getSnapRect() const;
  331. LLRect getLocalSnapRect() const;
  333. std::string getLayout() { return mLayout; }
  335. // Override and return required size for this object. 0 for width/height means don't care.
  336. virtual LLRect getRequiredRect();
  337. LLRect calcBoundingRect();
  338. void updateBoundingRect();
  340. LLView* getRootView();
  341. LLView* getParent() const { return mParentView; }
  342. LLView* getFirstChild() const { return (mChildList.empty()) ? NULL : *(mChildList.begin()); }
  343. LLView* findPrevSibling(LLView* child);
  344. LLView* findNextSibling(LLView* child);
  345. S32 getChildCount() const { return (S32)mChildList.size(); }
  346. template<class _Pr3> void sortChildren(_Pr3 _Pred) { mChildList.sort(_Pred); }
  347. BOOL hasAncestor(const LLView* parentp) const;
  348. BOOL hasChild(const std::string& childname, BOOL recurse = FALSE) const;
  349. BOOL  childHasKeyboardFocus( const std::string& childname ) const;
  351. // these iterators are used for collapsing various tree traversals into for loops
  352. typedef LLTreeDFSIter<LLView, child_list_const_iter_t> tree_iterator_t;
  353. tree_iterator_t beginTreeDFS();
  354. tree_iterator_t endTreeDFS();
  356. typedef LLTreeDFSPostIter<LLView, child_list_const_iter_t> tree_post_iterator_t;
  357. tree_post_iterator_t beginTreeDFSPost();
  358. tree_post_iterator_t endTreeDFSPost();
  361. typedef LLTreeDownIter<LLView> root_to_view_iterator_t;
  362. root_to_view_iterator_t beginRootToView();
  363. root_to_view_iterator_t endRootToView();
  365. //
  366. // UTILITIES
  367. //
  369. // Default behavior is to use reshape flags to resize child views
  370. virtual void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
  371. virtual void translate( S32 x, S32 y );
  372. void setOrigin( S32 x, S32 y ) { mRect.translate( x - mRect.mLeft, y - mRect.mBottom ); }
  373. BOOL translateIntoRect( const LLRect& constraint, BOOL allow_partial_outside );
  374. BOOL translateIntoRectWithExclusion( const LLRect& inside, const LLRect& exclude, BOOL allow_partial_outside );
  375. void centerWithin(const LLRect& bounds);
  377. void setShape(const LLRect& new_rect, bool by_user = false);
  378. virtual LLView* findSnapRect(LLRect& new_rect, const LLCoordGL& mouse_dir, LLView::ESnapType snap_type, S32 threshold, S32 padding = 0);
  379. virtual LLView* findSnapEdge(S32& new_edge_val, const LLCoordGL& mouse_dir, ESnapEdge snap_edge, ESnapType snap_type, S32 threshold, S32 padding = 0);
  380. virtual BOOL canSnapTo(const LLView* other_view);
  381. virtual void setSnappedTo(const LLView* snap_view);
  383. // inherited from LLFocusableElement
  384. /* virtual */ BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
  385. /* virtual */ BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
  387. virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  388.   EDragAndDropType cargo_type,
  389.   void* cargo_data,
  390.   EAcceptance* accept,
  391.   std::string& tooltip_msg);
  393. virtual void draw();
  395. void parseFollowsFlags(const LLView::Params& params);
  397. // Some widgets, like close box buttons, don't need to be saved
  398. BOOL getFromXUI() const { return mFromXUI; }
  399. void setFromXUI(BOOL b) { mFromXUI = b; }
  401. typedef enum e_hit_test_type
  402. {
  403. HIT_TEST_USE_BOUNDING_RECT,
  404. HIT_TEST_IGNORE_BOUNDING_RECT
  405. }EHitTestType;
  407. BOOL parentPointInView(S32 x, S32 y, EHitTestType type = HIT_TEST_USE_BOUNDING_RECT) const;
  408. BOOL pointInView(S32 x, S32 y, EHitTestType type = HIT_TEST_USE_BOUNDING_RECT) const;
  409. BOOL blockMouseEvent(S32 x, S32 y) const;
  411. // See LLMouseHandler virtuals for screenPointToLocal and localPointToScreen
  412. BOOL localPointToOtherView( S32 x, S32 y, S32 *other_x, S32 *other_y, LLView* other_view) const;
  413. BOOL localRectToOtherView( const LLRect& local, LLRect* other, LLView* other_view ) const;
  414. void screenRectToLocal( const LLRect& screen, LLRect* local ) const;
  415. void localRectToScreen( const LLRect& local, LLRect* screen ) const;
  417. LLControlVariable *findControl(const std::string& name);
  419.     // Moved setValue(), getValue(), setControlValue(), setControlName(),
  420.     // controlListener() to LLUICtrl because an LLView is NOT assumed to
  421.     // contain a value. If that's what you want, use LLUICtrl instead.
  422. // virtual bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata);
  424. const child_list_t* getChildList() const { return &mChildList; }
  425. const child_list_const_iter_t beginChild()  { return mChildList.begin(); }
  426. const child_list_const_iter_t endChild()  { return mChildList.end(); }
  428. // LLMouseHandler functions
  429. //  Default behavior is to pass events to children
  430. /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
  431. /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
  432. /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  433. /*virtual*/ BOOL handleMiddleMouseUp(S32 x, S32 y, MASK mask);
  434. /*virtual*/ BOOL handleMiddleMouseDown(S32 x, S32 y, MASK mask);
  435. /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
  436. /*virtual*/ BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
  437. /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
  438. /*virtual*/ BOOL handleRightMouseUp(S32 x, S32 y, MASK mask);
  439. /*virtual*/ BOOL handleToolTip(S32 x, S32 y, MASK mask);
  441. /*virtual*/ std::string getName() const;
  442. /*virtual*/ void onMouseCaptureLost();
  443. /*virtual*/ BOOL hasMouseCapture();
  444. /*virtual*/ void screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const;
  445. /*virtual*/ void localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const;
  447. virtual LLView* childFromPoint(S32 x, S32 y);
  449. // view-specific handlers 
  450. virtual void onMouseEnter(S32 x, S32 y, MASK mask);
  451. virtual void onMouseLeave(S32 x, S32 y, MASK mask);
  454. template <class T> T* findChild(const std::string& name, BOOL recurse = TRUE) const
  455. {
  456. LLView* child = findChildView(name, recurse);
  457. T* result = dynamic_cast<T*>(child);
  458. return result;
  459. }
  461. template <class T> T* getChild(const std::string& name, BOOL recurse = TRUE) const;
  463. template <class T> T& getChildRef(const std::string& name, BOOL recurse = TRUE) const
  464. {
  465. return *getChild<T>(name, recurse);
  466. }
  468. virtual LLView* getChildView(const std::string& name, BOOL recurse = TRUE) const;
  469. virtual LLView* findChildView(const std::string& name, BOOL recurse = TRUE) const;
  471. template <class T> T* getDefaultWidget(const std::string& name) const
  472. {
  473. default_widget_map_t::const_iterator found_it = getDefaultWidgetMap().find(name);
  474. if (found_it == getDefaultWidgetMap().end())
  475. {
  476. return NULL;
  477. }
  478. return dynamic_cast<T*>(found_it->second);
  479. }
  481. //////////////////////////////////////////////
  482. // statics
  483. //////////////////////////////////////////////
  484. //static LLFontGL::HAlign selectFontHAlign(LLXMLNodePtr node);
  486. // focuses the item in the list after the currently-focused item, wrapping if necessary
  487. static BOOL focusNext(LLView::child_list_t & result);
  488. // focuses the item in the list before the currently-focused item, wrapping if necessary
  489. static BOOL focusPrev(LLView::child_list_t & result);
  491. // returns query for iterating over controls in tab order
  492. static const LLCtrlQuery & getTabOrderQuery();
  493. // return query for iterating over focus roots in tab order
  494. static const LLCtrlQuery & getFocusRootsQuery();
  496. static void deleteViewByHandle(LLHandle<LLView> handle);
  497. static LLWindow* getWindow(void) { return LLUI::sWindow; }
  499. // Set up params after XML load before calling new(),
  500. // usually to adjust layout.
  501. static void applyXUILayout(Params& p, LLView* parent);
  503. // For re-export of floaters and panels, convert the coordinate system
  504. // to be top-left based.
  505. static void setupParamsForExport(Params& p, LLView* parent);
  507. //virtual BOOL addChildFromParam(const LLInitParam::BaseBlock& params) { return TRUE; }
  508. virtual BOOL handleKeyHere(KEY key, MASK mask);
  509. virtual BOOL handleUnicodeCharHere(llwchar uni_char);
  511. virtual void handleReshape(const LLRect& rect, bool by_user);
  512. virtual void dirtyRect();
  514. //send custom notification to LLView parent
  515. virtual S32 notifyParent(const LLSD& info);
  517. //send custom notification to all view childrend
  518. // return true if _any_ children return true. otherwise false.
  519. virtual bool notifyChildren(const LLSD& info);
  521. //send custom notification to current view
  522. virtual S32 notify(const LLSD& info) { return 0;};
  524. static const LLViewDrawContext& getDrawContext();
  526. protected:
  527. void drawDebugRect();
  528. void drawChild(LLView* childp, S32 x_offset = 0, S32 y_offset = 0, BOOL force_draw = FALSE);
  529. void drawChildren();
  531. LLView* childrenHandleKey(KEY key, MASK mask);
  532. LLView* childrenHandleUnicodeChar(llwchar uni_char);
  533. LLView* childrenHandleDragAndDrop(S32 x, S32 y, MASK mask,
  534.   BOOL drop,
  535.   EDragAndDropType type,
  536.   void* data,
  537.   EAcceptance* accept,
  538.   std::string& tooltip_msg);
  540. LLView* childrenHandleHover(S32 x, S32 y, MASK mask);
  541. LLView* childrenHandleMouseUp(S32 x, S32 y, MASK mask);
  542. LLView* childrenHandleMouseDown(S32 x, S32 y, MASK mask);
  543. LLView* childrenHandleMiddleMouseUp(S32 x, S32 y, MASK mask);
  544. LLView* childrenHandleMiddleMouseDown(S32 x, S32 y, MASK mask);
  545. LLView* childrenHandleDoubleClick(S32 x, S32 y, MASK mask);
  546. LLView* childrenHandleScrollWheel(S32 x, S32 y, S32 clicks);
  547. LLView* childrenHandleRightMouseDown(S32 x, S32 y, MASK mask);
  548. LLView* childrenHandleRightMouseUp(S32 x, S32 y, MASK mask);
  549. LLView* childrenHandleToolTip(S32 x, S32 y, MASK mask);
  551. ECursorType mHoverCursor;
  553. private:
  555. LLView* mParentView;
  556. child_list_t mChildList;
  558. std::string mName;
  559. // location in pixels, relative to surrounding structure, bottom,left=0,0
  560. LLRect mRect;
  561. LLRect mBoundingRect;
  562. std::string mLayout;
  564. U32 mReshapeFlags;
  566. child_tab_order_t mCtrlOrder;
  567. S32 mDefaultTabGroup;
  568. S32 mLastTabGroup;
  570. BOOL mEnabled; // Enabled means "accepts input that has an effect on the state of the application."
  571. // A disabled view, for example, may still have a scrollbar that responds to mouse events.
  572. BOOL mMouseOpaque; // Opaque views handle all mouse events that are over their rect.
  573. LLUIString mToolTipMsg; // isNull() is true if none.
  575. U8          mSoundFlags;
  576. BOOL mFromXUI;
  578. BOOL mIsFocusRoot;
  579. BOOL mUseBoundingRect; // hit test against bounding rectangle that includes all child elements
  581. LLRootHandle<LLView> mHandle;
  582. BOOL mLastVisible;
  584. BOOL mVisible;
  586. S32 mNextInsertionOrdinal;
  588. static LLWindow* sWindow; // All root views must know about their window.
  590. typedef std::map<std::string, LLView*> default_widget_map_t;
  591. // allocate this map no demand, as it is rarely needed
  592. mutable default_widget_map_t* mDefaultWidgets;
  594. default_widget_map_t& getDefaultWidgetMap() const;
  596. public:
  597. // Depth in view hierarchy during rendering
  598. static S32 sDepth;
  600. // Draw debug rectangles around widgets to help with alignment and spacing
  601. static bool sDebugRects;
  603. // Draw widget names and sizes when drawing debug rectangles, turning this
  604. // off is useful to make the rectangles themselves easier to see.
  605. static bool sDebugRectsShowNames;
  607. static bool sDebugKeys;
  608. static bool sDebugMouseHandling;
  609. static std::string sMouseHandlerMessage;
  610. static S32 sSelectID;
  611. static std::set<LLView*> sPreviewHighlightedElements; // DEV-16869
  612. static BOOL sHighlightingDiffs; // DEV-16869
  613. static LLView* sPreviewClickedElement; // DEV-16869
  614. static BOOL sDrawPreviewHighlights;
  615. static S32 sLastLeftXML;
  616. static S32 sLastBottomXML;
  617. static BOOL sForceReshape;
  618. };
  620. class LLCompareByTabOrder
  621. {
  622. public:
  623. LLCompareByTabOrder(LLView::child_tab_order_t order) : mTabOrder(order) {}
  624. virtual ~LLCompareByTabOrder() {}
  625. bool operator() (const LLView* const a, const LLView* const b) const;
  626. private:
  627. virtual bool compareTabOrders(const LLView::tab_order_t & a, const LLView::tab_order_t & b) const { return a < b; }
  628. LLView::child_tab_order_t mTabOrder;
  629. };
  631. template <class T> T* LLView::getChild(const std::string& name, BOOL recurse) const
  632. {
  633. LLView* child = findChildView(name, recurse);
  634. T* result = dynamic_cast<T*>(child);
  635. if (!result)
  636. {
  637. // did we find *something* with that name?
  638. if (child)
  639. {
  640. llwarns << "Found child named " << name << " but of wrong type " << typeid(*child).name() << ", expecting " << typeid(T*).name() << llendl;
  641. }
  642. result = getDefaultWidget<T>(name);
  643. if (!result)
  644. {
  645. result = LLUICtrlFactory::getDefaultWidget<T>(name);
  647. if (result)
  648. {
  649. // *NOTE: You cannot call mFoo = getChild<LLFoo>("bar")
  650. // in a floater or panel constructor.  The widgets will not
  651. // be ready.  Instead, put it in postBuild().
  652. llwarns << "Making dummy " << typeid(T).name() << " named "" << name << "" in " << getName() << llendl;
  653. }
  654. else
  655. {
  656. llwarns << "Failed to create dummy " << typeid(T).name() << llendl;
  657. return NULL;
  658. }
  660. getDefaultWidgetMap()[name] = result;
  661. }
  662. }
  663. return result;
  664. }
  666. // Compiler optimization - don't generate these specializations inline,
  667. // require explicit specialization.  See llbutton.cpp for an example.
  668. #ifndef LLVIEW_CPP
  669. extern template class LLView* LLView::getChild<class LLView>(
  670. const std::string& name, BOOL recurse) const;
  671. #endif
  673. #endif //LL_LLVIEW_H