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

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

游戏引擎

开发平台：

C++ Builder

llscrolllistctrl.h：源码内容
  1. /** 
  2.  * @file llscrolllistctrl.h
  3.  * @brief A scrolling list of items.  This is the one you want to use
  4.  * in UI code.  LLScrollListCell, LLScrollListItem, etc. are utility
  5.  * classes.
  6.  *
  7.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2001-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  35. #ifndef LL_SCROLLLISTCTRL_H
  36. #define LL_SCROLLLISTCTRL_H
  38. #include <vector>
  39. #include <deque>
  41. #include "lluictrl.h"
  42. #include "llctrlselectioninterface.h"
  43. //#include "lldarray.h"
  44. #include "llfontgl.h"
  45. #include "llui.h"
  46. #include "llstring.h" // LLWString
  47. #include "lleditmenuhandler.h"
  48. #include "llframetimer.h"
  50. #include "llscrollbar.h"
  51. #include "lldate.h"
  52. #include "llscrolllistitem.h"
  53. #include "llscrolllistcolumn.h"
  54. #include "llviewborder.h"
  56. class LLScrollListCell;
  57. class LLTextBox;
  58. class LLContextMenu;
  60. class LLScrollListCtrl : public LLUICtrl, public LLEditMenuHandler, 
  61. public LLCtrlListInterface, public LLCtrlScrollInterface
  62. {
  63. public:
  64. struct Contents : public LLInitParam::Block<Contents>
  65. {
  66. Multiple<LLScrollListColumn::Params> columns;
  67. Multiple<LLScrollListItem::Params> rows;
  69. //Multiple<Contents> groups;
  71. Contents();
  72. };
  74. // *TODO: Add callbacks to Params
  75. typedef boost::function<void (void)> callback_t;
  77. struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
  78. {
  79. // behavioral flags
  80. Optional<bool> multi_select,
  81. commit_on_keyboard_movement;
  83. // display flags
  84. Optional<bool> has_border,
  85. draw_heading,
  86. draw_stripes,
  87. background_visible,
  88. scroll_bar_bg_visible;
  90. // layout
  91. Optional<S32> column_padding,
  92. page_lines,
  93. heading_height;
  95. // sort and search behavior
  96. Optional<S32> search_column,
  97. sort_column;
  98. Optional<bool> sort_ascending;
  100. // colors
  101. Optional<LLUIColor> fg_unselected_color,
  102. fg_selected_color,
  103. bg_selected_color,
  104. fg_disable_color,
  105. bg_writeable_color,
  106. bg_readonly_color,
  107. bg_stripe_color,
  108. hovered_color,
  109. highlighted_color,
  110. scroll_bar_bg_color;
  112. Optional<Contents> contents;
  114. Optional<LLViewBorder::Params> border;
  116. Params();
  117. };
  119. protected:
  120. friend class LLUICtrlFactory;
  122. LLScrollListCtrl(const Params&);
  124. public:
  125. virtual ~LLScrollListCtrl();
  127. S32 isEmpty() const;
  129. void deleteAllItems() { clearRows(); }
  131. // Sets an array of column descriptors
  132. void      setColumnHeadings(const LLSD& headings);
  133. void    sortByColumnIndex(U32 column, BOOL ascending);
  135. // LLCtrlListInterface functions
  136. virtual S32  getItemCount() const;
  137. // Adds a single column descriptor: ["name" : string, "label" : string, "width" : integer, "relwidth" : integer ]
  138. virtual void addColumn(const LLScrollListColumn::Params& column, EAddPosition pos = ADD_BOTTOM);
  139. virtual void addColumn(const LLSD& column, EAddPosition pos = ADD_BOTTOM);
  140. virtual void clearColumns();
  141. virtual void setColumnLabel(const std::string& column, const std::string& label);
  142. virtual bool  preProcessChildNode(LLXMLNodePtr child);
  143. virtual LLScrollListColumn* getColumn(S32 index);
  144. virtual LLScrollListColumn* getColumn(const std::string& name);
  145. virtual S32 getNumColumns() const { return mColumnsIndexed.size(); }
  147. // Adds a single element, from an array of:
  148. // "columns" => [ "column" => column name, "value" => value, "type" => type, "font" => font, "font-style" => style ], "id" => uuid
  149. // Creates missing columns automatically.
  150. virtual LLScrollListItem* addElement(const LLSD& element, EAddPosition pos = ADD_BOTTOM, void* userdata = NULL);
  151. virtual LLScrollListItem* addRow(LLScrollListItem *new_item, const LLScrollListItem::Params& value, EAddPosition pos = ADD_BOTTOM);
  152. virtual LLScrollListItem* addRow(const LLScrollListItem::Params& value, EAddPosition pos = ADD_BOTTOM);
  153. // Simple add element. Takes a single array of:
  154. // [ "value" => value, "font" => font, "font-style" => style ]
  155. virtual void clearRows(); // clears all elements
  156. virtual void sortByColumn(const std::string& name, BOOL ascending);
  158. // These functions take and return an array of arrays of elements, as above
  159. virtual void setValue(const LLSD& value );
  160. virtual LLSD getValue() const;
  162. LLCtrlSelectionInterface* getSelectionInterface() { return (LLCtrlSelectionInterface*)this; }
  163. LLCtrlListInterface* getListInterface() { return (LLCtrlListInterface*)this; }
  164. LLCtrlScrollInterface* getScrollInterface() { return (LLCtrlScrollInterface*)this; }
  166. // DEPRECATED: Use setSelectedByValue() below.
  167. BOOL setCurrentByID( const LLUUID& id ) { return selectByID(id); }
  168. virtual LLUUID getCurrentID() const { return getStringUUIDSelectedItem(); }
  170. BOOL operateOnSelection(EOperation op);
  171. BOOL operateOnAll(EOperation op);
  173. // returns FALSE if unable to set the max count so low
  174. BOOL  setMaxItemCount(S32 max_count);
  176. BOOL selectByID( const LLUUID& id ); // FALSE if item not found
  178. // Match item by value.asString(), which should work for string, integer, uuid.
  179. // Returns FALSE if not found.
  180. BOOL setSelectedByValue(const LLSD& value, BOOL selected);
  182. BOOL isSorted() const { return mSorted; }
  184. virtual BOOL isSelected(const LLSD& value) const;
  186. BOOL handleClick(S32 x, S32 y, MASK mask);
  187. BOOL selectFirstItem();
  188. BOOL selectNthItem( S32 index );
  189. BOOL selectItemRange( S32 first, S32 last );
  190. BOOL selectItemAt(S32 x, S32 y, MASK mask);
  192. void deleteSingleItem( S32 index );
  193. void deleteItems(const LLSD& sd);
  194. void  deleteSelectedItems();
  195. void deselectAllItems(BOOL no_commit_on_change = FALSE); // by default, go ahead and commit on selection change
  197. void clearHighlightedItems();
  198. void mouseOverHighlightNthItem( S32 index );
  200. void setDoubleClickCallback( callback_t cb ) { mOnDoubleClickCallback = cb; }
  201. void setMaximumSelectCallback( callback_t cb) { mOnMaximumSelectCallback = cb; }
  202. void setSortChangedCallback( callback_t cb)  { mOnSortChangedCallback = cb; }
  203. // Convenience function; *TODO: replace with setter above + boost::bind() in calling code
  204. void setDoubleClickCallback( boost::function<void (void* userdata)> cb, void* userdata) { mOnDoubleClickCallback = boost::bind(cb, userdata); }
  206. void swapWithNext(S32 index);
  207. void swapWithPrevious(S32 index);
  209. void setCanSelect(BOOL can_select) { mCanSelect = can_select; }
  210. virtual BOOL getCanSelect() const { return mCanSelect; }
  212. S32 getItemIndex( LLScrollListItem* item ) const;
  213. S32 getItemIndex( const LLUUID& item_id ) const;
  215. void setCommentText( const std::string& comment_text);
  216. LLScrollListItem* addSeparator(EAddPosition pos);
  218. // "Simple" interface: use this when you're creating a list that contains only unique strings, only
  219. // one of which can be selected at a time.
  220. virtual LLScrollListItem* addSimpleElement(const std::string& value, EAddPosition pos = ADD_BOTTOM, const LLSD& id = LLSD());
  222. BOOL selectItemByLabel( const std::string& item, BOOL case_sensitive = TRUE ); // FALSE if item not found
  223. BOOL selectItemByPrefix(const std::string& target, BOOL case_sensitive = TRUE);
  224. BOOL selectItemByPrefix(const LLWString& target, BOOL case_sensitive = TRUE);
  225. LLScrollListItem*  getItemByLabel( const std::string& item, BOOL case_sensitive = TRUE, S32 column = 0 );
  226. const std::string getSelectedItemLabel(S32 column = 0) const;
  227. LLSD getSelectedValue();
  229. // DEPRECATED: Use LLSD versions of setCommentText() and getSelectedValue().
  230. // "StringUUID" interface: use this when you're creating a list that contains non-unique strings each of which
  231. // has an associated, unique UUID, and only one of which can be selected at a time.
  232. LLScrollListItem* addStringUUIDItem(const std::string& item_text, const LLUUID& id, EAddPosition pos = ADD_BOTTOM, BOOL enabled = TRUE);
  233. LLUUID getStringUUIDSelectedItem() const;
  235. LLScrollListItem* getFirstSelected() const;
  236. virtual S32 getFirstSelectedIndex() const;
  237. std::vector<LLScrollListItem*> getAllSelected() const;
  238. LLScrollListItem* getLastSelectedItem() const { return mLastSelected; }
  240. // iterate over all items
  241. LLScrollListItem* getFirstData() const;
  242. LLScrollListItem* getLastData() const;
  243. std::vector<LLScrollListItem*> getAllData() const;
  245. LLScrollListItem* getItem(const LLSD& sd) const;
  247. void setAllowMultipleSelection(BOOL mult ) { mAllowMultipleSelection = mult; }
  249. void setBgWriteableColor(const LLColor4 &c) { mBgWriteableColor = c; }
  250. void setReadOnlyBgColor(const LLColor4 &c) { mBgReadOnlyColor = c; }
  251. void setBgSelectedColor(const LLColor4 &c) { mBgSelectedColor = c; }
  252. void setBgStripeColor(const LLColor4& c) { mBgStripeColor = c; }
  253. void setFgSelectedColor(const LLColor4 &c) { mFgSelectedColor = c; }
  254. void setFgUnselectedColor(const LLColor4 &c){ mFgUnselectedColor = c; }
  255. void setHoveredColor(const LLColor4 &c) { mHoveredColor = c; }
  256. void setHighlightedColor(const LLColor4 &c) { mHighlightedColor = c; }
  257. void setFgDisableColor(const LLColor4 &c) { mFgDisabledColor = c; }
  259. void setBackgroundVisible(BOOL b) { mBackgroundVisible = b; }
  260. void setDrawStripes(BOOL b) { mDrawStripes = b; }
  261. void setColumnPadding(const S32 c)          { mColumnPadding = c; }
  262. S32  getColumnPadding() { return mColumnPadding; }
  263. void setCommitOnKeyboardMovement(BOOL b) { mCommitOnKeyboardMovement = b; }
  264. void setCommitOnSelectionChange(BOOL b) { mCommitOnSelectionChange = b; }
  265. void setAllowKeyboardMovement(BOOL b) { mAllowKeyboardMovement = b; }
  267. void setMaxSelectable(U32 max_selected) { mMaxSelectable = max_selected; }
  268. S32 getMaxSelectable() { return mMaxSelectable; }
  271. virtual S32 getScrollPos() const;
  272. virtual void setScrollPos( S32 pos );
  273. S32 getSearchColumn();
  274. void setSearchColumn(S32 column) { mSearchColumn = column; }
  275. S32 getColumnIndexFromOffset(S32 x);
  276. S32 getColumnOffsetFromIndex(S32 index);
  277. S32 getRowOffsetFromIndex(S32 index);
  279. void clearSearchString() { mSearchString.clear(); }
  281. // support right-click context menus for avatar/group lists
  282. enum ContextMenuType { MENU_NONE, MENU_AVATAR, MENU_GROUP };
  283. void setContextMenu(const ContextMenuType &menu) { mContextMenuType = menu; }
  285. // Overridden from LLView
  286. /*virtual*/ void    draw();
  287. /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  288. /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
  289. /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
  290. /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
  291. /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
  292. /*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
  293. /*virtual*/ BOOL handleUnicodeCharHere(llwchar uni_char);
  294. /*virtual*/ BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
  295. /*virtual*/ BOOL handleToolTip(S32 x, S32 y, MASK mask);
  296. /*virtual*/ void setEnabled(BOOL enabled);
  297. /*virtual*/ void setFocus( BOOL b );
  298. /*virtual*/ void onFocusReceived();
  299. /*virtual*/ void onFocusLost();
  300. /*virtual*/ void onMouseLeave(S32 x, S32 y, MASK mask);
  301. /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
  303. virtual BOOL isDirty() const;
  304. virtual void resetDirty(); // Clear dirty state
  306. virtual void updateLayout();
  307. virtual void fitContents(S32 max_width, S32 max_height);
  309. virtual LLRect getRequiredRect();
  310. static  BOOL    rowPreceeds(LLScrollListItem *new_row, LLScrollListItem *test_row);
  312. LLRect getItemListRect() { return mItemListRect; }
  314. /// Returns rect, in local coords, of a given row/column
  315. LLRect getCellRect(S32 row_index, S32 column_index);
  317. // Used "internally" by the scroll bar.
  318. void onScrollChange( S32 new_pos, LLScrollbar* src );
  320. static void onClickColumn(void *userdata);
  322. virtual void updateColumns();
  323. void calcColumnWidths();
  324. S32 getMaxContentWidth() { return mMaxContentWidth; }
  326. void setHeadingHeight(S32 heading_height);
  327. /**
  328.  * Sets  max visible  lines without scroolbar, if this value equals to 0,
  329.  * then display all items.
  330.  */
  331. void setPageLines(S32 page_lines );
  332. void setCollapseEmptyColumns(BOOL collapse);
  334. LLScrollListItem* hitItem(S32 x,S32 y);
  335. virtual void scrollToShowSelected();
  337. // LLEditMenuHandler functions
  338. virtual void copy();
  339. virtual BOOL canCopy() const;
  340. virtual void cut();
  341. virtual BOOL canCut() const;
  342. virtual void selectAll();
  343. virtual BOOL canSelectAll() const;
  344. virtual void deselect();
  345. virtual BOOL canDeselect() const;
  347. void setNumDynamicColumns(S32 num) { mNumDynamicWidthColumns = num; }
  348. void updateStaticColumnWidth(LLScrollListColumn* col, S32 new_width);
  349. S32 getTotalStaticColumnWidth() { return mTotalStaticColumnWidth; }
  351. std::string     getSortColumnName();
  352. BOOL getSortAscending() { return mSortColumns.empty() ? TRUE : mSortColumns.back().second; }
  353. BOOL hasSortOrder() const;
  355. S32 selectMultiple( std::vector<LLUUID> ids );
  356. // conceptually const, but mutates mItemList
  357. void updateSort() const;
  358. // sorts a list without affecting the permanent sort order (so further list insertions can be unsorted, for example)
  359. void sortOnce(S32 column, BOOL ascending);
  361. // manually call this whenever editing list items in place to flag need for resorting
  362. void setNeedsSort(bool val = true) { mSorted = !val; }
  363. void dirtyColumns(); // some operation has potentially affected column layout or ordering
  365. protected:
  366. // "Full" interface: use this when you're creating a list that has one or more of the following:
  367. // * contains icons
  368. // * contains multiple columns
  369. // * allows multiple selection
  370. // * has items that are not guarenteed to have unique names
  371. // * has additional per-item data (e.g. a UUID or void* userdata)
  372. //
  373. // To add items using this approach, create new LLScrollListItems and LLScrollListCells.  Add the
  374. // cells (column entries) to each item, and add the item to the LLScrollListCtrl.
  375. //
  376. // The LLScrollListCtrl owns its items and is responsible for deleting them
  377. // (except in the case that the addItem() call fails, in which case it is up
  378. // to the caller to delete the item)
  379. //
  380. // returns FALSE if item faile to be added to list, does NOT delete 'item'
  381. BOOL addItem( LLScrollListItem* item, EAddPosition pos = ADD_BOTTOM, BOOL requires_column = TRUE );
  383. typedef std::deque<LLScrollListItem *> item_list;
  384. item_list& getItemList() { return mItemList; }
  386. void updateLineHeight();
  388. private:
  389. void selectPrevItem(BOOL extend_selection);
  390. void selectNextItem(BOOL extend_selection);
  391. void drawItems();
  393. void            updateLineHeightInsert(LLScrollListItem* item);
  394. void reportInvalidInput();
  395. BOOL isRepeatedChars(const LLWString& string) const;
  396. void selectItem(LLScrollListItem* itemp, BOOL single_select = TRUE);
  397. void deselectItem(LLScrollListItem* itemp);
  398. void commitIfChanged();
  399. BOOL setSort(S32 column, BOOL ascending);
  400. S32 getLinesPerPage();
  402. static void showNameDetails(std::string id, bool is_group);
  403. static void copyNameToClipboard(std::string id, bool is_group);
  404. static void copySLURLToClipboard(std::string id, bool is_group);
  406. S32 mLineHeight; // the max height of a single line
  407. S32 mScrollLines; // how many lines we've scrolled down
  408. S32 mPageLines; // max number of lines is it possible to see on the screen given mRect and mLineHeight
  409. S32 mHeadingHeight; // the height of the column header buttons, if visible
  410. U32 mMaxSelectable; 
  411. LLScrollbar* mScrollbar;
  412. BOOL  mAllowMultipleSelection;
  413. BOOL mAllowKeyboardMovement;
  414. BOOL mCommitOnKeyboardMovement;
  415. BOOL mCommitOnSelectionChange;
  416. BOOL mSelectionChanged;
  417. BOOL mNeedsScroll;
  418. BOOL mCanSelect;
  419. const BOOL mDisplayColumnHeaders;
  420. BOOL mColumnsDirty;
  422. mutable item_list mItemList;
  424. LLScrollListItem *mLastSelected;
  426. S32 mMaxItemCount; 
  428. LLRect mItemListRect;
  429. S32 mMaxContentWidth;
  430. S32             mColumnPadding;
  432. BOOL mBackgroundVisible;
  433. BOOL mDrawStripes;
  435. LLUIColor mBgWriteableColor;
  436. LLUIColor mBgReadOnlyColor;
  437. LLUIColor mBgSelectedColor;
  438. LLUIColor mBgStripeColor;
  439. LLUIColor mFgSelectedColor;
  440. LLUIColor mFgUnselectedColor;
  441. LLUIColor mFgDisabledColor;
  442. LLUIColor mHoveredColor;
  443. LLUIColor mHighlightedColor;
  445. S32 mBorderThickness;
  446. callback_t mOnDoubleClickCallback;
  447. callback_t  mOnMaximumSelectCallback;
  448. callback_t  mOnSortChangedCallback;
  450. S32 mHighlightedItem;
  451. class LLViewBorder* mBorder;
  452. LLContextMenu *mPopupMenu;
  454. LLWString mSearchString;
  455. LLFrameTimer mSearchTimer;
  457. S32 mSearchColumn;
  458. S32 mNumDynamicWidthColumns;
  459. S32 mTotalStaticColumnWidth;
  460. S32 mTotalColumnPadding;
  462. mutable bool mSorted;
  464. typedef std::map<std::string, LLScrollListColumn> column_map_t;
  465. column_map_t mColumns;
  467. BOOL mDirty;
  468. S32 mOriginalSelection;
  470. ContextMenuType mContextMenuType;
  472. typedef std::vector<LLScrollListColumn*> ordered_columns_t;
  473. ordered_columns_t mColumnsIndexed;
  475. typedef std::pair<S32, BOOL> sort_column_t;
  476. std::vector<sort_column_t> mSortColumns;
  477. }; // end class LLScrollListCtrl
  479. #endif  // LL_SCROLLLISTCTRL_H