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

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

游戏引擎

开发平台：

C++ Builder

llscrolllistctrl.cpp：源码内容
  1.  /** 
  2.  * @file llscrolllistctrl.cpp
  3.  * @brief Scroll lists are composed of rows (items), each of which 
  4.  * contains columns (cells).
  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.  */
  34. #include "linden_common.h"
  36. #include "llscrolllistctrl.h"
  38. #include <algorithm>
  40. #include "llstl.h"
  41. #include "llboost.h"
  42. //#include "indra_constants.h"
  44. #include "llcheckboxctrl.h"
  45. #include "llclipboard.h"
  46. #include "llfocusmgr.h"
  47. #include "llgl.h" // LLGLSUIDefault()
  48. #include "lllocalcliprect.h"
  49. //#include "llrender.h"
  50. #include "llresmgr.h"
  51. #include "llscrollbar.h"
  52. #include "llscrolllistcell.h"
  53. #include "llstring.h"
  54. #include "llui.h"
  55. #include "lluictrlfactory.h"
  56. #include "llwindow.h"
  57. #include "llcontrol.h"
  58. #include "llkeyboard.h"
  59. #include "llviewborder.h"
  60. #include "lltextbox.h"
  61. #include "llsdparam.h"
  62. #include "llcachename.h"
  63. #include "llmenugl.h"
  64. #include "llurlaction.h"
  65. #include "lltooltip.h"
  67. #include <boost/bind.hpp>
  69. static LLDefaultChildRegistry::Register<LLScrollListCtrl> r("scroll_list");
  71. // local structures & classes.
  72. struct SortScrollListItem
  73. {
  74. SortScrollListItem(const std::vector<std::pair<S32, BOOL> >& sort_orders)
  75. : mSortOrders(sort_orders)
  76. {}
  78. bool operator()(const LLScrollListItem* i1, const LLScrollListItem* i2)
  79. {
  80. // sort over all columns in order specified by mSortOrders
  81. S32 sort_result = 0;
  82. for (sort_order_t::const_reverse_iterator it = mSortOrders.rbegin();
  83.  it != mSortOrders.rend(); ++it)
  84. {
  85. S32 col_idx = it->first;
  86. BOOL sort_ascending = it->second;
  88. const LLScrollListCell *cell1 = i1->getColumn(col_idx);
  89. const LLScrollListCell *cell2 = i2->getColumn(col_idx);
  90. S32 order = sort_ascending ? 1 : -1; // ascending or descending sort for this column?
  91. if (cell1 && cell2)
  92. {
  93. sort_result = order * LLStringUtil::compareDict(cell1->getValue().asString(), cell2->getValue().asString());
  94. if (sort_result != 0)
  95. {
  96. break; // we have a sort order!
  97. }
  98. }
  99. }
  101. return sort_result < 0;
  102. }
  104. typedef std::vector<std::pair<S32, BOOL> > sort_order_t;
  105. const sort_order_t& mSortOrders;
  106. };
  108. //---------------------------------------------------------------------------
  109. // LLScrollListCtrl
  110. //---------------------------------------------------------------------------
  112. LLScrollListCtrl::Contents::Contents()
  113. : columns("column"),
  114. rows("row")
  115. {
  116. addSynonym(columns, "columns");
  117. addSynonym(rows, "rows");
  118. }
  120. LLScrollListCtrl::Params::Params()
  121. : multi_select("multi_select", false),
  122. has_border("draw_border"),
  123. draw_heading("draw_heading"),
  124. search_column("search_column", 0),
  125. sort_column("sort_column", -1),
  126. sort_ascending("sort_ascending", true),
  127. commit_on_keyboard_movement("commit_on_keyboard_movement", true),
  128. heading_height("heading_height"),
  129. page_lines("page_lines", 0),
  130. background_visible("background_visible"),
  131. draw_stripes("draw_stripes"),
  132. column_padding("column_padding"),
  133. fg_unselected_color("fg_unselected_color"),
  134. fg_selected_color("fg_selected_color"),
  135. bg_selected_color("bg_selected_color"),
  136. fg_disable_color("fg_disable_color"),
  137. bg_writeable_color("bg_writeable_color"),
  138. bg_readonly_color("bg_readonly_color"),
  139. bg_stripe_color("bg_stripe_color"),
  140. hovered_color("hovered_color"),
  141. highlighted_color("highlighted_color"),
  142. contents(""),
  143. scroll_bar_bg_visible("scroll_bar_bg_visible"),
  144. scroll_bar_bg_color("scroll_bar_bg_color")
  145. , border("border")
  146. {
  147. name = "scroll_list";
  148. mouse_opaque = true;
  149. }
  151. LLScrollListCtrl::LLScrollListCtrl(const LLScrollListCtrl::Params& p)
  152. : LLUICtrl(p),
  153. mLineHeight(0),
  154. mScrollLines(0),
  155. mPageLines(p.page_lines),
  156. mMaxSelectable(0),
  157. mAllowKeyboardMovement(TRUE),
  158. mCommitOnKeyboardMovement(p.commit_on_keyboard_movement),
  159. mCommitOnSelectionChange(FALSE),
  160. mSelectionChanged(FALSE),
  161. mNeedsScroll(FALSE),
  162. mCanSelect(TRUE),
  163. mColumnsDirty(FALSE),
  164. mMaxItemCount(INT_MAX), 
  165. mMaxContentWidth(0),
  166. mBorderThickness( 2 ),
  167. mOnDoubleClickCallback( NULL ),
  168. mOnMaximumSelectCallback( NULL ),
  169. mOnSortChangedCallback( NULL ),
  170. mHighlightedItem(-1),
  171. mBorder(NULL),
  172. mPopupMenu(NULL),
  173. mNumDynamicWidthColumns(0),
  174. mTotalStaticColumnWidth(0),
  175. mTotalColumnPadding(0),
  176. mSorted(false),
  177. mDirty(FALSE),
  178. mOriginalSelection(-1),
  179. mLastSelected(NULL),
  180. mHeadingHeight(p.heading_height),
  181. mAllowMultipleSelection(p.multi_select),
  182. mDisplayColumnHeaders(p.draw_heading),
  183. mBackgroundVisible(p.background_visible),
  184. mDrawStripes(p.draw_stripes),
  185. mBgWriteableColor(p.bg_writeable_color()),
  186. mBgReadOnlyColor(p.bg_readonly_color()),
  187. mBgSelectedColor(p.bg_selected_color()),
  188. mBgStripeColor(p.bg_stripe_color()),
  189. mFgSelectedColor(p.fg_selected_color()),
  190. mFgUnselectedColor(p.fg_unselected_color()),
  191. mFgDisabledColor(p.fg_disable_color()),
  192. mHighlightedColor(p.highlighted_color()),
  193. mHoveredColor(p.hovered_color()),
  194. mSearchColumn(p.search_column),
  195. mColumnPadding(p.column_padding),
  196. mContextMenuType(MENU_NONE)
  197. {
  198. mItemListRect.setOriginAndSize(
  199. mBorderThickness,
  200. mBorderThickness,
  201. getRect().getWidth() - 2 * mBorderThickness,
  202. getRect().getHeight() - 2 * mBorderThickness );
  204. updateLineHeight();
  206. // Init the scrollbar
  207. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  209. LLRect scroll_rect;
  210. scroll_rect.setOriginAndSize( 
  211. getRect().getWidth() - mBorderThickness - scrollbar_size,
  212. mItemListRect.mBottom,
  213. scrollbar_size,
  214. mItemListRect.getHeight());
  216. LLScrollbar::Params sbparams;
  217. sbparams.name("Scrollbar");
  218. sbparams.rect(scroll_rect);
  219. sbparams.orientation(LLScrollbar::VERTICAL);
  220. sbparams.doc_size(getItemCount());
  221. sbparams.doc_pos(mScrollLines);
  222. sbparams.page_size( getLinesPerPage() );
  223. sbparams.change_callback(boost::bind(&LLScrollListCtrl::onScrollChange, this, _1, _2));
  224. sbparams.follows.flags(FOLLOWS_RIGHT | FOLLOWS_TOP | FOLLOWS_BOTTOM);
  225. sbparams.visible(false);
  226. sbparams.bg_visible(p.scroll_bar_bg_visible);
  227. sbparams.bg_color(p.scroll_bar_bg_color);
  228. mScrollbar = LLUICtrlFactory::create<LLScrollbar> (sbparams);
  229. addChild(mScrollbar);
  231. // Border
  232. if (p.has_border)
  233. {
  234. LLRect border_rect = getLocalRect();
  235. LLViewBorder::Params params = p.border;
  236. params.rect(border_rect);
  237. mBorder = LLUICtrlFactory::create<LLViewBorder> (params);
  238. addChild(mBorder);
  239. }
  241. // set border *after* rect is fully initialized
  242. if (mBorder)
  243. {
  244. mBorder->setRect(getLocalRect());
  245. mBorder->reshape(getRect().getWidth(), getRect().getHeight());
  246. }
  248. if (p.sort_column >= 0)
  249. {
  250. sortByColumnIndex(p.sort_column, p.sort_ascending);
  251. }
  254. for (LLInitParam::ParamIterator<LLScrollListColumn::Params>::const_iterator row_it = p.contents.columns().begin();
  255. row_it != p.contents.columns().end();
  256. ++row_it)
  257. {
  258. addColumn(*row_it);
  259. }
  261. for (LLInitParam::ParamIterator<LLScrollListItem::Params>::const_iterator row_it = p.contents.rows().begin();
  262. row_it != p.contents.rows().end();
  263. ++row_it)
  264. {
  265. addRow(*row_it);
  266. }
  268. LLTextBox::Params text_p;
  269. text_p.name("comment_text");
  270. text_p.border_visible(false);
  271. text_p.rect(mItemListRect);
  272. text_p.follows.flags(FOLLOWS_ALL);
  273. addChild(LLUICtrlFactory::create<LLTextBox>(text_p));
  274. }
  276. S32 LLScrollListCtrl::getSearchColumn()
  277. {
  278. // search for proper search column
  279. if (mSearchColumn < 0)
  280. {
  281. LLScrollListItem* itemp = getFirstData();
  282. if (itemp)
  283. {
  284. for(S32 column = 0; column < getNumColumns(); column++)
  285. {
  286. LLScrollListCell* cell = itemp->getColumn(column);
  287. if (cell && cell->isText())
  288. {
  289. mSearchColumn = column;
  290. break;
  291. }
  292. }
  293. }
  294. }
  295. return llclamp(mSearchColumn, 0, getNumColumns());
  296. }
  297. /*virtual*/
  298. bool LLScrollListCtrl::preProcessChildNode(LLXMLNodePtr child)
  299. {
  300. if (child->hasName("column") || child->hasName("row"))
  301. {
  302. return true; // skip
  303. }
  304. else
  305. {
  306. return false;
  307. }
  308. }
  310. LLScrollListCtrl::~LLScrollListCtrl()
  311. {
  312. std::for_each(mItemList.begin(), mItemList.end(), DeletePointer());
  314. if( gEditMenuHandler == this )
  315. {
  316. gEditMenuHandler = NULL;
  317. }
  318. }
  321. BOOL LLScrollListCtrl::setMaxItemCount(S32 max_count)
  322. {
  323. if (max_count >= getItemCount())
  324. {
  325. mMaxItemCount = max_count;
  326. }
  327. return (max_count == mMaxItemCount);
  328. }
  330. S32 LLScrollListCtrl::isEmpty() const
  331. {
  332. return mItemList.empty();
  333. }
  335. S32 LLScrollListCtrl::getItemCount() const
  336. {
  337. return mItemList.size();
  338. }
  340. // virtual LLScrolListInterface function (was deleteAllItems)
  341. void LLScrollListCtrl::clearRows()
  342. {
  343. std::for_each(mItemList.begin(), mItemList.end(), DeletePointer());
  344. mItemList.clear();
  345. //mItemCount = 0;
  347. // Scroll the bar back up to the top.
  348. mScrollbar->setDocParams(0, 0);
  350. mScrollLines = 0;
  351. mLastSelected = NULL;
  352. updateLayout();
  353. mDirty = FALSE; 
  354. }
  357. LLScrollListItem* LLScrollListCtrl::getFirstSelected() const
  358. {
  359. item_list::const_iterator iter;
  360. for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
  361. {
  362. LLScrollListItem* item  = *iter;
  363. if (item->getSelected())
  364. {
  365. return item;
  366. }
  367. }
  368. return NULL;
  369. }
  371. std::vector<LLScrollListItem*> LLScrollListCtrl::getAllSelected() const
  372. {
  373. std::vector<LLScrollListItem*> ret;
  374. item_list::const_iterator iter;
  375. for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
  376. {
  377. LLScrollListItem* item  = *iter;
  378. if (item->getSelected())
  379. {
  380. ret.push_back(item);
  381. }
  382. }
  383. return ret;
  384. }
  386. S32 LLScrollListCtrl::getFirstSelectedIndex() const
  387. {
  388. S32 CurSelectedIndex = 0;
  390. // make sure sort is up to date before returning an index
  391. updateSort();
  393. item_list::const_iterator iter;
  394. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  395. {
  396. LLScrollListItem* item  = *iter;
  397. if (item->getSelected())
  398. {
  399. return CurSelectedIndex;
  400. }
  401. CurSelectedIndex++;
  402. }
  404. return -1;
  405. }
  407. LLScrollListItem* LLScrollListCtrl::getFirstData() const
  408. {
  409. if (mItemList.size() == 0)
  410. {
  411. return NULL;
  412. }
  413. return mItemList[0];
  414. }
  416. LLScrollListItem* LLScrollListCtrl::getLastData() const
  417. {
  418. if (mItemList.size() == 0)
  419. {
  420. return NULL;
  421. }
  422. return mItemList[mItemList.size() - 1];
  423. }
  425. std::vector<LLScrollListItem*> LLScrollListCtrl::getAllData() const
  426. {
  427. std::vector<LLScrollListItem*> ret;
  428. item_list::const_iterator iter;
  429. for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
  430. {
  431. LLScrollListItem* item  = *iter;
  432. ret.push_back(item);
  433. }
  434. return ret;
  435. }
  437. // returns first matching item
  438. LLScrollListItem* LLScrollListCtrl::getItem(const LLSD& sd) const
  439. {
  440. std::string string_val = sd.asString();
  442. item_list::const_iterator iter;
  443. for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
  444. {
  445. LLScrollListItem* item  = *iter;
  446. // assumes string representation is good enough for comparison
  447. if (item->getValue().asString() == string_val)
  448. {
  449. return item;
  450. }
  451. }
  452. return NULL;
  453. }
  456. void LLScrollListCtrl::reshape( S32 width, S32 height, BOOL called_from_parent )
  457. {
  458. LLUICtrl::reshape( width, height, called_from_parent );
  460. updateLayout();
  461. }
  463. void LLScrollListCtrl::updateLayout()
  464. {
  465. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  466. // reserve room for column headers, if needed
  467. S32 heading_size = (mDisplayColumnHeaders ? mHeadingHeight : 0);
  468. mItemListRect.setOriginAndSize(
  469. mBorderThickness,
  470. mBorderThickness,
  471. getRect().getWidth() - 2 * mBorderThickness,
  472. getRect().getHeight() - (2 * mBorderThickness ) - heading_size );
  474. getChildView("comment_text")->setShape(mItemListRect);
  476. // how many lines of content in a single "page"
  477. S32 page_lines =  getLinesPerPage();
  479. BOOL scrollbar_visible = mLineHeight * getItemCount() > mItemListRect.getHeight();
  480. if (scrollbar_visible)
  481. {
  482. // provide space on the right for scrollbar
  483. mItemListRect.mRight = getRect().getWidth() - mBorderThickness - scrollbar_size;
  484. }
  486. mScrollbar->setOrigin(getRect().getWidth() - mBorderThickness - scrollbar_size, mItemListRect.mBottom);
  487. mScrollbar->reshape(scrollbar_size, mItemListRect.getHeight() + (mDisplayColumnHeaders ? mHeadingHeight : 0));
  488. mScrollbar->setPageSize(page_lines);
  489. mScrollbar->setDocSize( getItemCount() );
  490. mScrollbar->setVisible(scrollbar_visible);
  492. dirtyColumns();
  493. }
  495. // Attempt to size the control to show all items.
  496. // Do not make larger than width or height.
  497. void LLScrollListCtrl::fitContents(S32 max_width, S32 max_height)
  498. {
  499. S32 height = llmin( getRequiredRect().getHeight(), max_height );
  500. if(mPageLines)
  501. height = llmin( mPageLines * mLineHeight + 2*mBorderThickness + (mDisplayColumnHeaders ? mHeadingHeight : 0), height );
  503. S32 width = getRect().getWidth();
  505. reshape( width, height );
  506. }
  509. LLRect LLScrollListCtrl::getRequiredRect()
  510. {
  511. S32 heading_size = (mDisplayColumnHeaders ? mHeadingHeight : 0);
  512. S32 height = (mLineHeight * getItemCount()) 
  513. + (2 * mBorderThickness ) 
  514. + heading_size;
  515. S32 width = getRect().getWidth();
  517. return LLRect(0, height, width, 0);
  518. }
  521. BOOL LLScrollListCtrl::addItem( LLScrollListItem* item, EAddPosition pos, BOOL requires_column )
  522. {
  523. BOOL not_too_big = getItemCount() < mMaxItemCount;
  524. if (not_too_big)
  525. {
  526. switch( pos )
  527. {
  528. case ADD_TOP:
  529. mItemList.push_front(item);
  530. setNeedsSort();
  531. break;
  533. case ADD_SORTED:
  534. {
  535. // sort by column 0, in ascending order
  536. std::vector<sort_column_t> single_sort_column;
  537. single_sort_column.push_back(std::make_pair(0, TRUE));
  539. mItemList.push_back(item);
  540. std::stable_sort(
  541. mItemList.begin(), 
  542. mItemList.end(), 
  543. SortScrollListItem(single_sort_column));
  545. // ADD_SORTED just sorts by first column...
  546. // this might not match user sort criteria, so flag list as being in unsorted state
  547. setNeedsSort();
  548. break;
  549. }
  550. case ADD_BOTTOM:
  551. mItemList.push_back(item);
  552. setNeedsSort();
  553. break;
  555. default:
  556. llassert(0);
  557. mItemList.push_back(item);
  558. setNeedsSort();
  559. break;
  560. }
  562. // create new column on demand
  563. if (mColumns.empty() && requires_column)
  564. {
  565. LLScrollListColumn::Params col_params;
  566. col_params.name =  "default_column";
  567. col_params.header.label = "";
  568. col_params.width.dynamic_width = true;
  569. addColumn(col_params);
  570. }
  572. updateLineHeightInsert(item);
  574. updateLayout();
  575. }
  577. return not_too_big;
  578. }
  580. // NOTE: This is *very* expensive for large lists, especially when we are dirtying the list every frame
  581. //  while receiving a long list of names.
  582. // *TODO: Use bookkeeping to make this an incramental cost with item additions
  583. void LLScrollListCtrl::calcColumnWidths()
  584. {
  585. const S32 HEADING_TEXT_PADDING = 25;
  586. const S32 COLUMN_TEXT_PADDING = 10;
  588. mMaxContentWidth = 0;
  590. S32 max_item_width = 0;
  592. ordered_columns_t::iterator column_itor;
  593. for (column_itor = mColumnsIndexed.begin(); column_itor != mColumnsIndexed.end(); ++column_itor)
  594. {
  595. LLScrollListColumn* column = *column_itor;
  596. if (!column) continue;
  598. // update column width
  599. S32 new_width = column->getWidth();
  600. if (column->mRelWidth >= 0)
  601. {
  602. new_width = (S32)llround(column->mRelWidth*mItemListRect.getWidth());
  603. }
  604. else if (column->mDynamicWidth)
  605. {
  606. new_width = (mItemListRect.getWidth() - mTotalStaticColumnWidth - mTotalColumnPadding) / mNumDynamicWidthColumns;
  607. }
  609. column->setWidth(new_width);
  611. // update max content width for this column, by looking at all items
  612. column->mMaxContentWidth = column->mHeader ? LLFontGL::getFontSansSerifSmall()->getWidth(column->mLabel) + mColumnPadding + HEADING_TEXT_PADDING : 0;
  613. item_list::iterator iter;
  614. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  615. {
  616. LLScrollListCell* cellp = (*iter)->getColumn(column->mIndex);
  617. if (!cellp) continue;
  619. column->mMaxContentWidth = llmax(LLFontGL::getFontSansSerifSmall()->getWidth(cellp->getValue().asString()) + mColumnPadding + COLUMN_TEXT_PADDING, column->mMaxContentWidth);
  620. }
  622. max_item_width += column->mMaxContentWidth;
  623. }
  625. mMaxContentWidth = max_item_width;
  626. }
  628. const S32 SCROLL_LIST_ROW_PAD = 2;
  630. // Line height is the max height of all the cells in all the items.
  631. void LLScrollListCtrl::updateLineHeight()
  632. {
  633. mLineHeight = 0;
  634. item_list::iterator iter;
  635. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  636. {
  637. LLScrollListItem *itemp = *iter;
  638. S32 num_cols = itemp->getNumColumns();
  639. S32 i = 0;
  640. for (const LLScrollListCell* cell = itemp->getColumn(i); i < num_cols; cell = itemp->getColumn(++i))
  641. {
  642. mLineHeight = llmax( mLineHeight, cell->getHeight() + SCROLL_LIST_ROW_PAD );
  643. }
  644. }
  645. }
  647. // when the only change to line height is from an insert, we needn't scan the entire list
  648. void LLScrollListCtrl::updateLineHeightInsert(LLScrollListItem* itemp)
  649. {
  650. S32 num_cols = itemp->getNumColumns();
  651. S32 i = 0;
  652. for (const LLScrollListCell* cell = itemp->getColumn(i); i < num_cols; cell = itemp->getColumn(++i))
  653. {
  654. mLineHeight = llmax( mLineHeight, cell->getHeight() + SCROLL_LIST_ROW_PAD );
  655. }
  656. }
  659. void LLScrollListCtrl::updateColumns()
  660. {
  661. calcColumnWidths();
  663. // update column headers
  664. std::vector<LLScrollListColumn*>::iterator column_ordered_it;
  665. S32 left = mItemListRect.mLeft;
  666. LLScrollColumnHeader* last_header = NULL;
  667. for (column_ordered_it = mColumnsIndexed.begin(); column_ordered_it != mColumnsIndexed.end(); ++column_ordered_it)
  668. {
  669. if ((*column_ordered_it)->getWidth() < 0)
  670. {
  671. // skip hidden columns
  672. continue;
  673. }
  674. LLScrollListColumn* column = *column_ordered_it;
  676. if (column->mHeader)
  677. {
  678. column->mHeader->updateResizeBars();
  680. last_header = column->mHeader;
  681. S32 top = mItemListRect.mTop;
  682. S32 right = left + column->getWidth();
  684. if (column->mIndex != (S32)mColumnsIndexed.size()-1)
  685. {
  686. right += mColumnPadding;
  687. }
  688. right = llmax(left, llmin(mItemListRect.getWidth(), right));
  689. S32 header_width = right - left;
  691. last_header->reshape(header_width, mHeadingHeight);
  692. last_header->translate(
  693. left - last_header->getRect().mLeft,
  694. top - last_header->getRect().mBottom);
  695. last_header->setVisible(mDisplayColumnHeaders && header_width > 0);
  696. left = right;
  697. }
  698. }
  700. // expand last column header we encountered to full list width
  701. if (last_header)
  702. {
  703. S32 new_width = llmax(0, mItemListRect.mRight - last_header->getRect().mLeft);
  704. last_header->reshape(new_width, last_header->getRect().getHeight());
  705. last_header->setVisible(mDisplayColumnHeaders && new_width > 0);
  706. last_header->getColumn()->setWidth(new_width);
  707. }
  709. // propagate column widths to individual cells
  710. item_list::iterator iter;
  711. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  712. {
  713. LLScrollListItem *itemp = *iter;
  714. S32 num_cols = itemp->getNumColumns();
  715. S32 i = 0;
  716. for (LLScrollListCell* cell = itemp->getColumn(i); i < num_cols; cell = itemp->getColumn(++i))
  717. {
  718. if (i >= (S32)mColumnsIndexed.size()) break;
  720. cell->setWidth(mColumnsIndexed[i]->getWidth());
  721. }
  722. }
  724. }
  726. void LLScrollListCtrl::setHeadingHeight(S32 heading_height)
  727. {
  728. mHeadingHeight = heading_height;
  730. updateLayout();
  732. }
  733. void LLScrollListCtrl::setPageLines(S32 new_page_lines)
  734. {
  735. mPageLines  = new_page_lines;
  737. updateLayout();
  738. }
  740. BOOL LLScrollListCtrl::selectFirstItem()
  741. {
  742. BOOL success = FALSE;
  744. // our $%&@#$()^%#$()*^ iterators don't let us check against the first item inside out iteration
  745. BOOL first_item = TRUE;
  747. item_list::iterator iter;
  748. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  749. {
  750. LLScrollListItem *itemp = *iter;
  751. if( first_item && itemp->getEnabled() )
  752. {
  753. if (!itemp->getSelected())
  754. {
  755. selectItem(itemp);
  756. }
  757. success = TRUE;
  758. mOriginalSelection = 0;
  759. }
  760. else
  761. {
  762. deselectItem(itemp);
  763. }
  764. first_item = FALSE;
  765. }
  766. if (mCommitOnSelectionChange)
  767. {
  768. commitIfChanged();
  769. }
  770. return success;
  771. }
  773. // Deselects all other items
  774. // virtual
  775. BOOL LLScrollListCtrl::selectNthItem( S32 target_index )
  776. {
  777. return selectItemRange(target_index, target_index);
  778. }
  780. // virtual
  781. BOOL LLScrollListCtrl::selectItemRange( S32 first_index, S32 last_index )
  782. {
  783. if (mItemList.empty())
  784. {
  785. return FALSE;
  786. }
  788. // make sure sort is up to date
  789. updateSort();
  791. S32 listlen = (S32)mItemList.size();
  792. first_index = llclamp(first_index, 0, listlen-1);
  794. if (last_index < 0)
  795. last_index = listlen-1;
  796. else
  797. last_index = llclamp(last_index, first_index, listlen-1);
  799. BOOL success = FALSE;
  800. S32 index = 0;
  801. for (item_list::iterator iter = mItemList.begin(); iter != mItemList.end(); )
  802. {
  803. LLScrollListItem *itemp = *iter;
  804. if(!itemp)
  805. {
  806. iter = mItemList.erase(iter);
  807. continue ;
  808. }
  810. if( index >= first_index && index <= last_index )
  811. {
  812. if( itemp->getEnabled() )
  813. {
  814. selectItem(itemp, FALSE);
  815. success = TRUE;
  816. }
  817. }
  818. else
  819. {
  820. deselectItem(itemp);
  821. }
  822. index++;
  823. iter++ ;
  824. }
  826. if (mCommitOnSelectionChange)
  827. {
  828. commitIfChanged();
  829. }
  831. mSearchString.clear();
  833. return success;
  834. }
  837. void LLScrollListCtrl::swapWithNext(S32 index)
  838. {
  839. if (index >= ((S32)mItemList.size() - 1))
  840. {
  841. // At end of list, doesn't do anything
  842. return;
  843. }
  844. updateSort();
  845. LLScrollListItem *cur_itemp = mItemList[index];
  846. mItemList[index] = mItemList[index + 1];
  847. mItemList[index + 1] = cur_itemp;
  848. }
  851. void LLScrollListCtrl::swapWithPrevious(S32 index)
  852. {
  853. if (index <= 0)
  854. {
  855. // At beginning of list, don't do anything
  856. }
  858. updateSort();
  859. LLScrollListItem *cur_itemp = mItemList[index];
  860. mItemList[index] = mItemList[index - 1];
  861. mItemList[index - 1] = cur_itemp;
  862. }
  865. void LLScrollListCtrl::deleteSingleItem(S32 target_index)
  866. {
  867. if (target_index < 0 || target_index >= (S32)mItemList.size())
  868. {
  869. return;
  870. }
  872. updateSort();
  874. LLScrollListItem *itemp;
  875. itemp = mItemList[target_index];
  876. if (itemp == mLastSelected)
  877. {
  878. mLastSelected = NULL;
  879. }
  880. delete itemp;
  881. mItemList.erase(mItemList.begin() + target_index);
  882. dirtyColumns();
  883. }
  885. //FIXME: refactor item deletion
  886. void LLScrollListCtrl::deleteItems(const LLSD& sd)
  887. {
  888. item_list::iterator iter;
  889. for (iter = mItemList.begin(); iter < mItemList.end(); )
  890. {
  891. LLScrollListItem* itemp = *iter;
  892. if (itemp->getValue().asString() == sd.asString())
  893. {
  894. if (itemp == mLastSelected)
  895. {
  896. mLastSelected = NULL;
  897. }
  898. delete itemp;
  899. iter = mItemList.erase(iter);
  900. }
  901. else
  902. {
  903. iter++;
  904. }
  905. }
  907. dirtyColumns();
  908. }
  910. void LLScrollListCtrl::deleteSelectedItems()
  911. {
  912. item_list::iterator iter;
  913. for (iter = mItemList.begin(); iter < mItemList.end(); )
  914. {
  915. LLScrollListItem* itemp = *iter;
  916. if (itemp->getSelected())
  917. {
  918. delete itemp;
  919. iter = mItemList.erase(iter);
  920. }
  921. else
  922. {
  923. iter++;
  924. }
  925. }
  926. mLastSelected = NULL;
  927. dirtyColumns();
  928. }
  930. void LLScrollListCtrl::clearHighlightedItems()
  931. {
  932. for (item_list::iterator iter = mItemList.begin(); iter != mItemList.end(); ++iter)
  933. {
  934. (*iter)->setHighlighted(false);
  935. }
  936. }
  938. void LLScrollListCtrl::mouseOverHighlightNthItem(S32 target_index)
  939. {
  940. if (mHighlightedItem != target_index)
  941. {
  942. mHighlightedItem = target_index;
  943. }
  944. }
  946. S32 LLScrollListCtrl::selectMultiple( std::vector<LLUUID> ids )
  947. {
  948. item_list::iterator iter;
  949. S32 count = 0;
  950. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  951. {
  952. LLScrollListItem* item = *iter;
  953. std::vector<LLUUID>::iterator iditr;
  954. for(iditr = ids.begin(); iditr != ids.end(); ++iditr)
  955. {
  956. if (item->getEnabled() && (item->getUUID() == (*iditr)))
  957. {
  958. selectItem(item,FALSE);
  959. ++count;
  960. break;
  961. }
  962. }
  963. if(ids.end() != iditr) ids.erase(iditr);
  964. }
  966. if (mCommitOnSelectionChange)
  967. {
  968. commitIfChanged();
  969. }
  970. return count;
  971. }
  973. S32 LLScrollListCtrl::getItemIndex( LLScrollListItem* target_item ) const
  974. {
  975. updateSort();
  977. S32 index = 0;
  978. item_list::const_iterator iter;
  979. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  980. {
  981. LLScrollListItem *itemp = *iter;
  982. if (target_item == itemp)
  983. {
  984. return index;
  985. }
  986. index++;
  987. }
  988. return -1;
  989. }
  991. S32 LLScrollListCtrl::getItemIndex( const LLUUID& target_id ) const
  992. {
  993. updateSort();
  995. S32 index = 0;
  996. item_list::const_iterator iter;
  997. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  998. {
  999. LLScrollListItem *itemp = *iter;
  1000. if (target_id == itemp->getUUID())
  1001. {
  1002. return index;
  1003. }
  1004. index++;
  1005. }
  1006. return -1;
  1007. }
  1009. void LLScrollListCtrl::selectPrevItem( BOOL extend_selection)
  1010. {
  1011. LLScrollListItem* prev_item = NULL;
  1013. if (!getFirstSelected())
  1014. {
  1015. // select last item
  1016. selectNthItem(getItemCount() - 1);
  1017. }
  1018. else
  1019. {
  1020. updateSort();
  1022. item_list::iterator iter;
  1023. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1024. {
  1025. LLScrollListItem* cur_item = *iter;
  1027. if (cur_item->getSelected())
  1028. {
  1029. if (prev_item)
  1030. {
  1031. selectItem(prev_item, !extend_selection);
  1032. }
  1033. else
  1034. {
  1035. reportInvalidInput();
  1036. }
  1037. break;
  1038. }
  1040. // don't allow navigation to disabled elements
  1041. prev_item = cur_item->getEnabled() ? cur_item : prev_item;
  1042. }
  1043. }
  1045. if ((mCommitOnSelectionChange || mCommitOnKeyboardMovement))
  1046. {
  1047. commitIfChanged();
  1048. }
  1050. mSearchString.clear();
  1051. }
  1054. void LLScrollListCtrl::selectNextItem( BOOL extend_selection)
  1055. {
  1056. LLScrollListItem* next_item = NULL;
  1058. if (!getFirstSelected())
  1059. {
  1060. selectFirstItem();
  1061. }
  1062. else
  1063. {
  1064. updateSort();
  1066. item_list::reverse_iterator iter;
  1067. for (iter = mItemList.rbegin(); iter != mItemList.rend(); iter++)
  1068. {
  1069. LLScrollListItem* cur_item = *iter;
  1071. if (cur_item->getSelected())
  1072. {
  1073. if (next_item)
  1074. {
  1075. selectItem(next_item, !extend_selection);
  1076. }
  1077. else
  1078. {
  1079. reportInvalidInput();
  1080. }
  1081. break;
  1082. }
  1084. // don't allow navigation to disabled items
  1085. next_item = cur_item->getEnabled() ? cur_item : next_item;
  1086. }
  1087. }
  1089. if (mCommitOnKeyboardMovement)
  1090. {
  1091. onCommit();
  1092. }
  1094. mSearchString.clear();
  1095. }
  1099. void LLScrollListCtrl::deselectAllItems(BOOL no_commit_on_change)
  1100. {
  1101. item_list::iterator iter;
  1102. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1103. {
  1104. LLScrollListItem* item = *iter;
  1105. deselectItem(item);
  1106. }
  1108. if (mCommitOnSelectionChange && !no_commit_on_change)
  1109. {
  1110. commitIfChanged();
  1111. }
  1112. }
  1114. ///////////////////////////////////////////////////////////////////////////////////////////////////
  1115. // Use this to add comment text such as "Searching", which ignores column settings of list
  1117. void LLScrollListCtrl::setCommentText(const std::string& comment_text)
  1118. {
  1119. getChild<LLTextBox>("comment_text")->setValue(comment_text);
  1120. }
  1122. LLScrollListItem* LLScrollListCtrl::addSeparator(EAddPosition pos)
  1123. {
  1124. LLScrollListItem::Params separator_params;
  1125. separator_params.enabled(false);
  1126. LLScrollListCell::Params column_params;
  1127. column_params.type = "icon";
  1128. column_params.value = "menu_separator";
  1129. column_params.color = LLColor4(0.f, 0.f, 0.f, 0.7f);
  1130. column_params.font_halign = LLFontGL::HCENTER;
  1131. separator_params.columns.add(column_params);
  1132. return addRow( separator_params, pos );
  1133. }
  1135. // Selects first enabled item of the given name.
  1136. // Returns false if item not found.
  1137. // Calls getItemByLabel in order to combine functionality
  1138. BOOL LLScrollListCtrl::selectItemByLabel(const std::string& label, BOOL case_sensitive)
  1139. {
  1140. deselectAllItems(TRUE);  // ensure that no stale items are selected, even if we don't find a match
  1141. LLScrollListItem* item = getItemByLabel(label, case_sensitive);
  1143. bool found = NULL != item;
  1144. if(found)
  1145. {
  1146. selectItem(item);
  1147. }
  1149. if (mCommitOnSelectionChange)
  1150. {
  1151. commitIfChanged();
  1152. }
  1154. return found;
  1155. }
  1157. LLScrollListItem* LLScrollListCtrl::getItemByLabel(const std::string& label, BOOL case_sensitive, S32 column)
  1158. {
  1159. if (label.empty())  //RN: assume no empty items
  1160. {
  1161. return NULL;
  1162. }
  1164. std::string target_text = label;
  1165. if (!case_sensitive)
  1166. {
  1167. LLStringUtil::toLower(target_text);
  1168. }
  1170. item_list::iterator iter;
  1171. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1172. {
  1173. LLScrollListItem* item = *iter;
  1174. std::string item_text = item->getColumn(column)->getValue().asString(); // Only select enabled items with matching names
  1175. if (!case_sensitive)
  1176. {
  1177. LLStringUtil::toLower(item_text);
  1178. }
  1179. if(item_text == target_text)
  1180. {
  1181. return item;
  1182. }
  1183. }
  1184. return NULL;
  1185. }
  1188. BOOL LLScrollListCtrl::selectItemByPrefix(const std::string& target, BOOL case_sensitive)
  1189. {
  1190. return selectItemByPrefix(utf8str_to_wstring(target), case_sensitive);
  1191. }
  1193. // Selects first enabled item that has a name where the name's first part matched the target string.
  1194. // Returns false if item not found.
  1195. BOOL LLScrollListCtrl::selectItemByPrefix(const LLWString& target, BOOL case_sensitive)
  1196. {
  1197. BOOL found = FALSE;
  1199. LLWString target_trimmed( target );
  1200. S32 target_len = target_trimmed.size();
  1202. if( 0 == target_len )
  1203. {
  1204. // Is "" a valid choice?
  1205. item_list::iterator iter;
  1206. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1207. {
  1208. LLScrollListItem* item = *iter;
  1209. // Only select enabled items with matching names
  1210. LLScrollListCell* cellp = item->getColumn(getSearchColumn());
  1211. BOOL select = cellp ? item->getEnabled() && ('' == cellp->getValue().asString()[0]) : FALSE;
  1212. if (select)
  1213. {
  1214. selectItem(item);
  1215. found = TRUE;
  1216. break;
  1217. }
  1218. }
  1219. }
  1220. else
  1221. {
  1222. if (!case_sensitive)
  1223. {
  1224. // do comparisons in lower case
  1225. LLWStringUtil::toLower(target_trimmed);
  1226. }
  1228. for (item_list::iterator iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1229. {
  1230. LLScrollListItem* item = *iter;
  1232. // Only select enabled items with matching names
  1233. LLScrollListCell* cellp = item->getColumn(getSearchColumn());
  1234. if (!cellp)
  1235. {
  1236. continue;
  1237. }
  1238. LLWString item_label = utf8str_to_wstring(cellp->getValue().asString());
  1239. if (!case_sensitive)
  1240. {
  1241. LLWStringUtil::toLower(item_label);
  1242. }
  1243. // remove extraneous whitespace from searchable label
  1244. LLWString trimmed_label = item_label;
  1245. LLWStringUtil::trim(trimmed_label);
  1247. BOOL select = item->getEnabled() && trimmed_label.compare(0, target_trimmed.size(), target_trimmed) == 0;
  1249. if (select)
  1250. {
  1251. // find offset of matching text (might have leading whitespace)
  1252. S32 offset = item_label.find(target_trimmed);
  1253. cellp->highlightText(offset, target_trimmed.size());
  1254. selectItem(item);
  1255. found = TRUE;
  1256. break;
  1257. }
  1258. }
  1259. }
  1261. if (mCommitOnSelectionChange)
  1262. {
  1263. commitIfChanged();
  1264. }
  1266. return found;
  1267. }
  1269. const std::string LLScrollListCtrl::getSelectedItemLabel(S32 column) const
  1270. {
  1271. LLScrollListItem* item;
  1273. item = getFirstSelected();
  1274. if (item)
  1275. {
  1276. return item->getColumn(column)->getValue().asString();
  1277. }
  1279. return LLStringUtil::null;
  1280. }
  1282. ///////////////////////////////////////////////////////////////////////////////////////////////////
  1283. // "StringUUID" interface: use this when you're creating a list that contains non-unique strings each of which
  1284. // has an associated, unique UUID, and only one of which can be selected at a time.
  1286. LLScrollListItem* LLScrollListCtrl::addStringUUIDItem(const std::string& item_text, const LLUUID& id, EAddPosition pos, BOOL enabled)
  1287. {
  1288. if (getItemCount() < mMaxItemCount)
  1289. {
  1290. LLScrollListItem::Params item_p;
  1291. item_p.enabled(enabled);
  1292. item_p.value(id);
  1293. item_p.columns.add().value(item_text).type("text");
  1295. return addRow( item_p, pos );
  1296. }
  1297. return NULL;
  1298. }
  1300. // Select the line or lines that match this UUID
  1301. BOOL LLScrollListCtrl::selectByID( const LLUUID& id )
  1302. {
  1303. return selectByValue( LLSD(id) );
  1304. }
  1306. BOOL LLScrollListCtrl::setSelectedByValue(const LLSD& value, BOOL selected)
  1307. {
  1308. BOOL found = FALSE;
  1310. if (selected && !mAllowMultipleSelection) deselectAllItems(TRUE);
  1312. item_list::iterator iter;
  1313. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1314. {
  1315. LLScrollListItem* item = *iter;
  1316. if (item->getEnabled() && (item->getValue().asString() == value.asString()))
  1317. {
  1318. if (selected)
  1319. {
  1320. selectItem(item);
  1321. }
  1322. else
  1323. {
  1324. deselectItem(item);
  1325. }
  1326. found = TRUE;
  1327. break;
  1328. }
  1329. }
  1331. if (mCommitOnSelectionChange)
  1332. {
  1333. commitIfChanged();
  1334. }
  1336. return found;
  1337. }
  1339. BOOL LLScrollListCtrl::isSelected(const LLSD& value) const 
  1340. {
  1341. item_list::const_iterator iter;
  1342. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1343. {
  1344. LLScrollListItem* item = *iter;
  1345. if (item->getValue().asString() == value.asString())
  1346. {
  1347. return item->getSelected();
  1348. }
  1349. }
  1350. return FALSE;
  1351. }
  1353. LLUUID LLScrollListCtrl::getStringUUIDSelectedItem() const
  1354. {
  1355. LLScrollListItem* item = getFirstSelected();
  1357. if (item)
  1358. {
  1359. return item->getUUID();
  1360. }
  1362. return LLUUID::null;
  1363. }
  1365. LLSD LLScrollListCtrl::getSelectedValue()
  1366. {
  1367. LLScrollListItem* item = getFirstSelected();
  1369. if (item)
  1370. {
  1371. return item->getValue();
  1372. }
  1373. else
  1374. {
  1375. return LLSD();
  1376. }
  1377. }
  1379. void LLScrollListCtrl::drawItems()
  1380. {
  1381. S32 x = mItemListRect.mLeft;
  1382. S32 y = mItemListRect.mTop - mLineHeight;
  1384. // allow for partial line at bottom
  1385. S32 num_page_lines = getLinesPerPage();
  1387. LLRect item_rect;
  1389. LLGLSUIDefault gls_ui;
  1391. F32 alpha = getDrawContext().mAlpha;
  1393. {
  1394. LLLocalClipRect clip(mItemListRect);
  1396. S32 cur_y = y;
  1398. S32 line = 0;
  1399. S32 max_columns = 0;
  1401. LLColor4 highlight_color = LLColor4::white;
  1402. static LLUICachedControl<F32> type_ahead_timeout ("TypeAheadTimeout", 0);
  1403. highlight_color.mV[VALPHA] = clamp_rescale(mSearchTimer.getElapsedTimeF32(), type_ahead_timeout * 0.7f, type_ahead_timeout, 0.4f, 0.f);
  1405. item_list::iterator iter;
  1406. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1407. {
  1408. LLScrollListItem* item = *iter;
  1410. item_rect.setOriginAndSize( 
  1411. x, 
  1412. cur_y, 
  1413. mItemListRect.getWidth(),
  1414. mLineHeight );
  1415. item->setRect(item_rect);
  1417. //llinfos << item_rect.getWidth() << llendl;
  1419. max_columns = llmax(max_columns, item->getNumColumns());
  1421. LLColor4 fg_color;
  1422. LLColor4 bg_color(LLColor4::transparent);
  1424. if( mScrollLines <= line && line < mScrollLines + num_page_lines )
  1425. {
  1426. fg_color = (item->getEnabled() ? mFgUnselectedColor.get() : mFgDisabledColor.get());
  1427. if( item->getSelected() && mCanSelect)
  1428. {
  1429. if(item->getHighlighted()) // if it's highlighted, average the colors
  1430. {
  1431. bg_color = lerp(mBgSelectedColor.get(), mHighlightedColor.get(), 0.5f);
  1432. }
  1433. else // otherwise just select-highlight it
  1434. {
  1435. bg_color = mBgSelectedColor.get();
  1436. }
  1438. fg_color = (item->getEnabled() ? mFgSelectedColor.get() : mFgDisabledColor.get());
  1439. }
  1440. else if (mHighlightedItem == line && mCanSelect)
  1441. {
  1442. if(item->getHighlighted()) // if it's highlighted, average the colors
  1443. {
  1444. bg_color = lerp(mHoveredColor.get(), mHighlightedColor.get(), 0.5f);
  1445. }
  1446. else // otherwise just hover-highlight it
  1447. {
  1448. bg_color = mHoveredColor.get();
  1449. }
  1450. }
  1451. else if (item->getHighlighted())
  1452. {
  1453. bg_color = mHighlightedColor.get();
  1454. }
  1455. else 
  1456. {
  1457. if (mDrawStripes && (line % 2 == 0) && (max_columns > 1))
  1458. {
  1459. bg_color = mBgStripeColor.get();
  1460. }
  1461. }
  1463. if (!item->getEnabled())
  1464. {
  1465. bg_color = mBgReadOnlyColor.get();
  1466. }
  1468. item->draw(item_rect, fg_color % alpha, bg_color% alpha, highlight_color % alpha, mColumnPadding);
  1470. cur_y -= mLineHeight;
  1471. }
  1472. line++;
  1473. }
  1474. }
  1475. }
  1478. void LLScrollListCtrl::draw()
  1479. {
  1480. LLLocalClipRect clip(getLocalRect());
  1482. // if user specifies sort, make sure it is maintained
  1483. updateSort();
  1485. if (mNeedsScroll)
  1486. {
  1487. scrollToShowSelected();
  1488. mNeedsScroll = FALSE;
  1489. }
  1490. LLRect background(0, getRect().getHeight(), getRect().getWidth(), 0);
  1491. // Draw background
  1492. if (mBackgroundVisible)
  1493. {
  1494. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1495. gl_rect_2d(background, getEnabled() ? mBgWriteableColor.get() : mBgReadOnlyColor.get() );
  1496. }
  1498. if (mColumnsDirty)
  1499. {
  1500. updateColumns();
  1501. mColumnsDirty = FALSE;
  1502. }
  1504. getChildView("comment_text")->setVisible(mItemList.empty());
  1506. drawItems();
  1508. if (mBorder)
  1509. {
  1510. mBorder->setKeyboardFocusHighlight(hasFocus());
  1511. }
  1513. LLUICtrl::draw();
  1514. }
  1516. void LLScrollListCtrl::setEnabled(BOOL enabled)
  1517. {
  1518. mCanSelect = enabled;
  1519. setTabStop(enabled);
  1520. mScrollbar->setTabStop(!enabled && mScrollbar->getPageSize() < mScrollbar->getDocSize());
  1521. }
  1523. BOOL LLScrollListCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
  1524. {
  1525. BOOL handled = FALSE;
  1526. // Pretend the mouse is over the scrollbar
  1527. handled = mScrollbar->handleScrollWheel( 0, 0, clicks );
  1528. return handled;
  1529. }
  1531. // *NOTE: Requires a valid row_index and column_index
  1532. LLRect LLScrollListCtrl::getCellRect(S32 row_index, S32 column_index)
  1533. {
  1534. LLRect cell_rect;
  1535. S32 rect_left = getColumnOffsetFromIndex(column_index) + mItemListRect.mLeft;
  1536. S32 rect_bottom = getRowOffsetFromIndex(row_index);
  1537. LLScrollListColumn* columnp = getColumn(column_index);
  1538. cell_rect.setOriginAndSize(rect_left, rect_bottom,
  1539. /*rect_left + */columnp->getWidth(), mLineHeight);
  1540. return cell_rect;
  1541. }
  1543. BOOL LLScrollListCtrl::handleToolTip(S32 x, S32 y, MASK mask)
  1544. {
  1545. S32 column_index = getColumnIndexFromOffset(x);
  1546. LLScrollListColumn* columnp = getColumn(column_index);
  1548. if (columnp == NULL) return FALSE;
  1550. BOOL handled = FALSE;
  1551. // show tooltip for full name of hovered item if it has been truncated
  1552. LLScrollListItem* hit_item = hitItem(x, y);
  1553. if (hit_item)
  1554. {
  1555. LLScrollListCell* hit_cell = hit_item->getColumn(column_index);
  1556. if (!hit_cell) return FALSE;
  1557. if (hit_cell 
  1558. && hit_cell->isText()
  1559. && hit_cell->needsToolTip())
  1560. {
  1561. S32 row_index = getItemIndex(hit_item);
  1562. LLRect cell_rect = getCellRect(row_index, column_index);
  1563. // Convert rect local to screen coordinates
  1564. LLRect sticky_rect;
  1565. localRectToScreen(cell_rect, &sticky_rect);
  1567. // display tooltip exactly over original cell, in same font
  1568. LLToolTipMgr::instance().show(LLToolTip::Params()
  1569. .message(hit_cell->getToolTip())
  1570. .font(LLFontGL::getFontSansSerifSmall())
  1571. .pos(LLCoordGL(sticky_rect.mLeft - 5, sticky_rect.mTop + 6))
  1572. .delay_time(0.2f)
  1573. .sticky_rect(sticky_rect));
  1574. }
  1575. handled = TRUE;
  1576. }
  1578. // otherwise, look for a tooltip associated with this column
  1579. LLScrollColumnHeader* headerp = columnp->mHeader;
  1580. if (headerp && !handled)
  1581. {
  1582. handled = headerp->handleToolTip(x, y, mask);
  1583. }
  1585. return handled;
  1586. }
  1588. BOOL LLScrollListCtrl::selectItemAt(S32 x, S32 y, MASK mask)
  1589. {
  1590. if (!mCanSelect) return FALSE;
  1592. BOOL selection_changed = FALSE;
  1594. LLScrollListItem* hit_item = hitItem(x, y);
  1596. if( hit_item )
  1597. {
  1598. if( mAllowMultipleSelection )
  1599. {
  1600. if (mask & MASK_SHIFT)
  1601. {
  1602. if (mLastSelected == NULL)
  1603. {
  1604. selectItem(hit_item);
  1605. }
  1606. else
  1607. {
  1608. // Select everthing between mLastSelected and hit_item
  1609. bool selecting = false;
  1610. item_list::iterator itor;
  1611. // If we multiselect backwards, we'll stomp on mLastSelected,
  1612. // meaning that we never stop selecting until hitting max or
  1613. // the end of the list.
  1614. LLScrollListItem* lastSelected = mLastSelected;
  1615. for (itor = mItemList.begin(); itor != mItemList.end(); ++itor)
  1616. {
  1617. if(mMaxSelectable > 0 && getAllSelected().size() >= mMaxSelectable)
  1618. {
  1619. if(mOnMaximumSelectCallback)
  1620. {
  1621. mOnMaximumSelectCallback();
  1622. }
  1623. break;
  1624. }
  1625. LLScrollListItem *item = *itor;
  1626.                         if (item == hit_item || item == lastSelected)
  1627. {
  1628. selectItem(item, FALSE);
  1629. selecting = !selecting;
  1630. if (hit_item == lastSelected)
  1631. {
  1632. // stop selecting now, since we just clicked on our last selected item
  1633. selecting = FALSE;
  1634. }
  1635. }
  1636. if (selecting)
  1637. {
  1638. selectItem(item, FALSE);
  1639. }
  1640. }
  1641. }
  1642. }
  1643. else if (mask & MASK_CONTROL)
  1644. {
  1645. if (hit_item->getSelected())
  1646. {
  1647. deselectItem(hit_item);
  1648. }
  1649. else
  1650. {
  1651. if(!(mMaxSelectable > 0 && getAllSelected().size() >= mMaxSelectable))
  1652. {
  1653. selectItem(hit_item, FALSE);
  1654. }
  1655. else
  1656. {
  1657. if(mOnMaximumSelectCallback)
  1658. {
  1659. mOnMaximumSelectCallback();
  1660. }
  1661. }
  1662. }
  1663. }
  1664. else
  1665. {
  1666. deselectAllItems(TRUE);
  1667. selectItem(hit_item);
  1668. }
  1669. }
  1670. else
  1671. {
  1672. selectItem(hit_item);
  1673. }
  1675. selection_changed = mSelectionChanged;
  1676. if (mCommitOnSelectionChange)
  1677. {
  1678. commitIfChanged();
  1679. }
  1681. // clear search string on mouse operations
  1682. mSearchString.clear();
  1683. }
  1684. else
  1685. {
  1686. //mLastSelected = NULL;
  1687. //deselectAllItems(TRUE);
  1688. }
  1690. return selection_changed;
  1691. }
  1694. BOOL LLScrollListCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
  1695. {
  1696. BOOL handled = childrenHandleMouseDown(x, y, mask) != NULL;
  1698. if( !handled )
  1699. {
  1700. // set keyboard focus first, in case click action wants to move focus elsewhere
  1701. setFocus(TRUE);
  1703. // clear selection changed flag because user is starting a selection operation
  1704. mSelectionChanged = FALSE;
  1706. handleClick(x, y, mask);
  1707. }
  1709. return TRUE;
  1710. }
  1712. BOOL LLScrollListCtrl::handleMouseUp(S32 x, S32 y, MASK mask)
  1713. {
  1714. if (hasMouseCapture())
  1715. {
  1716. // release mouse capture immediately so 
  1717. // scroll to show selected logic will work
  1718. gFocusMgr.setMouseCapture(NULL);
  1719. if(mask == MASK_NONE)
  1720. {
  1721. selectItemAt(x, y, mask);
  1722. mNeedsScroll = TRUE;
  1723. }
  1724. }
  1726. // always commit when mouse operation is completed inside list
  1727. if (mItemListRect.pointInRect(x,y))
  1728. {
  1729. mDirty |= mSelectionChanged;
  1730. mSelectionChanged = FALSE;
  1731. onCommit();
  1732. }
  1734. return LLUICtrl::handleMouseUp(x, y, mask);
  1735. }
  1737. // virtual
  1738. BOOL LLScrollListCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
  1739. {
  1740. LLScrollListItem *item = hitItem(x, y);
  1741. if (item)
  1742. {
  1743. // check to see if we have a UUID for this row
  1744. std::string id = item->getValue().asString();
  1745. LLUUID uuid(id);
  1746. if (! uuid.isNull() && mContextMenuType != MENU_NONE)
  1747. {
  1748. // set up the callbacks for all of the avatar/group menu items
  1749. // (N.B. callbacks don't take const refs as id is local scope)
  1750. bool is_group = (mContextMenuType == MENU_GROUP);
  1751. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  1752. registrar.add("Url.Execute", boost::bind(&LLScrollListCtrl::showNameDetails, id, is_group));
  1753. registrar.add("Url.CopyLabel", boost::bind(&LLScrollListCtrl::copyNameToClipboard, id, is_group));
  1754. registrar.add("Url.CopyUrl", boost::bind(&LLScrollListCtrl::copySLURLToClipboard, id, is_group));
  1756. // create the context menu from the XUI file and display it
  1757. std::string menu_name = is_group ? "menu_url_group.xml" : "menu_url_agent.xml";
  1758. delete mPopupMenu;
  1759. mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>(
  1760. menu_name, LLMenuGL::sMenuContainer, LLMenuHolderGL::child_registry_t::instance());
  1761. if (mPopupMenu)
  1762. {
  1763. mPopupMenu->show(x, y);
  1764. LLMenuGL::showPopup(this, mPopupMenu, x, y);
  1765. return TRUE;
  1766. }
  1767. }
  1768. }
  1769. return FALSE;
  1770. }
  1772. void LLScrollListCtrl::showNameDetails(std::string id, bool is_group)
  1773. {
  1774. // show the resident's profile or the group profile
  1775. std::string sltype = is_group ? "group" : "agent";
  1776. std::string slurl = "secondlife:///app/" + sltype + "/" + id + "/about";
  1777. LLUrlAction::clickAction(slurl);
  1778. }
  1780. void LLScrollListCtrl::copyNameToClipboard(std::string id, bool is_group)
  1781. {
  1782. // copy the name of the avatar or group to the clipboard
  1783. std::string name;
  1784. if (is_group)
  1785. {
  1786. gCacheName->getGroupName(LLUUID(id), name);
  1787. }
  1788. else
  1789. {
  1790. gCacheName->getFullName(LLUUID(id), name);
  1791. }
  1792. LLUrlAction::copyURLToClipboard(name);
  1793. }
  1795. void LLScrollListCtrl::copySLURLToClipboard(std::string id, bool is_group)
  1796. {
  1797. // copy a SLURL for the avatar or group to the clipboard
  1798. std::string sltype = is_group ? "group" : "agent";
  1799. std::string slurl = "secondlife:///app/" + sltype + "/" + id + "/about";
  1800. LLUrlAction::copyURLToClipboard(slurl);
  1801. }
  1803. BOOL LLScrollListCtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
  1804. {
  1805. //BOOL handled = FALSE;
  1806. BOOL handled = handleClick(x, y, mask);
  1808. if (!handled)
  1809. {
  1810. // Offer the click to the children, even if we aren't enabled
  1811. // so the scroll bars will work.
  1812. if (NULL == LLView::childrenHandleDoubleClick(x, y, mask))
  1813. {
  1814. // Run the callback only if an item is being double-clicked.
  1815. if( mCanSelect && hitItem(x, y) && mOnDoubleClickCallback )
  1816. {
  1817. mOnDoubleClickCallback();
  1818. }
  1819. }
  1820. }
  1822. return TRUE;
  1823. }
  1825. BOOL LLScrollListCtrl::handleClick(S32 x, S32 y, MASK mask)
  1826. {
  1827. // which row was clicked on?
  1828. LLScrollListItem* hit_item = hitItem(x, y);
  1829. if (!hit_item) return FALSE;
  1831. // get appropriate cell from that row
  1832. S32 column_index = getColumnIndexFromOffset(x);
  1833. LLScrollListCell* hit_cell = hit_item->getColumn(column_index);
  1834. if (!hit_cell) return FALSE;
  1836. // if cell handled click directly (i.e. clicked on an embedded checkbox)
  1837. if (hit_cell->handleClick())
  1838. {
  1839. // if item not currently selected, select it
  1840. if (!hit_item->getSelected())
  1841. {
  1842. selectItemAt(x, y, mask);
  1843. gFocusMgr.setMouseCapture(this);
  1844. mNeedsScroll = TRUE;
  1845. }
  1847. // propagate state of cell to rest of selected column
  1848. {
  1849. // propagate value of this cell to other selected items
  1850. // and commit the respective widgets
  1851. LLSD item_value = hit_cell->getValue();
  1852. for (item_list::iterator iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1853. {
  1854. LLScrollListItem* item = *iter;
  1855. if (item->getSelected())
  1856. {
  1857. LLScrollListCell* cellp = item->getColumn(column_index);
  1858. cellp->setValue(item_value);
  1859. cellp->onCommit();
  1860. }
  1861. }
  1862. //FIXME: find a better way to signal cell changes
  1863. onCommit();
  1864. }
  1865. // eat click (e.g. do not trigger double click callback)
  1866. return TRUE;
  1867. }
  1868. else
  1869. {
  1870. // treat this as a normal single item selection
  1871. selectItemAt(x, y, mask);
  1872. gFocusMgr.setMouseCapture(this);
  1873. mNeedsScroll = TRUE;
  1874. // do not eat click (allow double click callback)
  1875. return FALSE;
  1876. }
  1877. }
  1879. LLScrollListItem* LLScrollListCtrl::hitItem( S32 x, S32 y )
  1880. {
  1881. // Excludes disabled items.
  1882. LLScrollListItem* hit_item = NULL;
  1884. updateSort();
  1886. LLRect item_rect;
  1887. item_rect.setLeftTopAndSize( 
  1888. mItemListRect.mLeft,
  1889. mItemListRect.mTop,
  1890. mItemListRect.getWidth(),
  1891. mLineHeight );
  1893. // allow for partial line at bottom
  1894. S32 num_page_lines = getLinesPerPage();
  1896. S32 line = 0;
  1897. item_list::iterator iter;
  1898. for(iter = mItemList.begin(); iter != mItemList.end(); iter++)
  1899. {
  1900. LLScrollListItem* item  = *iter;
  1901. if( mScrollLines <= line && line < mScrollLines + num_page_lines )
  1902. {
  1903. if( item->getEnabled() && item_rect.pointInRect( x, y ) )
  1904. {
  1905. hit_item = item;
  1906. break;
  1907. }
  1909. item_rect.translate(0, -mLineHeight);
  1910. }
  1911. line++;
  1912. }
  1914. return hit_item;
  1915. }
  1917. S32 LLScrollListCtrl::getColumnIndexFromOffset(S32 x)
  1918. {
  1919. // which column did we hit?
  1920. S32 left = 0;
  1921. S32 right = 0;
  1922. S32 width = 0;
  1923. S32 column_index = 0;
  1925. ordered_columns_t::const_iterator iter = mColumnsIndexed.begin();
  1926. ordered_columns_t::const_iterator end = mColumnsIndexed.end();
  1927. for ( ; iter != end; ++iter)
  1928. {
  1929. width = (*iter)->getWidth() + mColumnPadding;
  1930. right += width;
  1931. if (left <= x && x < right )
  1932. {
  1933. break;
  1934. }
  1936. // set left for next column as right of current column
  1937. left = right;
  1938. column_index++;
  1939. }
  1941. return llclamp(column_index, 0, getNumColumns() - 1);
  1942. }
  1945. S32 LLScrollListCtrl::getColumnOffsetFromIndex(S32 index)
  1946. {
  1947. S32 column_offset = 0;
  1948. ordered_columns_t::const_iterator iter = mColumnsIndexed.begin();
  1949. ordered_columns_t::const_iterator end = mColumnsIndexed.end();
  1950. for ( ; iter != end; ++iter)
  1951. {
  1952. if (index-- <= 0)
  1953. {
  1954. return column_offset;
  1955. }
  1956. column_offset += (*iter)->getWidth() + mColumnPadding;
  1957. }
  1959. // when running off the end, return the rightmost pixel
  1960. return mItemListRect.mRight;
  1961. }
  1963. S32 LLScrollListCtrl::getRowOffsetFromIndex(S32 index)
  1964. {
  1965. S32 row_bottom = (mItemListRect.mTop - ((index - mScrollLines + 1) * mLineHeight) );
  1966. return row_bottom;
  1967. }
  1970. BOOL LLScrollListCtrl::handleHover(S32 x,S32 y,MASK mask)
  1971. {
  1972. BOOL handled = FALSE;
  1974. if (hasMouseCapture())
  1975. {
  1976. if(mask == MASK_NONE)
  1977. {
  1978. selectItemAt(x, y, mask);
  1979. mNeedsScroll = TRUE;
  1980. }
  1981. }
  1982. else 
  1983. if (mCanSelect)
  1984. {
  1985. LLScrollListItem* item = hitItem(x, y);
  1986. if (item)
  1987. {
  1988. mouseOverHighlightNthItem(getItemIndex(item));
  1989. }
  1990. else
  1991. {
  1992. mouseOverHighlightNthItem(-1);
  1993. }
  1994. }
  1996. handled = LLUICtrl::handleHover( x, y, mask );
  1998. return handled;
  1999. }
  2001. void LLScrollListCtrl::onMouseLeave(S32 x, S32 y, MASK mask)
  2002. {
  2003. // clear mouse highlight
  2004. mouseOverHighlightNthItem(-1);
  2005. }
  2007. BOOL LLScrollListCtrl::handleKeyHere(KEY key,MASK mask )
  2008. {
  2009. BOOL handled = FALSE;
  2011. // not called from parent means we have keyboard focus or a child does
  2012. if (mCanSelect) 
  2013. {
  2014. // Ignore capslock
  2015. mask = mask;
  2017. if (mask == MASK_NONE)
  2018. {
  2019. switch(key)
  2020. {
  2021. case KEY_UP:
  2022. if (mAllowKeyboardMovement || hasFocus())
  2023. {
  2024. // commit implicit in call
  2025. selectPrevItem(FALSE);
  2026. mNeedsScroll = TRUE;
  2027. handled = TRUE;
  2028. }
  2029. break;
  2030. case KEY_DOWN:
  2031. if (mAllowKeyboardMovement || hasFocus())
  2032. {
  2033. // commit implicit in call
  2034. selectNextItem(FALSE);
  2035. mNeedsScroll = TRUE;
  2036. handled = TRUE;
  2037. }
  2038. break;
  2039. case KEY_PAGE_UP:
  2040. if (mAllowKeyboardMovement || hasFocus())
  2041. {
  2042. selectNthItem(getFirstSelectedIndex() - (mScrollbar->getPageSize() - 1));
  2043. mNeedsScroll = TRUE;
  2044. if (mCommitOnKeyboardMovement
  2045. && !mCommitOnSelectionChange) 
  2046. {
  2047. onCommit();
  2048. }
  2049. handled = TRUE;
  2050. }
  2051. break;
  2052. case KEY_PAGE_DOWN:
  2053. if (mAllowKeyboardMovement || hasFocus())
  2054. {
  2055. selectNthItem(getFirstSelectedIndex() + (mScrollbar->getPageSize() - 1));
  2056. mNeedsScroll = TRUE;
  2057. if (mCommitOnKeyboardMovement
  2058. && !mCommitOnSelectionChange) 
  2059. {
  2060. onCommit();
  2061. }
  2062. handled = TRUE;
  2063. }
  2064. break;
  2065. case KEY_HOME:
  2066. if (mAllowKeyboardMovement || hasFocus())
  2067. {
  2068. selectFirstItem();
  2069. mNeedsScroll = TRUE;
  2070. if (mCommitOnKeyboardMovement
  2071. && !mCommitOnSelectionChange) 
  2072. {
  2073. onCommit();
  2074. }
  2075. handled = TRUE;
  2076. }
  2077. break;
  2078. case KEY_END:
  2079. if (mAllowKeyboardMovement || hasFocus())
  2080. {
  2081. selectNthItem(getItemCount() - 1);
  2082. mNeedsScroll = TRUE;
  2083. if (mCommitOnKeyboardMovement
  2084. && !mCommitOnSelectionChange) 
  2085. {
  2086. onCommit();
  2087. }
  2088. handled = TRUE;
  2089. }
  2090. break;
  2091. case KEY_RETURN:
  2092. // JC - Special case: Only claim to have handled it
  2093. // if we're the special non-commit-on-move
  2094. // type. AND we are visible
  2095.    if (!mCommitOnKeyboardMovement && mask == MASK_NONE)
  2096. {
  2097. onCommit();
  2098. mSearchString.clear();
  2099. handled = TRUE;
  2100. }
  2101. break;
  2102. case KEY_BACKSPACE:
  2103. mSearchTimer.reset();
  2104. if (mSearchString.size())
  2105. {
  2106. mSearchString.erase(mSearchString.size() - 1, 1);
  2107. }
  2108. if (mSearchString.empty())
  2109. {
  2110. if (getFirstSelected())
  2111. {
  2112. LLScrollListCell* cellp = getFirstSelected()->getColumn(getSearchColumn());
  2113. if (cellp)
  2114. {
  2115. cellp->highlightText(0, 0);
  2116. }
  2117. }
  2118. }
  2119. else if (selectItemByPrefix(wstring_to_utf8str(mSearchString), FALSE))
  2120. {
  2121. mNeedsScroll = TRUE;
  2122. // update search string only on successful match
  2123. mSearchTimer.reset();
  2125. if (mCommitOnKeyboardMovement
  2126. && !mCommitOnSelectionChange) 
  2127. {
  2128. onCommit();
  2129. }
  2130. }
  2131. break;
  2132. default:
  2133. break;
  2134. }
  2135. }
  2136. // TODO: multiple: shift-up, shift-down, shift-home, shift-end, select all
  2137. }
  2139. return handled;
  2140. }
  2142. BOOL LLScrollListCtrl::handleUnicodeCharHere(llwchar uni_char)
  2143. {
  2144. if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
  2145. {
  2146. return FALSE;
  2147. }
  2149. // perform incremental search based on keyboard input
  2150. static LLUICachedControl<F32> type_ahead_timeout ("TypeAheadTimeout", 0);
  2151. if (mSearchTimer.getElapsedTimeF32() > type_ahead_timeout)
  2152. {
  2153. mSearchString.clear();
  2154. }
  2156. // type ahead search is case insensitive
  2157. uni_char = LLStringOps::toLower((llwchar)uni_char);
  2159. if (selectItemByPrefix(wstring_to_utf8str(mSearchString + (llwchar)uni_char), FALSE))
  2160. {
  2161. // update search string only on successful match
  2162. mNeedsScroll = TRUE;
  2163. mSearchString += uni_char;
  2164. mSearchTimer.reset();
  2166. if (mCommitOnKeyboardMovement
  2167. && !mCommitOnSelectionChange) 
  2168. {
  2169. onCommit();
  2170. }
  2171. }
  2172. // handle iterating over same starting character
  2173. else if (isRepeatedChars(mSearchString + (llwchar)uni_char) && !mItemList.empty())
  2174. {
  2175. // start from last selected item, in case we previously had a successful match against
  2176. // duplicated characters ('AA' matches 'Aaron')
  2177. item_list::iterator start_iter = mItemList.begin();
  2178. S32 first_selected = getFirstSelectedIndex();
  2180. // if we have a selection (> -1) then point iterator at the selected item
  2181. if (first_selected > 0)
  2182. {
  2183. // point iterator to first selected item
  2184. start_iter += first_selected;
  2185. }
  2187. // start search at first item after current selection
  2188. item_list::iterator iter = start_iter;
  2189. ++iter;
  2190. if (iter == mItemList.end())
  2191. {
  2192. iter = mItemList.begin();
  2193. }
  2195. // loop around once, back to previous selection
  2196. while(iter != start_iter)
  2197. {
  2198. LLScrollListItem* item = *iter;
  2200. LLScrollListCell* cellp = item->getColumn(getSearchColumn());
  2201. if (cellp)
  2202. {
  2203. // Only select enabled items with matching first characters
  2204. LLWString item_label = utf8str_to_wstring(cellp->getValue().asString());
  2205. if (item->getEnabled() && LLStringOps::toLower(item_label[0]) == uni_char)
  2206. {
  2207. selectItem(item);
  2208. mNeedsScroll = TRUE;
  2209. cellp->highlightText(0, 1);
  2210. mSearchTimer.reset();
  2212. if (mCommitOnKeyboardMovement
  2213. && !mCommitOnSelectionChange) 
  2214. {
  2215. onCommit();
  2216. }
  2218. break;
  2219. }
  2220. }
  2222. ++iter;
  2223. if (iter == mItemList.end())
  2224. {
  2225. iter = mItemList.begin();
  2226. }
  2227. }
  2228. }
  2230. return TRUE;
  2231. }
  2234. void LLScrollListCtrl::reportInvalidInput()
  2235. {
  2236. make_ui_sound("UISndBadKeystroke");
  2237. }
  2239. BOOL LLScrollListCtrl::isRepeatedChars(const LLWString& string) const
  2240. {
  2241. if (string.empty())
  2242. {
  2243. return FALSE;
  2244. }
  2246. llwchar first_char = string[0];
  2248. for (U32 i = 0; i < string.size(); i++)
  2249. {
  2250. if (string[i] != first_char)
  2251. {
  2252. return FALSE;
  2253. }
  2254. }
  2256. return TRUE;
  2257. }
  2259. void LLScrollListCtrl::selectItem(LLScrollListItem* itemp, BOOL select_single_item)
  2260. {
  2261. if (!itemp) return;
  2263. if (!itemp->getSelected())
  2264. {
  2265. if (mLastSelected)
  2266. {
  2267. LLScrollListCell* cellp = mLastSelected->getColumn(getSearchColumn());
  2268. if (cellp)
  2269. {
  2270. cellp->highlightText(0, 0);
  2271. }
  2272. }
  2273. if (select_single_item)
  2274. {
  2275. deselectAllItems(TRUE);
  2276. }
  2277. itemp->setSelected(TRUE);
  2278. mLastSelected = itemp;
  2279. mSelectionChanged = TRUE;
  2280. }
  2281. }
  2283. void LLScrollListCtrl::deselectItem(LLScrollListItem* itemp)
  2284. {
  2285. if (!itemp) return;
  2287. if (itemp->getSelected())
  2288. {
  2289. if (mLastSelected == itemp)
  2290. {
  2291. mLastSelected = NULL;
  2292. }
  2294. itemp->setSelected(FALSE);
  2295. LLScrollListCell* cellp = itemp->getColumn(getSearchColumn());
  2296. if (cellp)
  2297. {
  2298. cellp->highlightText(0, 0);
  2299. }
  2300. mSelectionChanged = TRUE;
  2301. }
  2302. }
  2304. void LLScrollListCtrl::commitIfChanged()
  2305. {
  2306. if (mSelectionChanged)
  2307. {
  2308. mDirty = TRUE;
  2309. mSelectionChanged = FALSE;
  2310. onCommit();
  2311. }
  2312. }
  2314. struct SameSortColumn
  2315. {
  2316. SameSortColumn(S32 column) : mColumn(column) {}
  2317. S32 mColumn;
  2319. bool operator()(std::pair<S32, BOOL> sort_column) { return sort_column.first == mColumn; }
  2320. };
  2322. BOOL LLScrollListCtrl::setSort(S32 column_idx, BOOL ascending)
  2323. {
  2324. LLScrollListColumn* sort_column = getColumn(column_idx);
  2325. if (!sort_column) return FALSE;
  2327. sort_column->mSortDirection = ascending ? LLScrollListColumn::ASCENDING : LLScrollListColumn::DESCENDING;
  2329. sort_column_t new_sort_column(column_idx, ascending);
  2331. setNeedsSort();
  2333. if (mSortColumns.empty())
  2334. {
  2335. mSortColumns.push_back(new_sort_column);
  2336. return TRUE;
  2337. }
  2338. else
  2339. {
  2340. // grab current sort column
  2341. sort_column_t cur_sort_column = mSortColumns.back();
  2343. // remove any existing sort criterion referencing this column
  2344. // and add the new one
  2345. mSortColumns.erase(remove_if(mSortColumns.begin(), mSortColumns.end(), SameSortColumn(column_idx)), mSortColumns.end()); 
  2346. mSortColumns.push_back(new_sort_column);
  2348. // did the sort criteria change?
  2349. return (cur_sort_column != new_sort_column);
  2350. }
  2351. }
  2353. S32 LLScrollListCtrl::getLinesPerPage()
  2354. {
  2355. //if mPageLines is NOT provided display all item
  2356. if(mPageLines)
  2357. {
  2358. return mPageLines;
  2359. }
  2360. else
  2361. {
  2362. return mLineHeight ? mItemListRect.getHeight() / mLineHeight : getItemCount();
  2363. }
  2364. }
  2367. // Called by scrollbar
  2368. void LLScrollListCtrl::onScrollChange( S32 new_pos, LLScrollbar* scrollbar )
  2369. {
  2370. mScrollLines = new_pos;
  2371. }
  2374. void LLScrollListCtrl::sortByColumn(const std::string& name, BOOL ascending)
  2375. {
  2376. std::map<std::string, LLScrollListColumn>::iterator itor = mColumns.find(name);
  2377. if (itor != mColumns.end())
  2378. {
  2379. sortByColumnIndex((*itor).second.mIndex, ascending);
  2380. }
  2381. }
  2383. // First column is column 0
  2384. void  LLScrollListCtrl::sortByColumnIndex(U32 column, BOOL ascending)
  2385. {
  2386. setSort(column, ascending);
  2387. updateSort();
  2388. }
  2390. void LLScrollListCtrl::updateSort() const
  2391. {
  2392. if (hasSortOrder() && !isSorted())
  2393. {
  2394. // do stable sort to preserve any previous sorts
  2395. std::stable_sort(
  2396. mItemList.begin(), 
  2397. mItemList.end(), 
  2398. SortScrollListItem(mSortColumns));
  2400. mSorted = true;
  2401. }
  2402. }
  2404. // for one-shot sorts, does not save sort column/order
  2405. void LLScrollListCtrl::sortOnce(S32 column, BOOL ascending)
  2406. {
  2407. std::vector<std::pair<S32, BOOL> > sort_column;
  2408. sort_column.push_back(std::make_pair(column, ascending));
  2410. // do stable sort to preserve any previous sorts
  2411. std::stable_sort(
  2412. mItemList.begin(), 
  2413. mItemList.end(), 
  2414. SortScrollListItem(sort_column));
  2415. }
  2417. void LLScrollListCtrl::dirtyColumns() 
  2418. { 
  2419. mColumnsDirty = TRUE; 
  2421. // need to keep mColumnsIndexed up to date
  2422. // just in case someone indexes into it immediately
  2423. mColumnsIndexed.resize(mColumns.size());
  2425. std::map<std::string, LLScrollListColumn>::iterator column_itor;
  2426. for (column_itor = mColumns.begin(); column_itor != mColumns.end(); ++column_itor)
  2427. {
  2428. LLScrollListColumn *column = &column_itor->second;
  2429. mColumnsIndexed[column_itor->second.mIndex] = column;
  2430. }
  2431. }
  2434. S32 LLScrollListCtrl::getScrollPos() const
  2435. {
  2436. return mScrollbar->getDocPos();
  2437. }
  2440. void LLScrollListCtrl::setScrollPos( S32 pos )
  2441. {
  2442. mScrollbar->setDocPos( pos );
  2444. onScrollChange(mScrollbar->getDocPos(), mScrollbar);
  2445. }
  2448. void LLScrollListCtrl::scrollToShowSelected()
  2449. {
  2450. // don't scroll automatically when capturing mouse input
  2451. // as that will change what is currently under the mouse cursor
  2452. if (hasMouseCapture())
  2453. {
  2454. return;
  2455. }
  2457. updateSort();
  2459. S32 index = getFirstSelectedIndex();
  2460. if (index < 0)
  2461. {
  2462. return;
  2463. }
  2465. LLScrollListItem* item = mItemList[index];
  2466. if (!item)
  2467. {
  2468. // I don't THINK this should ever happen.
  2469. return;
  2470. }
  2472. S32 lowest = mScrollLines;
  2473. S32 page_lines = getLinesPerPage();
  2474. S32 highest = mScrollLines + page_lines;
  2476. if (index < lowest)
  2477. {
  2478. // need to scroll to show item
  2479. setScrollPos(index);
  2480. }
  2481. else if (highest <= index)
  2482. {
  2483. setScrollPos(index - page_lines + 1);
  2484. }
  2485. }
  2487. void LLScrollListCtrl::updateStaticColumnWidth(LLScrollListColumn* col, S32 new_width)
  2488. {
  2489. mTotalStaticColumnWidth += llmax(0, new_width) - llmax(0, col->getWidth());
  2490. }
  2492. // LLEditMenuHandler functions
  2494. // virtual
  2495. void LLScrollListCtrl::copy()
  2496. {
  2497. std::string buffer;
  2499. std::vector<LLScrollListItem*> items = getAllSelected();
  2500. std::vector<LLScrollListItem*>::iterator itor;
  2501. for (itor = items.begin(); itor != items.end(); ++itor)
  2502. {
  2503. buffer += (*itor)->getContentsCSV() + "n";
  2504. }
  2505. gClipboard.copyFromSubstring(utf8str_to_wstring(buffer), 0, buffer.length());
  2506. }
  2508. // virtual
  2509. BOOL LLScrollListCtrl::canCopy() const
  2510. {
  2511. return (getFirstSelected() != NULL);
  2512. }
  2514. // virtual
  2515. void LLScrollListCtrl::cut()
  2516. {
  2517. copy();
  2518. doDelete();
  2519. }
  2521. // virtual
  2522. BOOL LLScrollListCtrl::canCut() const
  2523. {
  2524. return canCopy() && canDoDelete();
  2525. }
  2527. // virtual
  2528. void LLScrollListCtrl::selectAll()
  2529. {
  2530. // Deselects all other items
  2531. item_list::iterator iter;
  2532. for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
  2533. {
  2534. LLScrollListItem *itemp = *iter;
  2535. if( itemp->getEnabled() )
  2536. {
  2537. selectItem(itemp, FALSE);
  2538. }
  2539. }
  2541. if (mCommitOnSelectionChange)
  2542. {
  2543. commitIfChanged();
  2544. }
  2545. }
  2547. // virtual
  2548. BOOL LLScrollListCtrl::canSelectAll() const
  2549. {
  2550. return getCanSelect() && mAllowMultipleSelection && !(mMaxSelectable > 0 && mItemList.size() > mMaxSelectable);
  2551. }
  2553. // virtual
  2554. void LLScrollListCtrl::deselect()
  2555. {
  2556. deselectAllItems();
  2557. }
  2559. // virtual
  2560. BOOL LLScrollListCtrl::canDeselect() const
  2561. {
  2562. return getCanSelect();
  2563. }
  2565. void LLScrollListCtrl::addColumn(const LLSD& column, EAddPosition pos)
  2566. {
  2567. LLScrollListColumn::Params p;
  2568. LLParamSDParser::instance().readSD(column, p);
  2569. addColumn(p, pos);
  2570. }
  2572. void LLScrollListCtrl::addColumn(const LLScrollListColumn::Params& column_params, EAddPosition pos)
  2573. {
  2574. if (!column_params.validateBlock()) return;
  2576. std::string name = column_params.name;
  2577. // if no column name provided, just use ordinal as name
  2578. if (name.empty())
  2579. {
  2580. name = llformat("%d", mColumnsIndexed.size());
  2581. }
  2583. if (mColumns.find(name) == mColumns.end())
  2584. {
  2585. // Add column
  2586. mColumns[name] = LLScrollListColumn(column_params, this);
  2587. LLScrollListColumn* new_column = &mColumns[name];
  2588. new_column->mIndex = mColumns.size()-1;
  2590. // Add button
  2591. if (new_column->getWidth() > 0 || new_column->mRelWidth > 0 || new_column->mDynamicWidth)
  2592. {
  2593. if (getNumColumns() > 0)
  2594. {
  2595. mTotalColumnPadding += mColumnPadding;
  2596. }
  2597. if (new_column->mRelWidth >= 0)
  2598. {
  2599. new_column->setWidth((S32)llround(new_column->mRelWidth*mItemListRect.getWidth()));
  2600. }
  2601. else if(new_column->mDynamicWidth)
  2602. {
  2603. mNumDynamicWidthColumns++;
  2604. new_column->setWidth((mItemListRect.getWidth() - mTotalStaticColumnWidth - mTotalColumnPadding) / mNumDynamicWidthColumns);
  2605. }
  2606. S32 top = mItemListRect.mTop;
  2608. S32 left = mItemListRect.mLeft;
  2609. for (std::map<std::string, LLScrollListColumn>::iterator itor = mColumns.begin(); 
  2610. itor != mColumns.end(); 
  2611. ++itor)
  2612. {
  2613. if (itor->second.mIndex < new_column->mIndex &&
  2614. itor->second.getWidth() > 0)
  2615. {
  2616. left += itor->second.getWidth() + mColumnPadding;
  2617. }
  2618. }
  2620. S32 right = left+new_column->getWidth();
  2621. if (new_column->mIndex != (S32)mColumns.size()-1)
  2622. {
  2623. right += mColumnPadding;
  2624. }
  2626. LLRect temp_rect = LLRect(left,top+mHeadingHeight,right,top);
  2628. LLScrollColumnHeader::Params params(LLUICtrlFactory::getDefaultParams<LLScrollColumnHeader>());
  2629. params.name = "btn_" + name;
  2630. params.rect = temp_rect;
  2631. params.column = new_column;
  2632. params.tool_tip = column_params.tool_tip;
  2633. params.tab_stop = false;
  2634. params.visible = mDisplayColumnHeaders;
  2636. if(column_params.header.image.isProvided())
  2637. {
  2638. params.image_selected = column_params.header.image;
  2639. params.image_unselected = column_params.header.image;
  2640. }
  2641. else
  2642. {
  2643. params.label = column_params.header.label;
  2644. }
  2646. new_column->mHeader = LLUICtrlFactory::create<LLScrollColumnHeader>(params); 
  2647. addChild(new_column->mHeader);
  2649. sendChildToFront(mScrollbar);
  2650. }
  2651. }
  2653. dirtyColumns();
  2654. }
  2656. // static
  2657. void LLScrollListCtrl::onClickColumn(void *userdata)
  2658. {
  2659. LLScrollListColumn *info = (LLScrollListColumn*)userdata;
  2660. if (!info) return;
  2662. LLScrollListCtrl *parent = info->mParentCtrl;
  2663. if (!parent) return;
  2665. S32 column_index = info->mIndex;
  2667. LLScrollListColumn* column = parent->mColumnsIndexed[info->mIndex];
  2668. bool ascending = column->mSortDirection == LLScrollListColumn::ASCENDING;
  2669. if (column->mSortingColumn != column->mName
  2670. && parent->mColumns.find(column->mSortingColumn) != parent->mColumns.end())
  2671. {
  2672. LLScrollListColumn& info_redir = parent->mColumns[column->mSortingColumn];
  2673. column_index = info_redir.mIndex;
  2674. }
  2676. // if this column is the primary sort key, reverse the direction
  2677. sort_column_t cur_sort_column;
  2678. if (!parent->mSortColumns.empty() && parent->mSortColumns.back().first == column_index)
  2679. {
  2680. ascending = !parent->mSortColumns.back().second;
  2681. }
  2683. parent->sortByColumnIndex(column_index, ascending);
  2685. if (parent->mOnSortChangedCallback)
  2686. {
  2687. parent->mOnSortChangedCallback();
  2688. }
  2689. }
  2691. std::string LLScrollListCtrl::getSortColumnName()
  2692. {
  2693. LLScrollListColumn* column = mSortColumns.empty() ? NULL : mColumnsIndexed[mSortColumns.back().first];
  2695. if (column) return column->mName;
  2696. else return "";
  2697. }
  2699. BOOL LLScrollListCtrl::hasSortOrder() const
  2700. {
  2701. return !mSortColumns.empty();
  2702. }
  2704. void LLScrollListCtrl::clearColumns()
  2705. {
  2706. std::map<std::string, LLScrollListColumn>::iterator itor;
  2707. for (itor = mColumns.begin(); itor != mColumns.end(); ++itor)
  2708. {
  2709. LLScrollColumnHeader *header = itor->second.mHeader;
  2710. if (header)
  2711. {
  2712. removeChild(header);
  2713. delete header;
  2714. }
  2715. }
  2716. mColumns.clear();
  2717. mSortColumns.clear();
  2718. mTotalStaticColumnWidth = 0;
  2719. mTotalColumnPadding = 0;
  2720. }
  2722. void LLScrollListCtrl::setColumnLabel(const std::string& column, const std::string& label)
  2723. {
  2724. LLScrollListColumn* columnp = getColumn(column);
  2725. if (columnp)
  2726. {
  2727. columnp->mLabel = label;
  2728. if (columnp->mHeader)
  2729. {
  2730. columnp->mHeader->setLabel(label);
  2731. }
  2732. }
  2733. }
  2735. LLScrollListColumn* LLScrollListCtrl::getColumn(S32 index)
  2736. {
  2737. if (index < 0 || index >= (S32)mColumnsIndexed.size())
  2738. {
  2739. return NULL;
  2740. }
  2741. return mColumnsIndexed[index];
  2742. }
  2744. LLScrollListColumn* LLScrollListCtrl::getColumn(const std::string& name)
  2745. {
  2746. column_map_t::iterator column_itor = mColumns.find(name);
  2747. if (column_itor != mColumns.end()) 
  2748. {
  2749. return &column_itor->second;
  2750. }
  2751. return NULL;
  2752. }
  2755. LLScrollListItem* LLScrollListCtrl::addElement(const LLSD& element, EAddPosition pos, void* userdata)
  2756. {
  2757. LLScrollListItem::Params item_params;
  2758. LLParamSDParser::instance().readSD(element, item_params);
  2759. item_params.userdata = userdata;
  2760. return addRow(item_params, pos);
  2761. }
  2763. LLScrollListItem* LLScrollListCtrl::addRow(const LLScrollListItem::Params& item_p, EAddPosition pos)
  2764. {
  2765. LLScrollListItem *new_item = new LLScrollListItem(item_p);
  2766. return addRow(new_item, item_p, pos);
  2767. }
  2769. LLScrollListItem* LLScrollListCtrl::addRow(LLScrollListItem *new_item, const LLScrollListItem::Params& item_p, EAddPosition pos)
  2770. {
  2771. if (!item_p.validateBlock() || !new_item) return NULL;
  2772. new_item->setNumColumns(mColumns.size());
  2774. // Add any columns we don't already have
  2775. S32 col_index = 0;
  2777. for(LLInitParam::ParamIterator<LLScrollListCell::Params>::const_iterator itor = item_p.columns().begin();
  2778. itor != item_p.columns().end();
  2779. ++itor)
  2780. {
  2781. LLScrollListCell::Params cell_p = *itor;
  2782. std::string column = cell_p.column;
  2784. // empty columns strings index by ordinal
  2785. if (column.empty())
  2786. {
  2787. column = llformat("%d", col_index);
  2788. }
  2790. LLScrollListColumn* columnp = getColumn(column);
  2792. // create new column on demand
  2793. if (!columnp)
  2794. {
  2795. LLScrollListColumn::Params new_column;
  2796. new_column.name = column;
  2797. new_column.header.label = column;
  2799. // if width supplied for column, use it, otherwise 
  2800. // use adaptive width
  2801. if (cell_p.width.isProvided())
  2802. {
  2803. new_column.width.pixel_width = cell_p.width;
  2804. }
  2805. addColumn(new_column);
  2806. columnp = &mColumns[column];
  2807. new_item->setNumColumns(mColumns.size());
  2808. }
  2810. S32 index = columnp->mIndex;
  2811. cell_p.width.setIfNotProvided(columnp->getWidth());
  2813. LLScrollListCell* cell = LLScrollListCell::create(cell_p);
  2815. if (cell)
  2816. {
  2817. new_item->setColumn(index, cell);
  2818. if (columnp->mHeader 
  2819. && cell->isText() 
  2820. && !cell->getValue().asString().empty())
  2821. {
  2822. columnp->mHeader->setHasResizableElement(TRUE);
  2823. }
  2824. }
  2826. col_index++;
  2827. }
  2829. if (item_p.columns().empty())
  2830. {
  2831. if (mColumns.empty())
  2832. {
  2833. LLScrollListColumn::Params new_column;
  2834. new_column.name = "0";
  2836. addColumn(new_column);
  2837. new_item->setNumColumns(mColumns.size());
  2838. }
  2840. LLScrollListCell* cell = LLScrollListCell::create(LLScrollListCell::Params().value(item_p.value));
  2841. if (cell)
  2842. {
  2843. LLScrollListColumn* columnp = &(mColumns.begin()->second);
  2845. new_item->setColumn(0, cell);
  2846. if (columnp->mHeader 
  2847. && cell->isText() 
  2848. && !cell->getValue().asString().empty())
  2849. {
  2850. columnp->mHeader->setHasResizableElement(TRUE);
  2851. }
  2852. }
  2853. }
  2855. // add dummy cells for missing columns
  2856. for (column_map_t::iterator column_it = mColumns.begin(); column_it != mColumns.end(); ++column_it)
  2857. {
  2858. S32 column_idx = column_it->second.mIndex;
  2859. if (new_item->getColumn(column_idx) == NULL)
  2860. {
  2861. LLScrollListColumn* column_ptr = &column_it->second;
  2862. LLScrollListCell::Params cell_p;
  2863. cell_p.width = column_ptr->getWidth();
  2865. new_item->setColumn(column_idx, new LLScrollListSpacer(cell_p));
  2866. }
  2867. }
  2869. addItem(new_item, pos);
  2870. return new_item;
  2871. }
  2873. LLScrollListItem* LLScrollListCtrl::addSimpleElement(const std::string& value, EAddPosition pos, const LLSD& id)
  2874. {
  2875. LLSD entry_id = id;
  2877. if (id.isUndefined())
  2878. {
  2879. entry_id = value;
  2880. }
  2882. LLScrollListItem::Params item_params;
  2883. item_params.value(entry_id);
  2884. item_params.columns.add()
  2885. .value(value)
  2886. .font(LLFontGL::getFontSansSerifSmall());
  2888. return addRow(item_params, pos);
  2889. }
  2891. void LLScrollListCtrl::setValue(const LLSD& value )
  2892. {
  2893. LLSD::array_const_iterator itor;
  2894. for (itor = value.beginArray(); itor != value.endArray(); ++itor)
  2895. {
  2896. addElement(*itor);
  2897. }
  2898. }
  2900. LLSD LLScrollListCtrl::getValue() const
  2901. {
  2902. LLScrollListItem *item = getFirstSelected();
  2903. if (!item) return LLSD();
  2904. return item->getValue();
  2905. }
  2907. BOOL LLScrollListCtrl::operateOnSelection(EOperation op)
  2908. {
  2909. if (op == OP_DELETE)
  2910. {
  2911. deleteSelectedItems();
  2912. return TRUE;
  2913. }
  2914. else if (op == OP_DESELECT)
  2915. {
  2916. deselectAllItems();
  2917. }
  2918. return FALSE;
  2919. }
  2921. BOOL LLScrollListCtrl::operateOnAll(EOperation op)
  2922. {
  2923. if (op == OP_DELETE)
  2924. {
  2925. clearRows();
  2926. return TRUE;
  2927. }
  2928. else if (op == OP_DESELECT)
  2929. {
  2930. deselectAllItems();
  2931. }
  2932. else if (op == OP_SELECT)
  2933. {
  2934. selectAll();
  2935. }
  2936. return FALSE;
  2937. }
  2938. //virtual 
  2939. void LLScrollListCtrl::setFocus(BOOL b)
  2940. {
  2941. mSearchString.clear();
  2942. // for tabbing into pristine scroll lists (Finder)
  2943. if (!getFirstSelected())
  2944. {
  2945. selectFirstItem();
  2946. //onCommit(); // SJB: selectFirstItem() will call onCommit() if appropriate
  2947. }
  2948. LLUICtrl::setFocus(b);
  2949. }
  2952. // virtual 
  2953. BOOL LLScrollListCtrl::isDirty() const
  2954. {
  2955. BOOL grubby = mDirty;
  2956. if ( !mAllowMultipleSelection )
  2957. {
  2958. grubby = (mOriginalSelection != getFirstSelectedIndex());
  2959. }
  2960. return grubby;
  2961. }
  2963. // Clear dirty state
  2964. void LLScrollListCtrl::resetDirty()
  2965. {
  2966. mDirty = FALSE;
  2967. mOriginalSelection = getFirstSelectedIndex();
  2968. }
  2971. //virtual
  2972. void LLScrollListCtrl::onFocusReceived()
  2973. {
  2974. // forget latent selection changes when getting focus
  2975. mSelectionChanged = FALSE;
  2976. LLUICtrl::onFocusReceived();
  2977. }
  2979. //virtual 
  2980. void LLScrollListCtrl::onFocusLost()
  2981. {
  2982. if (hasMouseCapture())
  2983. {
  2984. gFocusMgr.setMouseCapture(NULL);
  2985. }
  2986. LLUICtrl::onFocusLost();
  2987. }