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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lltabcontainer.h
  3.  * @brief LLTabContainer class
  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.  */
  32. #ifndef LL_TABCONTAINER_H
  33. #define LL_TABCONTAINER_H
  34. #include "llpanel.h"
  35. #include "lltextbox.h"
  36. #include "llframetimer.h"
  37. #include "lliconctrl.h"
  38. #include "llbutton.h"
  39. class LLTabTuple;
  40. class LLTabContainer : public LLPanel
  41. {
  42. public:
  43. enum TabPosition
  44. {
  45. TOP,
  46. BOTTOM,
  47. LEFT
  48. };
  49. typedef enum e_insertion_point
  50. {
  51. START,
  52. END,
  53. LEFT_OF_CURRENT,
  54. RIGHT_OF_CURRENT
  55. } eInsertionPoint;
  56. struct TabPositions : public LLInitParam::TypeValuesHelper<LLTabContainer::TabPosition, TabPositions>
  57. {
  58. static void declareValues();
  59. };
  60. struct TabParams : public LLInitParam::Block<TabParams>
  61. {
  62. Optional<LLUIImage*> tab_top_image_unselected,
  63. tab_top_image_selected,
  64. tab_bottom_image_unselected,
  65. tab_bottom_image_selected,
  66. tab_left_image_unselected,
  67. tab_left_image_selected;
  68. TabParams();
  69. };
  70. struct Params
  71. : public LLInitParam::Block<Params, LLPanel::Params>
  72. {
  73. Optional<TabPosition, TabPositions> tab_position;
  74. Optional<S32> tab_width,
  75. tab_min_width,
  76. tab_max_width,
  77. tab_height,
  78. label_pad_bottom,
  79. label_pad_left;
  80. Optional<bool> hide_tabs;
  81. Optional<S32> tab_padding_right;
  82. Optional<TabParams> first_tab,
  83. middle_tab,
  84. last_tab;
  85. /**
  86.  * Tab label horizontal alignment
  87.  */
  88. Optional<LLFontGL::HAlign> font_halign;
  89. /**
  90.  * Tab label ellipses
  91.  */
  92. Optional<bool> use_ellipses;
  93. /**
  94.  * Use LLCustomButtonIconCtrl or LLButton in LLTabTuple
  95.  */
  96. Optional<bool> use_custom_icon_ctrl;
  97. /**
  98.  *  Paddings for LLIconCtrl in case of LLCustomButtonIconCtrl usage(use_custom_icon_ctrl = true)
  99.  */
  100. Optional<S32> tab_icon_ctrl_pad;
  101. Params();
  102. };
  103. protected:
  104. LLTabContainer(const Params&);
  105. friend class LLUICtrlFactory;
  106. public:
  107. //LLTabContainer( const std::string& name, const LLRect& rect, TabPosition pos,
  108. // BOOL bordered, BOOL is_vertical);
  109. /*virtual*/ ~LLTabContainer();
  110. // from LLView
  111. /*virtual*/ void setValue(const LLSD& value);
  112. /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
  113. /*virtual*/ void draw();
  114. /*virtual*/ BOOL handleMouseDown( S32 x, S32 y, MASK mask );
  115. /*virtual*/ BOOL handleHover( S32 x, S32 y, MASK mask );
  116. /*virtual*/ BOOL handleMouseUp( S32 x, S32 y, MASK mask );
  117. /*virtual*/ BOOL handleToolTip(S32 x, S32 y, MASK mask);
  118. /*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
  119. /*virtual*/ BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  120.    EDragAndDropType type, void* cargo_data,
  121.    EAcceptance* accept, std::string& tooltip);
  122. /*virtual*/ LLView* getChildView(const std::string& name, BOOL recurse = TRUE) const;
  123. /*virtual*/ LLView* findChildView(const std::string& name, BOOL recurse = TRUE) const;
  124. /*virtual*/ void initFromParams(const LLPanel::Params& p);
  125. /*virtual*/ bool addChild(LLView* view, S32 tab_group = 0);
  126. /*virtual*/ BOOL postBuild();
  127. struct TabPanelParams : public LLInitParam::Block<TabPanelParams>
  128. {
  129. Mandatory<LLPanel*> panel;
  130. Optional<std::string> label;
  131. Optional<bool> select_tab,
  132. is_placeholder;
  133. Optional<S32> indent;
  134. Optional<eInsertionPoint> insert_at;
  135. Optional<void*> user_data;
  136. TabPanelParams()
  137. : panel("panel", NULL),
  138. label("label"),
  139. select_tab("select_tab"),
  140. is_placeholder("is_placeholder"),
  141. indent("indent"),
  142. insert_at("insert_at", END)
  143. {}
  144. };
  145. void addTabPanel(LLPanel* panel);
  146. void addTabPanel(const TabPanelParams& panel);
  147. void  addPlaceholder(LLPanel* child, const std::string& label);
  148. void  removeTabPanel( LLPanel* child );
  149. void  lockTabs(S32 num_tabs = 0);
  150. void  unlockTabs();
  151. S32  getNumLockedTabs() { return mLockedTabCount; }
  152. void  enableTabButton(S32 which, BOOL enable);
  153. void  deleteAllTabs();
  154. LLPanel* getCurrentPanel();
  155. S32 getCurrentPanelIndex();
  156. S32 getTabCount();
  157. LLPanel* getPanelByIndex(S32 index);
  158. S32 getIndexForPanel(LLPanel* panel);
  159. S32 getPanelIndexByTitle(const std::string& title);
  160. LLPanel* getPanelByName(const std::string& name);
  161. void setCurrentTabName(const std::string& name);
  162. void selectFirstTab();
  163. void selectLastTab();
  164. void selectNextTab();
  165.  void selectPrevTab();
  166. BOOL  selectTabPanel( LLPanel* child );
  167. BOOL  selectTab(S32 which);
  168. BOOL  selectTabByName(const std::string& title);
  169. BOOL        getTabPanelFlashing(LLPanel* child);
  170. void setTabPanelFlashing(LLPanel* child, BOOL state);
  171. void  setTabImage(LLPanel* child, std::string img_name, const LLColor4& color = LLColor4::white);
  172. void  setTabImage(LLPanel* child, const LLUUID& img_id, const LLColor4& color = LLColor4::white);
  173. void setTabImage(LLPanel* child, LLIconCtrl* icon);
  174. void setTitle( const std::string& title );
  175. const std::string getPanelTitle(S32 index);
  176. void setTopBorderHeight(S32 height);
  177. S32 getTopBorderHeight() const;
  178. void  setRightTabBtnOffset( S32 offset );
  179. void  setPanelTitle(S32 index, const std::string& title);
  180. TabPosition getTabPosition() const { return mTabPosition; }
  181. void setMinTabWidth(S32 width) { mMinTabWidth = width; }
  182. void setMaxTabWidth(S32 width) { mMaxTabWidth = width; }
  183. S32 getMinTabWidth() const { return mMinTabWidth; }
  184. S32 getMaxTabWidth() const { return mMaxTabWidth; }
  185. void startDragAndDropDelayTimer() { mDragAndDropDelayTimer.start(); }
  186. void onTabBtn( const LLSD& data, LLPanel* panel );
  187. void onNextBtn(const LLSD& data);
  188. void onNextBtnHeld(const LLSD& data);
  189. void onPrevBtn(const LLSD& data);
  190. void onPrevBtnHeld(const LLSD& data);
  191. void onJumpFirstBtn( const LLSD& data );
  192. void onJumpLastBtn( const LLSD& data );
  193. private:
  194. void initButtons();
  195. BOOL setTab(S32 which);
  196. LLTabTuple* getTab(S32 index)  { return mTabList[index]; }
  197. LLTabTuple* getTabByPanel(LLPanel* child);
  198. void insertTuple(LLTabTuple * tuple, eInsertionPoint insertion_point);
  199. S32 getScrollPos() const { return mScrollPos; }
  200. void setScrollPos(S32 pos) { mScrollPos = pos; }
  201. S32 getMaxScrollPos() const { return mMaxScrollPos; }
  202. void setMaxScrollPos(S32 pos) { mMaxScrollPos = pos; }
  203. S32 getScrollPosPixels() const { return mScrollPosPixels; }
  204. void setScrollPosPixels(S32 pixels) { mScrollPosPixels = pixels; }
  205. void setTabsHidden(BOOL hidden) { mTabsHidden = hidden; }
  206. BOOL getTabsHidden() const { return mTabsHidden; }
  207. void setCurrentPanelIndex(S32 index) { mCurrentTabIdx = index; }
  208. void scrollPrev() { mScrollPos = llmax(0, mScrollPos-1); } // No wrap
  209. void scrollNext() { mScrollPos = llmin(mScrollPos+1, mMaxScrollPos); } // No wrap
  210. void updateMaxScrollPos();
  211. void commitHoveredButton(S32 x, S32 y);
  212. // updates tab button images given the tuple, tab position and the corresponding params
  213. void update_images(LLTabTuple* tuple, TabParams params, LLTabContainer::TabPosition pos);
  214. void reshapeTuple(LLTabTuple* tuple);
  215. // Variables
  216. typedef std::vector<LLTabTuple*> tuple_list_t;
  217. tuple_list_t mTabList;
  218. S32 mCurrentTabIdx;
  219. BOOL mTabsHidden;
  220. BOOL mScrolled;
  221. LLFrameTimer mScrollTimer;
  222. S32 mScrollPos;
  223. S32 mScrollPosPixels;
  224. S32 mMaxScrollPos;
  225. LLTextBox* mTitleBox;
  226. S32 mTopBorderHeight;
  227. TabPosition  mTabPosition;
  228. S32 mLockedTabCount;
  229. S32 mMinTabWidth;
  230. LLButton* mPrevArrowBtn;
  231. LLButton* mNextArrowBtn;
  232. BOOL mIsVertical;
  233. // Horizontal specific
  234. LLButton* mJumpPrevArrowBtn;
  235. LLButton* mJumpNextArrowBtn;
  236. S32 mRightTabBtnOffset; // Extra room to the right of the tab buttons.
  237. S32 mMaxTabWidth;
  238. S32 mTotalTabWidth;
  239. S32 mTabHeight;
  240. // Padding under the text labels of tab buttons
  241. S32 mLabelPadBottom;
  242. // Padding to the left of text labels of tab buttons
  243. S32 mLabelPadLeft;
  244. LLFrameTimer mDragAndDropDelayTimer;
  245. LLFontGL::HAlign                mFontHalign;
  246. const LLFontGL* mFont;
  247. TabParams mFirstTabParams;
  248. TabParams mMiddleTabParams;
  249. TabParams mLastTabParams;
  250. bool mCustomIconCtrlUsed;
  251. S32 mTabIconCtrlPad;
  252. bool mUseTabEllipses;
  253. };
  254. #endif  // LL_TABCONTAINER_H