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

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

游戏引擎

开发平台：

C++ Builder

llcombobox.cpp：源码内容
  1. /** 
  2.  * @file llcombobox.cpp
  3.  * @brief LLComboBox base class
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. // A control that displays the name of the chosen item, which when
  34. // clicked shows a scrolling box of options.
  36. #include "linden_common.h"
  38. // file includes
  39. #include "llcombobox.h"
  41. // common includes
  42. #include "llstring.h"
  44. // newview includes
  45. #include "llbutton.h"
  46. #include "llkeyboard.h"
  47. #include "llscrolllistctrl.h"
  48. #include "llwindow.h"
  49. #include "llfloater.h"
  50. #include "llscrollbar.h"
  51. #include "llscrolllistcell.h"
  52. #include "llscrolllistitem.h"
  53. #include "llcontrol.h"
  54. #include "llfocusmgr.h"
  55. #include "lllineeditor.h"
  56. #include "v2math.h"
  57. #include "lluictrlfactory.h"
  58. #include "lltooltip.h"
  60. // Globals
  61. S32 LLCOMBOBOX_HEIGHT = 0;
  62. S32 LLCOMBOBOX_WIDTH = 0;
  63. S32 MAX_COMBO_WIDTH = 500;
  65. static LLDefaultChildRegistry::Register<LLComboBox> register_combo_box("combo_box");
  67. void LLComboBox::PreferredPositionValues::declareValues()
  68. {
  69. declare("above", ABOVE);
  70. declare("below", BELOW);
  71. }
  73. LLComboBox::ItemParams::ItemParams()
  74. : label("label")
  75. {
  76. }
  79. LLComboBox::Params::Params()
  80. : allow_text_entry("allow_text_entry", false),
  81. allow_new_values("allow_new_values", false),
  82. show_text_as_tentative("show_text_as_tentative", true),
  83. max_chars("max_chars", 20),
  84. list_position("list_position", BELOW),
  85. items("item"),
  86. combo_button("combo_button"),
  87. combo_list("combo_list"),
  88. combo_editor("combo_editor"),
  89. drop_down_button("drop_down_button")
  90. {
  91. addSynonym(items, "combo_item");
  92. }
  95. LLComboBox::LLComboBox(const LLComboBox::Params& p)
  96. : LLUICtrl(p),
  97. mTextEntry(NULL),
  98. mTextEntryTentative(p.show_text_as_tentative),
  99. mHasAutocompletedText(false),
  100. mAllowTextEntry(p.allow_text_entry),
  101. mAllowNewValues(p.allow_new_values),
  102. mMaxChars(p.max_chars),
  103. mPrearrangeCallback(p.prearrange_callback()),
  104. mTextEntryCallback(p.text_entry_callback()),
  105. mListPosition(p.list_position),
  106. mLastSelectedIndex(-1),
  107. mLabel(p.label)
  108. {
  109. // Text label button
  111. LLButton::Params button_params = (mAllowTextEntry ? p.combo_button : p.drop_down_button);
  112. button_params.mouse_down_callback.function(
  113. boost::bind(&LLComboBox::onButtonMouseDown, this));
  114. button_params.follows.flags(FOLLOWS_LEFT|FOLLOWS_BOTTOM|FOLLOWS_RIGHT);
  115. button_params.rect(p.rect);
  117. if(mAllowTextEntry)
  118. {
  119. button_params.pad_right(2);
  120. }
  122. mArrowImage = button_params.image_unselected;
  124. mButton = LLUICtrlFactory::create<LLButton>(button_params);
  127. if(mAllowTextEntry)
  128. {
  129. //redo to compensate for button hack that leaves space for a character
  130. //unless it is a "minimal combobox"(drop down)
  131. mButton->setRightHPad(2);
  132. }
  133. addChild(mButton);
  135. LLScrollListCtrl::Params params = p.combo_list;
  136. params.name("ComboBox");
  137. params.commit_callback.function(boost::bind(&LLComboBox::onItemSelected, this, _2));
  138. params.visible(false);
  139. params.commit_on_keyboard_movement(false);
  141. mList = LLUICtrlFactory::create<LLScrollListCtrl>(params);
  142. addChild(mList);
  144. // Mouse-down on button will transfer mouse focus to the list
  145. // Grab the mouse-up event and make sure the button state is correct
  146. mList->setMouseUpCallback(boost::bind(&LLComboBox::onListMouseUp, this));
  148. for (LLInitParam::ParamIterator<ItemParams>::const_iterator it = p.items().begin();
  149. it != p.items().end();
  150. ++it)
  151. {
  152. LLScrollListItem::Params item_params = *it;
  153. if (it->label.isProvided())
  154. {
  155. item_params.columns.add().value(it->label());
  156. }
  158. mList->addRow(item_params);
  159. }
  161. createLineEditor(p);
  163. setTopLostCallback(boost::bind(&LLComboBox::hideList, this));
  164. }
  166. void LLComboBox::initFromParams(const LLComboBox::Params& p)
  167. {
  168. LLUICtrl::initFromParams(p);
  170. if (!acceptsTextInput() && mLabel.empty())
  171. {
  172. selectFirstItem();
  173. }
  174. }
  176. // virtual
  177. BOOL LLComboBox::postBuild()
  178. {
  179. if (mControlVariable)
  180. {
  181. setValue(mControlVariable->getValue()); // selects the appropriate item
  182. }
  183. return TRUE;
  184. }
  187. LLComboBox::~LLComboBox()
  188. {
  189. // children automatically deleted, including mMenu, mButton
  190. }
  193. void LLComboBox::clear()
  194. { 
  195. if (mTextEntry)
  196. {
  197. mTextEntry->setText(LLStringUtil::null);
  198. }
  199. mButton->setLabelSelected(LLStringUtil::null);
  200. mButton->setLabelUnselected(LLStringUtil::null);
  201. mList->deselectAllItems();
  202. mLastSelectedIndex = -1;
  203. }
  205. void LLComboBox::onCommit()
  206. {
  207. if (mAllowTextEntry && getCurrentIndex() != -1)
  208. {
  209. // we have selected an existing item, blitz the manual text entry with
  210. // the properly capitalized item
  211. mTextEntry->setValue(getSimple());
  212. mTextEntry->setTentative(FALSE);
  213. }
  214. setControlValue(getValue());
  215. LLUICtrl::onCommit();
  216. }
  218. // virtual
  219. BOOL LLComboBox::isDirty() const
  220. {
  221. BOOL grubby = FALSE;
  222. if ( mList )
  223. {
  224. grubby = mList->isDirty();
  225. }
  226. return grubby;
  227. }
  229. // virtual   Clear dirty state
  230. void LLComboBox::resetDirty()
  231. {
  232. if ( mList )
  233. {
  234. mList->resetDirty();
  235. }
  236. }
  239. // add item "name" to menu
  240. LLScrollListItem* LLComboBox::add(const std::string& name, EAddPosition pos, BOOL enabled)
  241. {
  242. LLScrollListItem* item = mList->addSimpleElement(name, pos);
  243. item->setEnabled(enabled);
  244. if (!mAllowTextEntry && mLabel.empty())
  245. {
  246. selectFirstItem();
  247. }
  248. return item;
  249. }
  251. // add item "name" with a unique id to menu
  252. LLScrollListItem* LLComboBox::add(const std::string& name, const LLUUID& id, EAddPosition pos, BOOL enabled )
  253. {
  254. LLScrollListItem* item = mList->addSimpleElement(name, pos, id);
  255. item->setEnabled(enabled);
  256. if (!mAllowTextEntry && mLabel.empty())
  257. {
  258. selectFirstItem();
  259. }
  260. return item;
  261. }
  263. // add item "name" with attached userdata
  264. LLScrollListItem* LLComboBox::add(const std::string& name, void* userdata, EAddPosition pos, BOOL enabled )
  265. {
  266. LLScrollListItem* item = mList->addSimpleElement(name, pos);
  267. item->setEnabled(enabled);
  268. item->setUserdata( userdata );
  269. if (!mAllowTextEntry && mLabel.empty())
  270. {
  271. selectFirstItem();
  272. }
  273. return item;
  274. }
  276. // add item "name" with attached generic data
  277. LLScrollListItem* LLComboBox::add(const std::string& name, LLSD value, EAddPosition pos, BOOL enabled )
  278. {
  279. LLScrollListItem* item = mList->addSimpleElement(name, pos, value);
  280. item->setEnabled(enabled);
  281. if (!mAllowTextEntry && mLabel.empty())
  282. {
  283. selectFirstItem();
  284. }
  285. return item;
  286. }
  288. LLScrollListItem* LLComboBox::addSeparator(EAddPosition pos)
  289. {
  290. return mList->addSeparator(pos);
  291. }
  293. void LLComboBox::sortByName(BOOL ascending)
  294. {
  295. mList->sortOnce(0, ascending);
  296. }
  299. // Choose an item with a given name in the menu.
  300. // Returns TRUE if the item was found.
  301. BOOL LLComboBox::setSimple(const LLStringExplicit& name)
  302. {
  303. BOOL found = mList->selectItemByLabel(name, FALSE);
  305. if (found)
  306. {
  307. setLabel(name);
  308. mLastSelectedIndex = mList->getFirstSelectedIndex();
  309. }
  311. return found;
  312. }
  314. // virtual
  315. void LLComboBox::setValue(const LLSD& value)
  316. {
  317. BOOL found = mList->selectByValue(value);
  318. if (found)
  319. {
  320. LLScrollListItem* item = mList->getFirstSelected();
  321. if (item)
  322. {
  323. setLabel( mList->getSelectedItemLabel() );
  324. }
  325. mLastSelectedIndex = mList->getFirstSelectedIndex();
  326. }
  327. }
  329. const std::string LLComboBox::getSimple() const
  330. {
  331. const std::string res = mList->getSelectedItemLabel();
  332. if (res.empty() && mAllowTextEntry)
  333. {
  334. return mTextEntry->getText();
  335. }
  336. else
  337. {
  338. return res;
  339. }
  340. }
  342. const std::string LLComboBox::getSelectedItemLabel(S32 column) const
  343. {
  344. return mList->getSelectedItemLabel(column);
  345. }
  347. // virtual
  348. LLSD LLComboBox::getValue() const
  349. {
  350. LLScrollListItem* item = mList->getFirstSelected();
  351. if( item )
  352. {
  353. return item->getValue();
  354. }
  355. else if (mAllowTextEntry)
  356. {
  357. return mTextEntry->getValue();
  358. }
  359. else
  360. {
  361. return LLSD();
  362. }
  363. }
  365. void LLComboBox::setLabel(const LLStringExplicit& name)
  366. {
  367. if ( mTextEntry )
  368. {
  369. mTextEntry->setText(name);
  370. if (mList->selectItemByLabel(name, FALSE))
  371. {
  372. mTextEntry->setTentative(FALSE);
  373. mLastSelectedIndex = mList->getFirstSelectedIndex();
  374. }
  375. else
  376. {
  377. mTextEntry->setTentative(mTextEntryTentative);
  378. }
  379. }
  381. if (!mAllowTextEntry)
  382. {
  383. mButton->setLabel(name);
  384. }
  385. }
  388. BOOL LLComboBox::remove(const std::string& name)
  389. {
  390. BOOL found = mList->selectItemByLabel(name);
  392. if (found)
  393. {
  394. LLScrollListItem* item = mList->getFirstSelected();
  395. if (item)
  396. {
  397. mList->deleteSingleItem(mList->getItemIndex(item));
  398. }
  399. mLastSelectedIndex = mList->getFirstSelectedIndex();
  400. }
  402. return found;
  403. }
  405. BOOL LLComboBox::remove(S32 index)
  406. {
  407. if (index < mList->getItemCount())
  408. {
  409. mList->deleteSingleItem(index);
  410. setLabel(mList->getSelectedItemLabel());
  411. return TRUE;
  412. }
  413. return FALSE;
  414. }
  416. // Keyboard focus lost.
  417. void LLComboBox::onFocusLost()
  418. {
  419. hideList();
  420. // if valid selection
  421. if (mAllowTextEntry && getCurrentIndex() != -1)
  422. {
  423. mTextEntry->selectAll();
  424. }
  425. LLUICtrl::onFocusLost();
  426. }
  428. void LLComboBox::setButtonVisible(BOOL visible)
  429. {
  430. static LLUICachedControl<S32> drop_shadow_button ("DropShadowButton", 0);
  432. mButton->setVisible(visible);
  433. if (mTextEntry)
  434. {
  435. LLRect text_entry_rect(0, getRect().getHeight(), getRect().getWidth(), 0);
  436. if (visible)
  437. {
  438. S32 arrow_width = mArrowImage ? mArrowImage->getWidth() : 0;
  439. text_entry_rect.mRight -= llmax(8,arrow_width) + 2 * drop_shadow_button;
  440. }
  441. //mTextEntry->setRect(text_entry_rect);
  442. mTextEntry->reshape(text_entry_rect.getWidth(), text_entry_rect.getHeight(), TRUE);
  443. }
  444. }
  446. BOOL LLComboBox::setCurrentByIndex( S32 index )
  447. {
  448. BOOL found = mList->selectNthItem( index );
  449. if (found)
  450. {
  451. setLabel(mList->getSelectedItemLabel());
  452. mLastSelectedIndex = index;
  453. }
  454. return found;
  455. }
  457. S32 LLComboBox::getCurrentIndex() const
  458. {
  459. LLScrollListItem* item = mList->getFirstSelected();
  460. if( item )
  461. {
  462. return mList->getItemIndex( item );
  463. }
  464. return -1;
  465. }
  468. void LLComboBox::createLineEditor(const LLComboBox::Params& p)
  469. {
  470. static LLUICachedControl<S32> drop_shadow_button ("DropShadowButton", 0);
  471. LLRect rect = getLocalRect();
  472. if (mAllowTextEntry)
  473. {
  474. S32 arrow_width = mArrowImage ? mArrowImage->getWidth() : 0;
  475. S32 shadow_size = drop_shadow_button;
  476. mButton->setRect(LLRect( getRect().getWidth() - llmax(8,arrow_width) - 2 * shadow_size,
  477. rect.mTop, rect.mRight, rect.mBottom));
  478. mButton->setTabStop(FALSE);
  479. mButton->setHAlign(LLFontGL::HCENTER);
  481. LLRect text_entry_rect(0, getRect().getHeight(), getRect().getWidth(), 0);
  482. text_entry_rect.mRight -= llmax(8,arrow_width) + 2 * drop_shadow_button;
  483. // clear label on button
  484. std::string cur_label = mButton->getLabelSelected();
  485. LLLineEditor::Params params = p.combo_editor;
  486. params.rect(text_entry_rect);
  487. params.default_text(LLStringUtil::null);
  488. params.max_length_bytes(mMaxChars);
  489. params.commit_callback.function(boost::bind(&LLComboBox::onTextCommit, this, _2));
  490. params.keystroke_callback(boost::bind(&LLComboBox::onTextEntry, this, _1));
  491. params.handle_edit_keys_directly(true);
  492. params.commit_on_focus_lost(false);
  493. params.follows.flags(FOLLOWS_ALL);
  494. params.label(mLabel);
  495. mTextEntry = LLUICtrlFactory::create<LLLineEditor> (params);
  496. mTextEntry->setText(cur_label);
  497. mTextEntry->setIgnoreTab(TRUE);
  498. addChild(mTextEntry);
  500. // clear label on button
  501. setLabel(LLStringUtil::null);
  503. mButton->setFollows(FOLLOWS_BOTTOM | FOLLOWS_TOP | FOLLOWS_RIGHT);
  504. }
  505. else
  506. {
  507. mButton->setRect(rect);
  508. mButton->setTabStop(TRUE);
  509. mButton->setHAlign(LLFontGL::LEFT);
  510. mButton->setLabel(mLabel.getString());
  512. if (mTextEntry)
  513. {
  514. mTextEntry->setVisible(FALSE);
  515. }
  516. mButton->setFollowsAll();
  517. }
  518. }
  520. void* LLComboBox::getCurrentUserdata()
  521. {
  522. LLScrollListItem* item = mList->getFirstSelected();
  523. if( item )
  524. {
  525. return item->getUserdata();
  526. }
  527. return NULL;
  528. }
  531. void LLComboBox::showList()
  532. {
  533. // Make sure we don't go off top of screen.
  534. LLCoordWindow window_size;
  535. getWindow()->getSize(&window_size);
  536. //HACK: shouldn't have to know about scale here
  537. mList->fitContents( 192, llfloor((F32)window_size.mY / LLUI::sGLScaleFactor.mV[VY]) - 50 );
  539. // Make sure that we can see the whole list
  540. LLRect root_view_local;
  541. LLView* root_view = getRootView();
  542. root_view->localRectToOtherView(root_view->getLocalRect(), &root_view_local, this);
  544. LLRect rect = mList->getRect();
  546. S32 min_width = getRect().getWidth();
  547. S32 max_width = llmax(min_width, MAX_COMBO_WIDTH);
  548. // make sure we have up to date content width metrics
  549. mList->calcColumnWidths();
  550. S32 list_width = llclamp(mList->getMaxContentWidth(), min_width, max_width);
  552. if (mListPosition == BELOW)
  553. {
  554. if (rect.getHeight() <= -root_view_local.mBottom)
  555. {
  556. // Move rect so it hangs off the bottom of this view
  557. rect.setLeftTopAndSize(0, 0, list_width, rect.getHeight() );
  558. }
  559. else
  560. {
  561. // stack on top or bottom, depending on which has more room
  562. if (-root_view_local.mBottom > root_view_local.mTop - getRect().getHeight())
  563. {
  564. // Move rect so it hangs off the bottom of this view
  565. rect.setLeftTopAndSize(0, 0, list_width, llmin(-root_view_local.mBottom, rect.getHeight()));
  566. }
  567. else
  568. {
  569. // move rect so it stacks on top of this view (clipped to size of screen)
  570. rect.setOriginAndSize(0, getRect().getHeight(), list_width, llmin(root_view_local.mTop - getRect().getHeight(), rect.getHeight()));
  571. }
  572. }
  573. }
  574. else // ABOVE
  575. {
  576. if (rect.getHeight() <= root_view_local.mTop - getRect().getHeight())
  577. {
  578. // move rect so it stacks on top of this view (clipped to size of screen)
  579. rect.setOriginAndSize(0, getRect().getHeight(), list_width, llmin(root_view_local.mTop - getRect().getHeight(), rect.getHeight()));
  580. }
  581. else
  582. {
  583. // stack on top or bottom, depending on which has more room
  584. if (-root_view_local.mBottom > root_view_local.mTop - getRect().getHeight())
  585. {
  586. // Move rect so it hangs off the bottom of this view
  587. rect.setLeftTopAndSize(0, 0, list_width, llmin(-root_view_local.mBottom, rect.getHeight()));
  588. }
  589. else
  590. {
  591. // move rect so it stacks on top of this view (clipped to size of screen)
  592. rect.setOriginAndSize(0, getRect().getHeight(), list_width, llmin(root_view_local.mTop - getRect().getHeight(), rect.getHeight()));
  593. }
  594. }
  596. }
  597. mList->setOrigin(rect.mLeft, rect.mBottom);
  598. mList->reshape(rect.getWidth(), rect.getHeight());
  599. mList->translateIntoRect(root_view_local, FALSE);
  601. // Make sure we didn't go off bottom of screen
  602. S32 x, y;
  603. mList->localPointToScreen(0, 0, &x, &y);
  605. if (y < 0)
  606. {
  607. mList->translate(0, -y);
  608. }
  610. // NB: this call will trigger the focuslost callback which will hide the list, so do it first
  611. // before finally showing the list
  613. mList->setFocus(TRUE);
  615. // register ourselves as a "top" control
  616. // effectively putting us into a special draw layer
  617. // and not affecting the bounding rectangle calculation
  618. gFocusMgr.setTopCtrl(this);
  620. // Show the list and push the button down
  621. mButton->setToggleState(TRUE);
  622. mList->setVisible(TRUE);
  624. setUseBoundingRect(TRUE);
  625. }
  627. void LLComboBox::hideList()
  628. {
  629. if (mList->getVisible())
  630. {
  631. // assert selection in list
  632. if(mAllowNewValues)
  633. {
  634. // mLastSelectedIndex = -1 means that we entered a new value, don't select
  635. // any of existing items in this case.
  636. if(mLastSelectedIndex >= 0)
  637. mList->selectNthItem(mLastSelectedIndex);
  638. }
  639. else if(mLastSelectedIndex >= 0)
  640. mList->selectNthItem(mLastSelectedIndex);
  642. mButton->setToggleState(FALSE);
  643. mList->setVisible(FALSE);
  644. mList->mouseOverHighlightNthItem(-1);
  646. setUseBoundingRect(FALSE);
  647. if( gFocusMgr.getTopCtrl() == this )
  648. {
  649. gFocusMgr.setTopCtrl(NULL);
  650. }
  651. }
  652. }
  654. void LLComboBox::onButtonMouseDown()
  655. {
  656. if (!mList->getVisible())
  657. {
  658. // this might change selection, so do it first
  659. prearrangeList();
  661. // highlight the last selected item from the original selection before potentially selecting a new item
  662. // as visual cue to original value of combo box
  663. LLScrollListItem* last_selected_item = mList->getLastSelectedItem();
  664. if (last_selected_item)
  665. {
  666. mList->mouseOverHighlightNthItem(mList->getItemIndex(last_selected_item));
  667. }
  669. if (mList->getItemCount() != 0)
  670. {
  671. showList();
  672. }
  674. setFocus( TRUE );
  676. // pass mouse capture on to list if button is depressed
  677. if (mButton->hasMouseCapture())
  678. {
  679. gFocusMgr.setMouseCapture(mList);
  681. // But keep the "pressed" look, which buttons normally lose when they
  682. // lose focus
  683. mButton->setForcePressedState(true);
  684. }
  685. }
  686. else
  687. {
  688. hideList();
  689. } 
  691. }
  693. void LLComboBox::onListMouseUp()
  694. {
  695. // In some cases this is the termination of a mouse click that started on
  696. // the button, so clear its pressed state
  697. mButton->setForcePressedState(false);
  698. }
  700. //------------------------------------------------------------------
  701. // static functions
  702. //------------------------------------------------------------------
  704. void LLComboBox::onItemSelected(const LLSD& data)
  705. {
  706. const std::string name = mList->getSelectedItemLabel();
  708. S32 cur_id = getCurrentIndex();
  709. mLastSelectedIndex = cur_id;
  710. if (cur_id != -1)
  711. {
  712. setLabel(name);
  714. if (mAllowTextEntry)
  715. {
  716. gFocusMgr.setKeyboardFocus(mTextEntry);
  717. mTextEntry->selectAll();
  718. }
  719. }
  721. // hiding the list reasserts the old value stored in the text editor/dropdown button
  722. hideList();
  724. // commit does the reverse, asserting the value in the list
  725. onCommit();
  726. }
  728. BOOL LLComboBox::handleToolTip(S32 x, S32 y, MASK mask)
  729. {
  730.     std::string tool_tip;
  732. if(LLUICtrl::handleToolTip(x, y, mask))
  733. {
  734. return TRUE;
  735. }
  737. tool_tip = getToolTip();
  738. if (tool_tip.empty())
  739. {
  740. tool_tip = getSelectedItemLabel();
  741. }
  743. if( !tool_tip.empty() )
  744. {
  745. LLToolTipMgr::instance().show(LLToolTip::Params()
  746. .message(tool_tip)
  747. .sticky_rect(calcScreenRect()));
  748. }
  749. return TRUE;
  750. }
  752. BOOL LLComboBox::handleKeyHere(KEY key, MASK mask)
  753. {
  754. BOOL result = FALSE;
  755. if (hasFocus())
  756. {
  757. if (mList->getVisible() 
  758. && key == KEY_ESCAPE && mask == MASK_NONE)
  759. {
  760. hideList();
  761. return TRUE;
  762. }
  763. //give list a chance to pop up and handle key
  764. LLScrollListItem* last_selected_item = mList->getLastSelectedItem();
  765. if (last_selected_item)
  766. {
  767. // highlight the original selection before potentially selecting a new item
  768. mList->mouseOverHighlightNthItem(mList->getItemIndex(last_selected_item));
  769. }
  770. result = mList->handleKeyHere(key, mask);
  772. // will only see return key if it is originating from line editor
  773. // since the dropdown button eats the key
  774. if (key == KEY_RETURN)
  775. {
  776. // don't show list and don't eat key input when committing
  777. // free-form text entry with RETURN since user already knows
  778.             // what they are trying to select
  779. return FALSE;
  780. }
  781. // if selection has changed, pop open list
  782. else if (mList->getLastSelectedItem() != last_selected_item)
  783. {
  784. showList();
  785. }
  786. }
  787. return result;
  788. }
  790. BOOL LLComboBox::handleUnicodeCharHere(llwchar uni_char)
  791. {
  792. BOOL result = FALSE;
  793. if (gFocusMgr.childHasKeyboardFocus(this))
  794. {
  795. // space bar just shows the list
  796. if (' ' != uni_char )
  797. {
  798. LLScrollListItem* last_selected_item = mList->getLastSelectedItem();
  799. if (last_selected_item)
  800. {
  801. // highlight the original selection before potentially selecting a new item
  802. mList->mouseOverHighlightNthItem(mList->getItemIndex(last_selected_item));
  803. }
  804. result = mList->handleUnicodeCharHere(uni_char);
  805. if (mList->getLastSelectedItem() != last_selected_item)
  806. {
  807. showList();
  808. }
  809. }
  810. }
  811. return result;
  812. }
  814. void LLComboBox::setTextEntry(const LLStringExplicit& text)
  815. {
  816. if (mTextEntry)
  817. {
  818. mTextEntry->setText(text);
  819. mHasAutocompletedText = FALSE;
  820. updateSelection();
  821. }
  822. }
  824. void LLComboBox::onTextEntry(LLLineEditor* line_editor)
  825. {
  826. if (mTextEntryCallback != NULL)
  827. {
  828. (mTextEntryCallback)(line_editor, LLSD());
  829. }
  831. KEY key = gKeyboard->currentKey();
  832. if (key == KEY_BACKSPACE || 
  833. key == KEY_DELETE)
  834. {
  835. if (mList->selectItemByLabel(line_editor->getText(), FALSE))
  836. {
  837. line_editor->setTentative(FALSE);
  838. mLastSelectedIndex = mList->getFirstSelectedIndex();
  839. }
  840. else
  841. {
  842. line_editor->setTentative(mTextEntryTentative);
  843. mList->deselectAllItems();
  844. mLastSelectedIndex = -1;
  845. }
  846. return;
  847. }
  849. if (key == KEY_LEFT || 
  850. key == KEY_RIGHT)
  851. {
  852. return;
  853. }
  855. if (key == KEY_DOWN)
  856. {
  857. setCurrentByIndex(llmin(getItemCount() - 1, getCurrentIndex() + 1));
  858. if (!mList->getVisible())
  859. {
  860. prearrangeList();
  862. if (mList->getItemCount() != 0)
  863. {
  864. showList();
  865. }
  866. }
  867. line_editor->selectAll();
  868. line_editor->setTentative(FALSE);
  869. }
  870. else if (key == KEY_UP)
  871. {
  872. setCurrentByIndex(llmax(0, getCurrentIndex() - 1));
  873. if (!mList->getVisible())
  874. {
  875. prearrangeList();
  877. if (mList->getItemCount() != 0)
  878. {
  879. showList();
  880. }
  881. }
  882. line_editor->selectAll();
  883. line_editor->setTentative(FALSE);
  884. }
  885. else
  886. {
  887. // RN: presumably text entry
  888. updateSelection();
  889. }
  890. }
  892. void LLComboBox::updateSelection()
  893. {
  894. LLWString left_wstring = mTextEntry->getWText().substr(0, mTextEntry->getCursor());
  895. // user-entered portion of string, based on assumption that any selected
  896.     // text was a result of auto-completion
  897. LLWString user_wstring = mHasAutocompletedText ? left_wstring : mTextEntry->getWText();
  898. std::string full_string = mTextEntry->getText();
  900. // go ahead and arrange drop down list on first typed character, even
  901. // though we aren't showing it... some code relies on prearrange
  902. // callback to populate content
  903. if( mTextEntry->getWText().size() == 1 )
  904. {
  905. prearrangeList(mTextEntry->getText());
  906. }
  908. if (mList->selectItemByLabel(full_string, FALSE))
  909. {
  910. mTextEntry->setTentative(FALSE);
  911. mLastSelectedIndex = mList->getFirstSelectedIndex();
  912. }
  913. else if (mList->selectItemByPrefix(left_wstring, FALSE))
  914. {
  915. LLWString selected_item = utf8str_to_wstring(mList->getSelectedItemLabel());
  916. LLWString wtext = left_wstring + selected_item.substr(left_wstring.size(), selected_item.size());
  917. mTextEntry->setText(wstring_to_utf8str(wtext));
  918. mTextEntry->setSelection(left_wstring.size(), mTextEntry->getWText().size());
  919. mTextEntry->endSelection();
  920. mTextEntry->setTentative(FALSE);
  921. mHasAutocompletedText = TRUE;
  922. mLastSelectedIndex = mList->getFirstSelectedIndex();
  923. }
  924. else // no matching items found
  925. {
  926. mList->deselectAllItems();
  927. mTextEntry->setText(wstring_to_utf8str(user_wstring)); // removes text added by autocompletion
  928. mTextEntry->setTentative(mTextEntryTentative);
  929. mHasAutocompletedText = FALSE;
  930. mLastSelectedIndex = -1;
  931. }
  932. }
  934. void LLComboBox::onTextCommit(const LLSD& data)
  935. {
  936. std::string text = mTextEntry->getText();
  937. setSimple(text);
  938. onCommit();
  939. mTextEntry->selectAll();
  940. }
  942. void LLComboBox::setFocus(BOOL b)
  943. {
  944. LLUICtrl::setFocus(b);
  946. if (b)
  947. {
  948. mList->clearSearchString();
  949. if (mList->getVisible())
  950. {
  951. mList->setFocus(TRUE);
  952. }
  953. }
  954. }
  956. void LLComboBox::prearrangeList(std::string filter)
  957. {
  958. if (mPrearrangeCallback)
  959. {
  960. mPrearrangeCallback(this, LLSD(filter));
  961. }
  962. }
  964. //============================================================================
  965. // LLCtrlListInterface functions
  967. S32 LLComboBox::getItemCount() const
  968. {
  969. return mList->getItemCount();
  970. }
  972. void LLComboBox::addColumn(const LLSD& column, EAddPosition pos)
  973. {
  974. mList->clearColumns();
  975. mList->addColumn(column, pos);
  976. }
  978. void LLComboBox::clearColumns()
  979. {
  980. mList->clearColumns();
  981. }
  983. void LLComboBox::setColumnLabel(const std::string& column, const std::string& label)
  984. {
  985. mList->setColumnLabel(column, label);
  986. }
  988. LLScrollListItem* LLComboBox::addElement(const LLSD& value, EAddPosition pos, void* userdata)
  989. {
  990. return mList->addElement(value, pos, userdata);
  991. }
  993. LLScrollListItem* LLComboBox::addSimpleElement(const std::string& value, EAddPosition pos, const LLSD& id)
  994. {
  995. return mList->addSimpleElement(value, pos, id);
  996. }
  998. void LLComboBox::clearRows()
  999. {
  1000. mList->clearRows();
  1001. }
  1003. void LLComboBox::sortByColumn(const std::string& name, BOOL ascending)
  1004. {
  1005. mList->sortByColumn(name, ascending);
  1006. }
  1008. //============================================================================
  1009. //LLCtrlSelectionInterface functions
  1011. BOOL LLComboBox::setCurrentByID(const LLUUID& id)
  1012. {
  1013. BOOL found = mList->selectByID( id );
  1015. if (found)
  1016. {
  1017. setLabel(mList->getSelectedItemLabel());
  1018. mLastSelectedIndex = mList->getFirstSelectedIndex();
  1019. }
  1021. return found;
  1022. }
  1024. LLUUID LLComboBox::getCurrentID() const
  1025. {
  1026. return mList->getStringUUIDSelectedItem();
  1027. }
  1028. BOOL LLComboBox::setSelectedByValue(const LLSD& value, BOOL selected)
  1029. {
  1030. BOOL found = mList->setSelectedByValue(value, selected);
  1031. if (found)
  1032. {
  1033. setLabel(mList->getSelectedItemLabel());
  1034. }
  1035. return found;
  1036. }
  1038. LLSD LLComboBox::getSelectedValue()
  1039. {
  1040. return mList->getSelectedValue();
  1041. }
  1043. BOOL LLComboBox::isSelected(const LLSD& value) const
  1044. {
  1045. return mList->isSelected(value);
  1046. }
  1048. BOOL LLComboBox::operateOnSelection(EOperation op)
  1049. {
  1050. if (op == OP_DELETE)
  1051. {
  1052. mList->deleteSelectedItems();
  1053. return TRUE;
  1054. }
  1055. return FALSE;
  1056. }
  1058. BOOL LLComboBox::operateOnAll(EOperation op)
  1059. {
  1060. if (op == OP_DELETE)
  1061. {
  1062. clearRows();
  1063. return TRUE;
  1064. }
  1065. return FALSE;
  1066. }
  1068. BOOL LLComboBox::selectItemRange( S32 first, S32 last )
  1069. {
  1070. return mList->selectItemRange(first, last);
  1071. }