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

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

游戏引擎

开发平台：

C++ Builder

lltabcontainer.cpp：源码内容
  1. /** 
  2.  * @file lltabcontainer.cpp
  3.  * @brief LLTabContainer class
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include "lltabcontainer.h"
  37. #include "llfocusmgr.h"
  38. #include "lllocalcliprect.h"
  39. #include "llrect.h"
  40. #include "llresizehandle.h"
  41. #include "lltextbox.h"
  42. #include "llcriticaldamp.h"
  43. #include "lluictrlfactory.h"
  44. #include "llrender.h"
  45. #include "llfloater.h"
  46. #include "lltrans.h"
  48. //----------------------------------------------------------------------------
  50. // Implementation Notes:
  51. //  - Each tab points to a LLPanel (see LLTabTuple below)
  52. //  - When a tab is selected, the validation callback
  53. //    (LLUICtrl::mValidateSignal) is called
  54. //  -  If the validation callback returns true (or none is provided),
  55. //     the tab is changed and the commit callback
  56. //     (LLUICtrl::mCommitSignal) is called
  57. //  - Callbacks pass the LLTabContainer as the control,
  58. //    and the NAME of the selected PANEL as the LLSD data
  60. //----------------------------------------------------------------------------
  62. const F32 SCROLL_STEP_TIME = 0.4f;
  63. const F32 SCROLL_DELAY_TIME = 0.5f;
  65. void LLTabContainer::TabPositions::declareValues()
  66. {
  67. declare("top", LLTabContainer::TOP);
  68. declare("bottom", LLTabContainer::BOTTOM);
  69. declare("left", LLTabContainer::LEFT);
  70. }
  72. //----------------------------------------------------------------------------
  74. // Structure used to map tab buttons to and from tab panels
  75. class LLTabTuple
  76. {
  77. public:
  78. LLTabTuple( LLTabContainer* c, LLPanel* p, LLButton* b, LLTextBox* placeholder = NULL)
  79. :
  80. mTabContainer(c),
  81. mTabPanel(p),
  82. mButton(b),
  83. mOldState(FALSE),
  84. mPlaceholderText(placeholder),
  85. mPadding(0)
  86. {}
  88. LLTabContainer*  mTabContainer;
  89. LLPanel*  mTabPanel;
  90. LLButton*  mButton;
  91. BOOL  mOldState;
  92. LLTextBox*  mPlaceholderText;
  93. S32  mPadding;
  94. };
  96. //----------------------------------------------------------------------------
  98. //============================================================================
  99. /*
  100.  * @file lltabcontainer.cpp
  101.  * @brief class implements LLButton with LLIconCtrl on it
  102.  */
  103. class LLCustomButtonIconCtrl : public LLButton
  104. {
  105. public:
  106. struct Params
  107. : public LLInitParam::Block<Params, LLButton::Params>
  108. {
  109. // LEFT, RIGHT, TOP, BOTTOM paddings of LLIconCtrl in this class has same value
  110. Optional<S32> icon_ctrl_pad;
  112. Params():
  113. icon_ctrl_pad("icon_ctrl_pad", 1)
  114. {}
  115. };
  117. protected:
  118. friend class LLUICtrlFactory;
  119. LLCustomButtonIconCtrl(const Params& p):
  120. LLButton(p),
  121. mIcon(NULL),
  122. mIconAlignment(LLFontGL::HCENTER),
  123. mIconCtrlPad(p.icon_ctrl_pad)
  124. {}
  126. public:
  128. void updateLayout()
  129. {
  130. LLRect button_rect = getRect();
  131. LLRect icon_rect = mIcon->getRect();
  133. S32 icon_size = button_rect.getHeight() - 2*mIconCtrlPad;
  135. switch(mIconAlignment)
  136. {
  137. case LLFontGL::LEFT:
  138. icon_rect.setLeftTopAndSize(button_rect.mLeft + mIconCtrlPad, button_rect.mTop - mIconCtrlPad, 
  139. icon_size, icon_size);
  140. setLeftHPad(icon_size + mIconCtrlPad * 2);
  141. break;
  142. case LLFontGL::HCENTER:
  143. icon_rect.setLeftTopAndSize(button_rect.mRight - (button_rect.getWidth() + mIconCtrlPad - icon_size)/2, button_rect.mTop - mIconCtrlPad, 
  144. icon_size, icon_size);
  145. setRightHPad(icon_size + mIconCtrlPad * 2);
  146. break;
  147. case LLFontGL::RIGHT:
  148. icon_rect.setLeftTopAndSize(button_rect.mRight - mIconCtrlPad - icon_size, button_rect.mTop - mIconCtrlPad, 
  149. icon_size, icon_size);
  150. setRightHPad(icon_size + mIconCtrlPad * 2);
  151. break;
  152. default:
  153. break;
  154. }
  155. mIcon->setRect(icon_rect);
  156. }
  158. void setIcon(LLIconCtrl* icon, LLFontGL::HAlign alignment = LLFontGL::LEFT)
  159. {
  160. if(icon)
  161. {
  162. if(mIcon)
  163. {
  164. removeChild(mIcon);
  165. mIcon->die();
  166. }
  167. mIcon = icon;
  168. mIconAlignment = alignment;
  170. addChild(mIcon);
  171. updateLayout();
  172. }
  173. }
  176. private:
  177. LLIconCtrl* mIcon;
  178. LLFontGL::HAlign mIconAlignment;
  179. S32 mIconCtrlPad;
  180. };
  181. //============================================================================
  183. struct LLPlaceHolderPanel : public LLPanel
  184. {
  185. // create dummy param block to register with "placeholder" nane
  186. struct Params : public LLPanel::Params{};
  187. LLPlaceHolderPanel(const Params& p) : LLPanel(p)
  188. {}
  189. };
  190. static LLDefaultChildRegistry::Register<LLPlaceHolderPanel> r1("placeholder");
  191. static LLDefaultChildRegistry::Register<LLTabContainer> r2("tab_container");
  193. LLTabContainer::TabParams::TabParams()
  194. : tab_top_image_unselected("tab_top_image_unselected"),
  195. tab_top_image_selected("tab_top_image_selected"),
  196. tab_bottom_image_unselected("tab_bottom_image_unselected"),
  197. tab_bottom_image_selected("tab_bottom_image_selected"),
  198. tab_left_image_unselected("tab_left_image_unselected"),
  199. tab_left_image_selected("tab_left_image_selected")
  200. {}
  202. LLTabContainer::Params::Params()
  203. : tab_width("tab_width"),
  204. tab_min_width("tab_min_width"),
  205. tab_max_width("tab_max_width"),
  206. tab_height("tab_height"),
  207. label_pad_bottom("label_pad_bottom"),
  208. label_pad_left("label_pad_left"),
  209. tab_position("tab_position"),
  210. hide_tabs("hide_tabs", false),
  211. tab_padding_right("tab_padding_right"),
  212. first_tab("first_tab"),
  213. middle_tab("middle_tab"),
  214. last_tab("last_tab"),
  215. use_custom_icon_ctrl("use_custom_icon_ctrl", false),
  216. tab_icon_ctrl_pad("tab_icon_ctrl_pad", 0),
  217. use_ellipses("use_ellipses"),
  218. font_halign("font_halign")
  219. {
  220. name(std::string("tab_container"));
  221. mouse_opaque = false;
  222. }
  224. LLTabContainer::LLTabContainer(const LLTabContainer::Params& p)
  225. : LLPanel(p),
  226. mCurrentTabIdx(-1),
  227. mTabsHidden(p.hide_tabs),
  228. mScrolled(FALSE),
  229. mScrollPos(0),
  230. mScrollPosPixels(0),
  231. mMaxScrollPos(0),
  232. mTitleBox(NULL),
  233. mTopBorderHeight(LLPANEL_BORDER_WIDTH),
  234. mLockedTabCount(0),
  235. mMinTabWidth(0),
  236. mMaxTabWidth(p.tab_max_width),
  237. mTabHeight(p.tab_height),
  238. mLabelPadBottom(p.label_pad_bottom),
  239. mLabelPadLeft(p.label_pad_left),
  240. mPrevArrowBtn(NULL),
  241. mNextArrowBtn(NULL),
  242. mIsVertical( p.tab_position == LEFT ),
  243. // Horizontal Specific
  244. mJumpPrevArrowBtn(NULL),
  245. mJumpNextArrowBtn(NULL),
  246. mRightTabBtnOffset(p.tab_padding_right),
  247. mTotalTabWidth(0),
  248. mTabPosition(p.tab_position),
  249. mFontHalign(p.font_halign),
  250. mFont(p.font),
  251. mFirstTabParams(p.first_tab),
  252. mMiddleTabParams(p.middle_tab),
  253. mLastTabParams(p.last_tab),
  254. mCustomIconCtrlUsed(p.use_custom_icon_ctrl),
  255. mTabIconCtrlPad(p.tab_icon_ctrl_pad),
  256. mUseTabEllipses(p.use_ellipses)
  257. {
  258. static LLUICachedControl<S32> tabcntr_vert_tab_min_width ("UITabCntrVertTabMinWidth", 0);
  260. mDragAndDropDelayTimer.stop();
  262. if (p.tab_width.isProvided())
  263. {
  264. mMinTabWidth = p.tab_width;
  265. }
  266. else if (!mIsVertical)
  267. {
  268. mMinTabWidth = p.tab_min_width;
  269. }
  270. else
  271. {
  272. // *HACK: support default min width for legacy vertical
  273. // tab containers
  274. mMinTabWidth = tabcntr_vert_tab_min_width;
  275. }
  277. initButtons( );
  278. }
  280. LLTabContainer::~LLTabContainer()
  281. {
  282. std::for_each(mTabList.begin(), mTabList.end(), DeletePointer());
  283. }
  285. //virtual
  286. void LLTabContainer::setValue(const LLSD& value)
  287. {
  288. selectTab((S32) value.asInteger());
  289. }
  291. //virtual
  292. void LLTabContainer::reshape(S32 width, S32 height, BOOL called_from_parent)
  293. {
  294. LLPanel::reshape( width, height, called_from_parent );
  295. updateMaxScrollPos();
  296. }
  298. //virtual
  299. LLView* LLTabContainer::getChildView(const std::string& name, BOOL recurse) const
  300. {
  301. tuple_list_t::const_iterator itor;
  302. for (itor = mTabList.begin(); itor != mTabList.end(); ++itor)
  303. {
  304. LLPanel *panel = (*itor)->mTabPanel;
  305. if (panel->getName() == name)
  306. {
  307. return panel;
  308. }
  309. }
  311. if (recurse)
  312. {
  313. for (itor = mTabList.begin(); itor != mTabList.end(); ++itor)
  314. {
  315. LLPanel *panel = (*itor)->mTabPanel;
  316. LLView *child = panel->getChildView(name, recurse);
  317. if (child)
  318. {
  319. return child;
  320. }
  321. }
  322. }
  323. return LLView::getChildView(name, recurse);
  324. }
  326. //virtual
  327. LLView* LLTabContainer::findChildView(const std::string& name, BOOL recurse) const
  328. {
  329. tuple_list_t::const_iterator itor;
  330. for (itor = mTabList.begin(); itor != mTabList.end(); ++itor)
  331. {
  332. LLPanel *panel = (*itor)->mTabPanel;
  333. if (panel->getName() == name)
  334. {
  335. return panel;
  336. }
  337. }
  339. if (recurse)
  340. {
  341. for (itor = mTabList.begin(); itor != mTabList.end(); ++itor)
  342. {
  343. LLPanel *panel = (*itor)->mTabPanel;
  344. LLView *child = panel->findChildView(name, recurse);
  345. if (child)
  346. {
  347. return child;
  348. }
  349. }
  350. }
  351. return LLView::findChildView(name, recurse);
  352. }
  354. bool LLTabContainer::addChild(LLView* view, S32 tab_group)
  355. {
  356. LLPanel* panelp = dynamic_cast<LLPanel*>(view);
  358. if (panelp)
  359. {
  360. addTabPanel(TabPanelParams().panel(panelp).label(panelp->getLabel()).is_placeholder(dynamic_cast<LLPlaceHolderPanel*>(view) != NULL));
  361. return true;
  362. }
  363. else
  364. {
  365. return LLUICtrl::addChild(view, tab_group);
  366. }
  367. }
  369. BOOL LLTabContainer::postBuild()
  370. {
  371. selectFirstTab();
  373. return TRUE;
  374. }
  376. // virtual
  377. void LLTabContainer::draw()
  378. {
  379. static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
  380. static LLUICachedControl<S32> tabcntrv_arrow_btn_size ("UITabCntrvArrowBtnSize", 0);
  381. static LLUICachedControl<S32> tabcntr_tab_h_pad ("UITabCntrTabHPad", 0);
  382. static LLUICachedControl<S32> tabcntr_arrow_btn_size ("UITabCntrArrowBtnSize", 0);
  383. static LLUICachedControl<S32> tabcntr_tab_partial_width ("UITabCntrTabPartialWidth", 0);
  384. S32 target_pixel_scroll = 0;
  385. S32 cur_scroll_pos = getScrollPos();
  386. if (cur_scroll_pos > 0)
  387. {
  388. S32 available_width_with_arrows = getRect().getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + tabcntr_arrow_btn_size  + tabcntr_arrow_btn_size + 1);
  389. if (!mIsVertical)
  390. {
  391. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  392. {
  393. if (cur_scroll_pos == 0)
  394. {
  395. break;
  396. }
  397. target_pixel_scroll += (*iter)->mButton->getRect().getWidth();
  398. cur_scroll_pos--;
  399. }
  401. // Show part of the tab to the left of what is fully visible
  402. target_pixel_scroll -= tabcntr_tab_partial_width;
  403. // clamp so that rightmost tab never leaves right side of screen
  404. target_pixel_scroll = llmin(mTotalTabWidth - available_width_with_arrows, target_pixel_scroll);
  405. }
  406. }
  408. setScrollPosPixels((S32)lerp((F32)getScrollPosPixels(), (F32)target_pixel_scroll, LLCriticalDamp::getInterpolant(0.08f)));
  410. BOOL has_scroll_arrows = !getTabsHidden() && ((mMaxScrollPos > 0) || (mScrollPosPixels > 0));
  411. if (!mIsVertical)
  412. {
  413. mJumpPrevArrowBtn->setVisible( has_scroll_arrows );
  414. mJumpNextArrowBtn->setVisible( has_scroll_arrows );
  415. }
  416. mPrevArrowBtn->setVisible( has_scroll_arrows );
  417. mNextArrowBtn->setVisible( has_scroll_arrows );
  419. S32 left = 0, top = 0;
  420. if (mIsVertical)
  421. {
  422. top = getRect().getHeight() - getTopBorderHeight() - LLPANEL_BORDER_WIDTH - 1 - (has_scroll_arrows ? tabcntrv_arrow_btn_size : 0);
  423. top += getScrollPosPixels();
  424. }
  425. else
  426. {
  427. // Set the leftmost position of the tab buttons.
  428. left = LLPANEL_BORDER_WIDTH + (has_scroll_arrows ? (tabcntr_arrow_btn_size * 2) : tabcntr_tab_h_pad);
  429. left -= getScrollPosPixels();
  430. }
  432. // Hide all the buttons
  433. if (getTabsHidden())
  434. {
  435. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  436. {
  437. LLTabTuple* tuple = *iter;
  438. tuple->mButton->setVisible( FALSE );
  439. }
  440. }
  442. {
  443. LLRect clip_rect = getLocalRect();
  444. clip_rect.mLeft+=(LLPANEL_BORDER_WIDTH + 2);
  445. clip_rect.mRight-=(LLPANEL_BORDER_WIDTH + 2);
  446. LLLocalClipRect clip(clip_rect);
  447. LLPanel::draw();
  448. }
  450. // if tabs are hidden, don't draw them and leave them in the invisible state
  451. if (!getTabsHidden())
  452. {
  453. // Show all the buttons
  454. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  455. {
  456. LLTabTuple* tuple = *iter;
  457. tuple->mButton->setVisible( TRUE );
  458. }
  460. S32 max_scroll_visible = getTabCount() - getMaxScrollPos() + getScrollPos();
  461. S32 idx = 0;
  462. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  463. {
  464. LLTabTuple* tuple = *iter;
  466. tuple->mButton->translate( left ? left - tuple->mButton->getRect().mLeft : 0,
  467.    top ? top - tuple->mButton->getRect().mTop : 0 );
  468. if (top) top -= BTN_HEIGHT + tabcntrv_pad;
  469. if (left) left += tuple->mButton->getRect().getWidth();
  471. if (!mIsVertical)
  472. {
  473. if( idx < getScrollPos() )
  474. {
  475. if( tuple->mButton->getFlashing() )
  476. {
  477. mPrevArrowBtn->setFlashing( TRUE );
  478. }
  479. }
  480. else if( max_scroll_visible < idx )
  481. {
  482. if( tuple->mButton->getFlashing() )
  483. {
  484. mNextArrowBtn->setFlashing( TRUE );
  485. }
  486. }
  487. }
  489. idx++;
  490. }
  493. if( mIsVertical && has_scroll_arrows )
  494. {
  495. // Redraw the arrows so that they appears on top.
  496. gGL.pushMatrix();
  497. gGL.translatef((F32)mPrevArrowBtn->getRect().mLeft, (F32)mPrevArrowBtn->getRect().mBottom, 0.f);
  498. mPrevArrowBtn->draw();
  499. gGL.popMatrix();
  501. gGL.pushMatrix();
  502. gGL.translatef((F32)mNextArrowBtn->getRect().mLeft, (F32)mNextArrowBtn->getRect().mBottom, 0.f);
  503. mNextArrowBtn->draw();
  504. gGL.popMatrix();
  505. }
  506. }
  508. mPrevArrowBtn->setFlashing(FALSE);
  509. mNextArrowBtn->setFlashing(FALSE);
  510. }
  513. // virtual
  514. BOOL LLTabContainer::handleMouseDown( S32 x, S32 y, MASK mask )
  515. {
  516. static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
  517. BOOL handled = FALSE;
  518. BOOL has_scroll_arrows = (getMaxScrollPos() > 0) && !getTabsHidden();
  520. if (has_scroll_arrows)
  521. {
  522. if (mJumpPrevArrowBtn&& mJumpPrevArrowBtn->getRect().pointInRect(x, y))
  523. {
  524. S32 local_x = x - mJumpPrevArrowBtn->getRect().mLeft;
  525. S32 local_y = y - mJumpPrevArrowBtn->getRect().mBottom;
  526. handled = mJumpPrevArrowBtn->handleMouseDown(local_x, local_y, mask);
  527. }
  528. else if (mJumpNextArrowBtn && mJumpNextArrowBtn->getRect().pointInRect(x, y))
  529. {
  530. S32 local_x = x - mJumpNextArrowBtn->getRect().mLeft;
  531. S32 local_y = y - mJumpNextArrowBtn->getRect().mBottom;
  532. handled = mJumpNextArrowBtn->handleMouseDown(local_x, local_y, mask);
  533. }
  534. else if (mPrevArrowBtn && mPrevArrowBtn->getRect().pointInRect(x, y))
  535. {
  536. S32 local_x = x - mPrevArrowBtn->getRect().mLeft;
  537. S32 local_y = y - mPrevArrowBtn->getRect().mBottom;
  538. handled = mPrevArrowBtn->handleMouseDown(local_x, local_y, mask);
  539. }
  540. else if (mNextArrowBtn && mNextArrowBtn->getRect().pointInRect(x, y))
  541. {
  542. S32 local_x = x - mNextArrowBtn->getRect().mLeft;
  543. S32 local_y = y - mNextArrowBtn->getRect().mBottom;
  544. handled = mNextArrowBtn->handleMouseDown(local_x, local_y, mask);
  545. }
  546. }
  547. if (!handled)
  548. {
  549. handled = LLPanel::handleMouseDown( x, y, mask );
  550. }
  552. S32 tab_count = getTabCount();
  553. if (tab_count > 0)
  554. {
  555. LLTabTuple* firsttuple = getTab(0);
  556. LLRect tab_rect;
  557. if (mIsVertical)
  558. {
  559. tab_rect = LLRect(firsttuple->mButton->getRect().mLeft,
  560.   has_scroll_arrows ? mPrevArrowBtn->getRect().mBottom - tabcntrv_pad : mPrevArrowBtn->getRect().mTop,
  561.   firsttuple->mButton->getRect().mRight,
  562.   has_scroll_arrows ? mNextArrowBtn->getRect().mTop + tabcntrv_pad : mNextArrowBtn->getRect().mBottom );
  563. }
  564. else
  565. {
  566. tab_rect = LLRect(has_scroll_arrows ? mPrevArrowBtn->getRect().mRight : mJumpPrevArrowBtn->getRect().mLeft,
  567.   firsttuple->mButton->getRect().mTop,
  568.   has_scroll_arrows ? mNextArrowBtn->getRect().mLeft : mJumpNextArrowBtn->getRect().mRight,
  569.   firsttuple->mButton->getRect().mBottom );
  570. }
  571. if( tab_rect.pointInRect( x, y ) )
  572. {
  573. S32 index = getCurrentPanelIndex();
  574. index = llclamp(index, 0, tab_count-1);
  575. LLButton* tab_button = getTab(index)->mButton;
  576. gFocusMgr.setMouseCapture(this);
  577. tab_button->setFocus(TRUE);
  578. }
  579. }
  580. return handled;
  581. }
  583. // virtual
  584. BOOL LLTabContainer::handleHover( S32 x, S32 y, MASK mask )
  585. {
  586. BOOL handled = FALSE;
  587. BOOL has_scroll_arrows = (getMaxScrollPos() > 0) && !getTabsHidden();
  589. if (has_scroll_arrows)
  590. {
  591. if (mJumpPrevArrowBtn && mJumpPrevArrowBtn->getRect().pointInRect(x, y))
  592. {
  593. S32 local_x = x - mJumpPrevArrowBtn->getRect().mLeft;
  594. S32 local_y = y - mJumpPrevArrowBtn->getRect().mBottom;
  595. handled = mJumpPrevArrowBtn->handleHover(local_x, local_y, mask);
  596. }
  597. else if (mJumpNextArrowBtn && mJumpNextArrowBtn->getRect().pointInRect(x, y))
  598. {
  599. S32 local_x = x - mJumpNextArrowBtn->getRect().mLeft;
  600. S32 local_y = y - mJumpNextArrowBtn->getRect().mBottom;
  601. handled = mJumpNextArrowBtn->handleHover(local_x, local_y, mask);
  602. }
  603. else if (mPrevArrowBtn && mPrevArrowBtn->getRect().pointInRect(x, y))
  604. {
  605. S32 local_x = x - mPrevArrowBtn->getRect().mLeft;
  606. S32 local_y = y - mPrevArrowBtn->getRect().mBottom;
  607. handled = mPrevArrowBtn->handleHover(local_x, local_y, mask);
  608. }
  609. else if (mNextArrowBtn && mNextArrowBtn->getRect().pointInRect(x, y))
  610. {
  611. S32 local_x = x - mNextArrowBtn->getRect().mLeft;
  612. S32 local_y = y - mNextArrowBtn->getRect().mBottom;
  613. handled = mNextArrowBtn->handleHover(local_x, local_y, mask);
  614. }
  615. }
  616. if (!handled)
  617. {
  618. handled = LLPanel::handleHover(x, y, mask);
  619. }
  621. commitHoveredButton(x, y);
  622. return handled;
  623. }
  625. // virtual
  626. BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
  627. {
  628. BOOL handled = FALSE;
  629. BOOL has_scroll_arrows = (getMaxScrollPos() > 0)  && !getTabsHidden();
  631. if (has_scroll_arrows)
  632. {
  633. if (mJumpPrevArrowBtn && mJumpPrevArrowBtn->getRect().pointInRect(x, y))
  634. {
  635. S32 local_x = x - mJumpPrevArrowBtn->getRect().mLeft;
  636. S32 local_y = y - mJumpPrevArrowBtn->getRect().mBottom;
  637. handled = mJumpPrevArrowBtn->handleMouseUp(local_x, local_y, mask);
  638. }
  639. else if (mJumpNextArrowBtn && mJumpNextArrowBtn->getRect().pointInRect(x, y))
  640. {
  641. S32 local_x = x - mJumpNextArrowBtn->getRect().mLeft;
  642. S32 local_y = y - mJumpNextArrowBtn->getRect().mBottom;
  643. handled = mJumpNextArrowBtn->handleMouseUp(local_x, local_y, mask);
  644. }
  645. else if (mPrevArrowBtn && mPrevArrowBtn->getRect().pointInRect(x, y))
  646. {
  647. S32 local_x = x - mPrevArrowBtn->getRect().mLeft;
  648. S32 local_y = y - mPrevArrowBtn->getRect().mBottom;
  649. handled = mPrevArrowBtn->handleMouseUp(local_x, local_y, mask);
  650. }
  651. else if (mNextArrowBtn && mNextArrowBtn->getRect().pointInRect(x, y))
  652. {
  653. S32 local_x = x - mNextArrowBtn->getRect().mLeft;
  654. S32 local_y = y - mNextArrowBtn->getRect().mBottom;
  655. handled = mNextArrowBtn->handleMouseUp(local_x, local_y, mask);
  656. }
  657. }
  658. if (!handled)
  659. {
  660. handled = LLPanel::handleMouseUp( x, y, mask );
  661. }
  663. commitHoveredButton(x, y);
  664. LLPanel* cur_panel = getCurrentPanel();
  665. if (hasMouseCapture())
  666. {
  667. if (cur_panel)
  668. {
  669. if (!cur_panel->focusFirstItem(FALSE))
  670. {
  671. // if nothing in the panel gets focus, make sure the new tab does
  672. // otherwise the last tab might keep focus
  673. getTab(getCurrentPanelIndex())->mButton->setFocus(TRUE);
  674. }
  675. }
  676. gFocusMgr.setMouseCapture(NULL);
  677. }
  678. return handled;
  679. }
  681. // virtual
  682. BOOL LLTabContainer::handleToolTip( S32 x, S32 y, MASK mask)
  683. {
  684. static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
  685. BOOL handled = LLPanel::handleToolTip( x, y, mask);
  686. if (!handled && getTabCount() > 0) 
  687. {
  688. LLTabTuple* firsttuple = getTab(0);
  690. BOOL has_scroll_arrows = (getMaxScrollPos() > 0);
  691. LLRect clip;
  692. if (mIsVertical)
  693. {
  694. clip = LLRect(firsttuple->mButton->getRect().mLeft,
  695.   has_scroll_arrows ? mPrevArrowBtn->getRect().mBottom - tabcntrv_pad : mPrevArrowBtn->getRect().mTop,
  696.   firsttuple->mButton->getRect().mRight,
  697.   has_scroll_arrows ? mNextArrowBtn->getRect().mTop + tabcntrv_pad : mNextArrowBtn->getRect().mBottom );
  698. }
  699. else
  700. {
  701. clip = LLRect(has_scroll_arrows ? mPrevArrowBtn->getRect().mRight : mJumpPrevArrowBtn->getRect().mLeft,
  702.   firsttuple->mButton->getRect().mTop,
  703.   has_scroll_arrows ? mNextArrowBtn->getRect().mLeft : mJumpNextArrowBtn->getRect().mRight,
  704.   firsttuple->mButton->getRect().mBottom );
  705. }
  707. if( clip.pointInRect( x, y ) )
  708. {
  709. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  710. {
  711. LLTabTuple* tuple = *iter;
  712. tuple->mButton->setVisible( TRUE );
  713. S32 local_x = x - tuple->mButton->getRect().mLeft;
  714. S32 local_y = y - tuple->mButton->getRect().mBottom;
  715. handled = tuple->mButton->handleToolTip( local_x, local_y, mask);
  716. if( handled )
  717. {
  718. break;
  719. }
  720. }
  721. }
  722. }
  723. return handled;
  724. }
  726. // virtual
  727. BOOL LLTabContainer::handleKeyHere(KEY key, MASK mask)
  728. {
  729. BOOL handled = FALSE;
  730. if (key == KEY_LEFT && mask == MASK_ALT)
  731. {
  732. selectPrevTab();
  733. handled = TRUE;
  734. }
  735. else if (key == KEY_RIGHT && mask == MASK_ALT)
  736. {
  737. selectNextTab();
  738. handled = TRUE;
  739. }
  741. if (handled)
  742. {
  743. if (getCurrentPanel())
  744. {
  745. getCurrentPanel()->setFocus(TRUE);
  746. }
  747. }
  749. if (!gFocusMgr.childHasKeyboardFocus(getCurrentPanel()))
  750. {
  751. // if child has focus, but not the current panel, focus is on a button
  752. if (mIsVertical)
  753. {
  754. switch(key)
  755. {
  756.   case KEY_UP:
  757. selectPrevTab();
  758. handled = TRUE;
  759. break;
  760.   case KEY_DOWN:
  761. selectNextTab();
  762. handled = TRUE;
  763. break;
  764.   case KEY_LEFT:
  765. handled = TRUE;
  766. break;
  767.   case KEY_RIGHT:
  768. if (getTabPosition() == LEFT && getCurrentPanel())
  769. {
  770. getCurrentPanel()->setFocus(TRUE);
  771. }
  772. handled = TRUE;
  773. break;
  774.   default:
  775. break;
  776. }
  777. }
  778. else
  779. {
  780. switch(key)
  781. {
  782.   case KEY_UP:
  783. if (getTabPosition() == BOTTOM && getCurrentPanel())
  784. {
  785. getCurrentPanel()->setFocus(TRUE);
  786. }
  787. handled = TRUE;
  788. break;
  789.   case KEY_DOWN:
  790. if (getTabPosition() == TOP && getCurrentPanel())
  791. {
  792. getCurrentPanel()->setFocus(TRUE);
  793. }
  794. handled = TRUE;
  795. break;
  796.   case KEY_LEFT:
  797. selectPrevTab();
  798. handled = TRUE;
  799. break;
  800.   case KEY_RIGHT:
  801. selectNextTab();
  802. handled = TRUE;
  803. break;
  804.   default:
  805. break;
  806. }
  807. }
  808. }
  809. return handled;
  810. }
  812. // virtual
  813. BOOL LLTabContainer::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, EDragAndDropType type, void* cargo_data, EAcceptance *accept, std::string &tooltip)
  814. {
  815. BOOL has_scroll_arrows = (getMaxScrollPos() > 0);
  817. if( mDragAndDropDelayTimer.getStarted() && mDragAndDropDelayTimer.getElapsedTimeF32() > SCROLL_DELAY_TIME )
  818. {
  819. if (has_scroll_arrows)
  820. {
  821. if (mJumpPrevArrowBtn && mJumpPrevArrowBtn->getRect().pointInRect(x, y))
  822. {
  823. S32 local_x = x - mJumpPrevArrowBtn->getRect().mLeft;
  824. S32 local_y = y - mJumpPrevArrowBtn->getRect().mBottom;
  825. mJumpPrevArrowBtn->handleHover(local_x, local_y, mask);
  826. }
  827. if (mJumpNextArrowBtn && mJumpNextArrowBtn->getRect().pointInRect(x, y))
  828. {
  829. S32 local_x = x - mJumpNextArrowBtn->getRect().mLeft;
  830. S32 local_y = y - mJumpNextArrowBtn->getRect().mBottom;
  831. mJumpNextArrowBtn->handleHover(local_x, local_y, mask);
  832. }
  833. if (mPrevArrowBtn->getRect().pointInRect(x, y))
  834. {
  835. S32 local_x = x - mPrevArrowBtn->getRect().mLeft;
  836. S32 local_y = y - mPrevArrowBtn->getRect().mBottom;
  837. mPrevArrowBtn->handleHover(local_x, local_y, mask);
  838. }
  839. else if (mNextArrowBtn->getRect().pointInRect(x, y))
  840. {
  841. S32 local_x = x - mNextArrowBtn->getRect().mLeft;
  842. S32 local_y = y - mNextArrowBtn->getRect().mBottom;
  843. mNextArrowBtn->handleHover(local_x, local_y, mask);
  844. }
  845. }
  847. for(tuple_list_t::iterator iter = mTabList.begin(); iter !=  mTabList.end(); ++iter)
  848. {
  849. LLTabTuple* tuple = *iter;
  850. tuple->mButton->setVisible( TRUE );
  851. S32 local_x = x - tuple->mButton->getRect().mLeft;
  852. S32 local_y = y - tuple->mButton->getRect().mBottom;
  853. if (tuple->mButton->pointInView(local_x, local_y) &&  tuple->mButton->getEnabled() && !tuple->mTabPanel->getVisible())
  854. {
  855. tuple->mButton->onCommit();
  856. mDragAndDropDelayTimer.stop();
  857. }
  858. }
  859. }
  861. return LLView::handleDragAndDrop(x, y, mask, drop, type, cargo_data,  accept, tooltip);
  862. }
  864. void LLTabContainer::addTabPanel(LLPanel* panelp)
  865. {
  866. addTabPanel(TabPanelParams().panel(panelp));
  867. }
  869. // function to update images
  870. void LLTabContainer::update_images(LLTabTuple* tuple, TabParams params, LLTabContainer::TabPosition pos)
  871. {
  872. if (tuple && tuple->mButton)
  873. {
  874. if (pos == LLTabContainer::TOP)
  875. {
  876. tuple->mButton->setImageUnselected(static_cast<LLUIImage*>(params.tab_top_image_unselected));
  877. tuple->mButton->setImageSelected(static_cast<LLUIImage*>(params.tab_top_image_selected));
  878. }
  879. else if (pos == LLTabContainer::BOTTOM)
  880. {
  881. tuple->mButton->setImageUnselected(static_cast<LLUIImage*>(params.tab_bottom_image_unselected));
  882. tuple->mButton->setImageSelected(static_cast<LLUIImage*>(params.tab_bottom_image_selected));
  883. }
  884. else if (pos == LLTabContainer::LEFT)
  885. {
  886. tuple->mButton->setImageUnselected(static_cast<LLUIImage*>(params.tab_left_image_unselected));
  887. tuple->mButton->setImageSelected(static_cast<LLUIImage*>(params.tab_left_image_selected));
  888. }
  889. }
  890. }
  892. void LLTabContainer::addTabPanel(const TabPanelParams& panel)
  893. {
  894. LLPanel* child = panel.panel();
  896. llassert(child);
  897. if (!child) return;
  899. const std::string& label = panel.label.isProvided() 
  900. ? panel.label() 
  901. : panel.panel()->getLabel();
  902. BOOL select = panel.select_tab(); 
  903. S32 indent = panel.indent();
  904. BOOL placeholder = panel.is_placeholder;
  905. eInsertionPoint insertion_point = panel.insert_at();
  907. static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
  908. static LLUICachedControl<S32> tabcntr_button_panel_overlap ("UITabCntrButtonPanelOverlap", 0);
  909. static LLUICachedControl<S32> tab_padding ("UITabPadding", 0);
  910. if (child->getParent() == this)
  911. {
  912. // already a child of mine
  913. return;
  914. }
  916. // Store the original label for possible xml export.
  917. child->setLabel(label);
  918. std::string trimmed_label = label;
  919. LLStringUtil::trim(trimmed_label);
  921. S32 button_width = mMinTabWidth;
  922. if (!mIsVertical)
  923. {
  924. button_width = llclamp(mFont->getWidth(trimmed_label) + tab_padding, mMinTabWidth, mMaxTabWidth);
  925. }
  927. // Tab panel
  928. S32 tab_panel_top;
  929. S32 tab_panel_bottom;
  930. if (!getTabsHidden()) 
  931. {
  932. if( getTabPosition() == LLTabContainer::TOP )
  933. {
  934. S32 tab_height = mIsVertical ? BTN_HEIGHT : mTabHeight;
  935. tab_panel_top = getRect().getHeight() - getTopBorderHeight() - (tab_height - tabcntr_button_panel_overlap);
  936. tab_panel_bottom = LLPANEL_BORDER_WIDTH;
  937. }
  938. else
  939. {
  940. tab_panel_top = getRect().getHeight() - getTopBorderHeight();
  941. tab_panel_bottom = (mTabHeight - tabcntr_button_panel_overlap);  // Run to the edge, covering up the border
  942. }
  943. }
  944. else
  945. {
  946. //Scip tab button space if they are invisible(EXT - 576)
  947. tab_panel_top = getRect().getHeight();
  948. tab_panel_bottom = LLPANEL_BORDER_WIDTH;
  949. }
  951. LLRect tab_panel_rect;
  952. if (!getTabsHidden() && mIsVertical)
  953. {
  954. tab_panel_rect = LLRect(mMinTabWidth + (LLPANEL_BORDER_WIDTH * 2) + tabcntrv_pad, 
  955. getRect().getHeight() - LLPANEL_BORDER_WIDTH,
  956. getRect().getWidth() - LLPANEL_BORDER_WIDTH,
  957. LLPANEL_BORDER_WIDTH);
  958. }
  959. else
  960. {
  961. tab_panel_rect = LLRect(LLPANEL_BORDER_WIDTH, 
  962. tab_panel_top,
  963. getRect().getWidth()-LLPANEL_BORDER_WIDTH,
  964. tab_panel_bottom );
  965. }
  966. child->setFollowsAll();
  967. child->translate( tab_panel_rect.mLeft - child->getRect().mLeft, tab_panel_rect.mBottom - child->getRect().mBottom);
  968. child->reshape( tab_panel_rect.getWidth(), tab_panel_rect.getHeight(), TRUE );
  969. // add this child later
  971. child->setVisible( FALSE );  // Will be made visible when selected
  973. mTotalTabWidth += button_width;
  975. // Tab button
  976. LLRect btn_rect;  // Note: btn_rect.mLeft is just a dummy.  Will be updated in draw().
  977. LLUIImage* tab_img = NULL;
  978. LLUIImage* tab_selected_img = NULL;
  979. S32 tab_fudge = 1; //  To make new tab art look better, nudge buttons up 1 pel
  981. if (mIsVertical)
  982. {
  983. btn_rect.setLeftTopAndSize(tabcntrv_pad + LLPANEL_BORDER_WIDTH + 2, // JC - Fudge factor
  984.    (getRect().getHeight() - getTopBorderHeight() - LLPANEL_BORDER_WIDTH - 1) - ((BTN_HEIGHT + tabcntrv_pad) * getTabCount()),
  985.    mMinTabWidth,
  986.    BTN_HEIGHT);
  987. }
  988. else if( getTabPosition() == LLTabContainer::TOP )
  989. {
  990. btn_rect.setLeftTopAndSize( 0, getRect().getHeight() - getTopBorderHeight() + tab_fudge, button_width, mTabHeight);
  991. tab_img = mMiddleTabParams.tab_top_image_unselected;
  992. tab_selected_img = mMiddleTabParams.tab_top_image_selected; 
  993. }
  994. else
  995. {
  996. btn_rect.setOriginAndSize( 0, 0 + tab_fudge, button_width, mTabHeight);
  997. tab_img = mMiddleTabParams.tab_bottom_image_unselected;
  998. tab_selected_img = mMiddleTabParams.tab_bottom_image_selected;
  999. }
  1001. LLTextBox* textbox = NULL;
  1002. LLButton* btn = NULL;
  1003. LLCustomButtonIconCtrl::Params custom_btn_params;
  1004. {
  1005. custom_btn_params.icon_ctrl_pad(mTabIconCtrlPad);
  1006. }
  1007. LLButton::Params normal_btn_params;
  1009. if (placeholder)
  1010. {
  1011. btn_rect.translate(0, -6); // *TODO: make configurable
  1012. LLTextBox::Params params;
  1013. params.name(trimmed_label);
  1014. params.rect(btn_rect);
  1015. params.initial_value(trimmed_label);
  1016. params.font(mFont);
  1017. textbox = LLUICtrlFactory::create<LLTextBox> (params);
  1019. LLButton::Params p;
  1020. p.name("placeholder");
  1021. btn = LLUICtrlFactory::create<LLButton>(p);
  1022. }
  1023. else
  1024. {
  1025. if (mIsVertical)
  1026. {
  1027. LLButton::Params& p = (mCustomIconCtrlUsed)?
  1028. custom_btn_params:normal_btn_params;
  1030. p.name(std::string("vert tab button"));
  1031. p.rect(btn_rect);
  1032. p.follows.flags(FOLLOWS_TOP | FOLLOWS_LEFT);
  1033. p.click_callback.function(boost::bind(&LLTabContainer::onTabBtn, this, _2, child));
  1034. p.font(mFont);
  1035. p.label(trimmed_label);
  1036. p.image_unselected(mMiddleTabParams.tab_left_image_unselected);
  1037. p.image_selected(mMiddleTabParams.tab_left_image_selected);
  1038. p.scale_image(true);
  1039. p.font_halign = mFontHalign;
  1040. p.pad_bottom( mLabelPadBottom );
  1041. p.tab_stop(false);
  1042. p.label_shadow(false);
  1043. if (indent)
  1044. {
  1045. p.pad_left(indent);
  1046. }
  1049. if(mCustomIconCtrlUsed)
  1050. {
  1051. btn = LLUICtrlFactory::create<LLCustomButtonIconCtrl>(custom_btn_params);
  1053. }
  1054. else
  1055. {
  1056. btn = LLUICtrlFactory::create<LLButton>(p);
  1057. }
  1058. }
  1059. else
  1060. {
  1061. LLButton::Params& p = (mCustomIconCtrlUsed)?
  1062. custom_btn_params:normal_btn_params;
  1063. p.name(std::string(child->getName()) + " tab");
  1064. p.rect(btn_rect);
  1065. p.click_callback.function(boost::bind(&LLTabContainer::onTabBtn, this, _2, child));
  1066. p.font(mFont);
  1067. p.label(trimmed_label);
  1068. p.visible(false);
  1069. p.scale_image(true);
  1070. p.image_unselected(tab_img);
  1071. p.image_selected(tab_selected_img);
  1072. p.tab_stop(false);
  1073. p.label_shadow(false);
  1074. // Try to squeeze in a bit more text
  1075. p.pad_left( mLabelPadLeft );
  1076. p.pad_right(2);
  1077. p.pad_bottom( mLabelPadBottom );
  1078. p.font_halign = mFontHalign;
  1079. p.follows.flags = FOLLOWS_LEFT;
  1080. p.follows.flags = FOLLOWS_LEFT;
  1082. if (indent)
  1083. {
  1084. p.pad_left(indent);
  1085. }
  1087. if( getTabPosition() == TOP )
  1088. {
  1089. p.follows.flags = p.follows.flags() | FOLLOWS_TOP;
  1090. }
  1091. else
  1092. {
  1093. p.follows.flags = p.follows.flags() | FOLLOWS_BOTTOM;
  1094. }
  1096. if(mCustomIconCtrlUsed)
  1097. {
  1098. btn = LLUICtrlFactory::create<LLCustomButtonIconCtrl>(custom_btn_params);
  1099. }
  1100. else
  1101. {
  1102. btn = LLUICtrlFactory::create<LLButton>(p);
  1103. }
  1104. }
  1105. }
  1107. LLTabTuple* tuple = new LLTabTuple( this, child, btn, textbox );
  1108. insertTuple( tuple, insertion_point );
  1110. // if new tab was added as a first or last tab, update button image 
  1111. // and update button image of any tab it may have affected
  1112. if (tuple == mTabList.front())
  1113. {  
  1114. update_images(tuple, mFirstTabParams, getTabPosition());
  1116. if (mTabList.size() == 2) 
  1117. {
  1118. update_images(mTabList[1], mLastTabParams, getTabPosition());
  1119. }
  1120. else if (mTabList.size() > 2) 
  1121. {
  1122. update_images(mTabList[1], mMiddleTabParams, getTabPosition());
  1123. }
  1124. }
  1125. else if (tuple == mTabList.back())
  1126. {
  1127. update_images(tuple, mLastTabParams, getTabPosition());
  1129. if (mTabList.size() > 2)
  1130. {
  1131. update_images(mTabList[mTabList.size()-2], mMiddleTabParams, getTabPosition());
  1132. }
  1133. }
  1135. //Don't add button and textbox if tab buttons are invisible(EXT - 576)
  1136. if (!getTabsHidden())
  1137. {
  1138. if (textbox)
  1139. {
  1140. addChild( textbox, 0 );
  1141. }
  1142. if (btn)
  1143. {
  1144. addChild( btn, 0 );
  1145. }
  1146. }
  1148. if (child)
  1149. {
  1150. LLUICtrl::addChild(child, 1);
  1151. }
  1153. sendChildToFront(mPrevArrowBtn);
  1154. sendChildToFront(mNextArrowBtn);
  1155. sendChildToFront(mJumpPrevArrowBtn);
  1156. sendChildToFront(mJumpNextArrowBtn);
  1158. if( select )
  1159. {
  1160. selectLastTab();
  1161. }
  1163. updateMaxScrollPos();
  1164. }
  1166. void LLTabContainer::addPlaceholder(LLPanel* child, const std::string& label)
  1167. {
  1168. addTabPanel(TabPanelParams().panel(child).label(label).is_placeholder(true));
  1169. }
  1171. void LLTabContainer::removeTabPanel(LLPanel* child)
  1172. {
  1173. static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
  1174. if (mIsVertical)
  1175. {
  1176. // Fix-up button sizes
  1177. S32 tab_count = 0;
  1178. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  1179. {
  1180. LLTabTuple* tuple = *iter;
  1181. LLRect rect;
  1182. rect.setLeftTopAndSize(tabcntrv_pad + LLPANEL_BORDER_WIDTH + 2, // JC - Fudge factor
  1183.    (getRect().getHeight() - LLPANEL_BORDER_WIDTH - 1) - ((BTN_HEIGHT + tabcntrv_pad) * (tab_count)),
  1184.    mMinTabWidth,
  1185.    BTN_HEIGHT);
  1186. if (tuple->mPlaceholderText)
  1187. {
  1188. tuple->mPlaceholderText->setRect(rect);
  1189. }
  1190. else
  1191. {
  1192. tuple->mButton->setRect(rect);
  1193. }
  1194. tab_count++;
  1195. }
  1196. }
  1197. else
  1198. {
  1199. // Adjust the total tab width.
  1200. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  1201. {
  1202. LLTabTuple* tuple = *iter;
  1203. if( tuple->mTabPanel == child )
  1204. {
  1205. mTotalTabWidth -= tuple->mButton->getRect().getWidth();
  1206. break;
  1207. }
  1208. }
  1209. }
  1211. BOOL has_focus = gFocusMgr.childHasKeyboardFocus(this);
  1213. // If the tab being deleted is the selected one, select a different tab.
  1214. for(std::vector<LLTabTuple*>::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  1215. {
  1216. LLTabTuple* tuple = *iter;
  1217. if( tuple->mTabPanel == child )
  1218. {
  1219. // update tab button images if removing the first or last tab
  1220. if ((tuple == mTabList.front()) && (mTabList.size() > 1))
  1221. {
  1222. update_images(mTabList[1], mFirstTabParams, getTabPosition());
  1223. }
  1224. else if ((tuple == mTabList.back()) && (mTabList.size() > 2))
  1225. {
  1226. update_images(mTabList[mTabList.size()-2], mLastTabParams, getTabPosition());
  1227. }
  1229. removeChild( tuple->mButton );
  1230.   delete tuple->mButton;
  1232.   removeChild( tuple->mTabPanel );
  1233. //  delete tuple->mTabPanel;
  1235. mTabList.erase( iter );
  1236. delete tuple;
  1238. break;
  1239. }
  1240. }
  1242. // make sure we don't have more locked tabs than we have tabs
  1243. mLockedTabCount = llmin(getTabCount(), mLockedTabCount);
  1245. if (mCurrentTabIdx >= (S32)mTabList.size())
  1246. {
  1247. mCurrentTabIdx = mTabList.size()-1;
  1248. }
  1249. selectTab(mCurrentTabIdx);
  1250. if (has_focus)
  1251. {
  1252. LLPanel* panelp = getPanelByIndex(mCurrentTabIdx);
  1253. if (panelp)
  1254. {
  1255. panelp->setFocus(TRUE);
  1256. }
  1257. }
  1259. updateMaxScrollPos();
  1260. }
  1262. void LLTabContainer::lockTabs(S32 num_tabs)
  1263. {
  1264. // count current tabs or use supplied value and ensure no new tabs get
  1265. // inserted between them
  1266. mLockedTabCount = num_tabs > 0 ? llmin(getTabCount(), num_tabs) : getTabCount();
  1267. }
  1269. void LLTabContainer::unlockTabs()
  1270. {
  1271. mLockedTabCount = 0;
  1272. }
  1274. void LLTabContainer::enableTabButton(S32 which, BOOL enable)
  1275. {
  1276. if (which >= 0 && which < (S32)mTabList.size())
  1277. {
  1278. mTabList[which]->mButton->setEnabled(enable);
  1279. }
  1280. }
  1282. void LLTabContainer::deleteAllTabs()
  1283. {
  1284. // Remove all the tab buttons and delete them.  Also, unlink all the child panels.
  1285. for(std::vector<LLTabTuple*>::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  1286. {
  1287. LLTabTuple* tuple = *iter;
  1289. removeChild( tuple->mButton );
  1290. delete tuple->mButton;
  1292.   removeChild( tuple->mTabPanel );
  1293. //  delete tuple->mTabPanel;
  1294. }
  1296. // Actually delete the tuples themselves
  1297. std::for_each(mTabList.begin(), mTabList.end(), DeletePointer());
  1298. mTabList.clear();
  1300. // And there isn't a current tab any more
  1301. mCurrentTabIdx = -1;
  1302. }
  1304. LLPanel* LLTabContainer::getCurrentPanel()
  1305. {
  1306. if (mCurrentTabIdx >= 0 && mCurrentTabIdx < (S32) mTabList.size())
  1307. {
  1308. return mTabList[mCurrentTabIdx]->mTabPanel;
  1309. }
  1310. return NULL;
  1311. }
  1313. S32 LLTabContainer::getCurrentPanelIndex()
  1314. {
  1315. return mCurrentTabIdx;
  1316. }
  1318. S32 LLTabContainer::getTabCount()
  1319. {
  1320. return mTabList.size();
  1321. }
  1323. LLPanel* LLTabContainer::getPanelByIndex(S32 index)
  1324. {
  1325. if (index >= 0 && index < (S32)mTabList.size())
  1326. {
  1327. return mTabList[index]->mTabPanel;
  1328. }
  1329. return NULL;
  1330. }
  1332. S32 LLTabContainer::getIndexForPanel(LLPanel* panel)
  1333. {
  1334. for (S32 index = 0; index < (S32)mTabList.size(); index++)
  1335. {
  1336. if (mTabList[index]->mTabPanel == panel)
  1337. {
  1338. return index;
  1339. }
  1340. }
  1341. return -1;
  1342. }
  1344. S32 LLTabContainer::getPanelIndexByTitle(const std::string& title)
  1345. {
  1346. for (S32 index = 0 ; index < (S32)mTabList.size(); index++)
  1347. {
  1348. if (title == mTabList[index]->mButton->getLabelSelected())
  1349. {
  1350. return index;
  1351. }
  1352. }
  1353. return -1;
  1354. }
  1356. LLPanel* LLTabContainer::getPanelByName(const std::string& name)
  1357. {
  1358. for (S32 index = 0 ; index < (S32)mTabList.size(); index++)
  1359. {
  1360. LLPanel *panel = mTabList[index]->mTabPanel;
  1361. if (name == panel->getName())
  1362. {
  1363. return panel;
  1364. }
  1365. }
  1366. return NULL;
  1367. }
  1369. // Change the name of the button for the current tab.
  1370. void LLTabContainer::setCurrentTabName(const std::string& name)
  1371. {
  1372. // Might not have a tab selected
  1373. if (mCurrentTabIdx < 0) return;
  1375. mTabList[mCurrentTabIdx]->mButton->setLabelSelected(name);
  1376. mTabList[mCurrentTabIdx]->mButton->setLabelUnselected(name);
  1377. }
  1379. void LLTabContainer::selectFirstTab()
  1380. {
  1381. selectTab( 0 );
  1382. }
  1385. void LLTabContainer::selectLastTab()
  1386. {
  1387. selectTab( mTabList.size()-1 );
  1388. }
  1390. void LLTabContainer::selectNextTab()
  1391. {
  1392. BOOL tab_has_focus = FALSE;
  1393. if (mCurrentTabIdx >= 0 && mTabList[mCurrentTabIdx]->mButton->hasFocus())
  1394. {
  1395. tab_has_focus = TRUE;
  1396. }
  1397. S32 idx = mCurrentTabIdx+1;
  1398. if (idx >= (S32)mTabList.size())
  1399. idx = 0;
  1400. while (!selectTab(idx) && idx != mCurrentTabIdx)
  1401. {
  1402. idx = (idx + 1 ) % (S32)mTabList.size();
  1403. }
  1405. if (tab_has_focus)
  1406. {
  1407. mTabList[idx]->mButton->setFocus(TRUE);
  1408. }
  1409. }
  1411. void LLTabContainer::selectPrevTab()
  1412. {
  1413. BOOL tab_has_focus = FALSE;
  1414. if (mCurrentTabIdx >= 0 && mTabList[mCurrentTabIdx]->mButton->hasFocus())
  1415. {
  1416. tab_has_focus = TRUE;
  1417. }
  1418. S32 idx = mCurrentTabIdx-1;
  1419. if (idx < 0)
  1420. idx = mTabList.size()-1;
  1421. while (!selectTab(idx) && idx != mCurrentTabIdx)
  1422. {
  1423. idx = idx - 1;
  1424. if (idx < 0)
  1425. idx = mTabList.size()-1;
  1426. }
  1427. if (tab_has_focus)
  1428. {
  1429. mTabList[idx]->mButton->setFocus(TRUE);
  1430. }
  1431. }
  1433. BOOL LLTabContainer::selectTabPanel(LLPanel* child)
  1434. {
  1435. S32 idx = 0;
  1436. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  1437. {
  1438. LLTabTuple* tuple = *iter;
  1439. if( tuple->mTabPanel == child )
  1440. {
  1441. return selectTab( idx );
  1442. }
  1443. idx++;
  1444. }
  1445. return FALSE;
  1446. }
  1448. BOOL LLTabContainer::selectTab(S32 which)
  1449. {
  1450. if (which >= getTabCount() || which < 0)
  1451. return FALSE;
  1453. LLTabTuple* selected_tuple = getTab(which);
  1454. if (!selected_tuple)
  1455. {
  1456. return FALSE;
  1457. }
  1459. LLSD cbdata;
  1460. if (selected_tuple->mTabPanel)
  1461. cbdata = selected_tuple->mTabPanel->getName();
  1463. BOOL res = FALSE;
  1464. if( !mValidateSignal || (*mValidateSignal)( this, cbdata ) )
  1465. {
  1466. res = setTab(which);
  1467. if (res && mCommitSignal)
  1468. {
  1469. (*mCommitSignal)(this, cbdata);
  1470. }
  1471. }
  1473. return res;
  1474. }
  1476. // private
  1477. BOOL LLTabContainer::setTab(S32 which)
  1478. {
  1479. static LLUICachedControl<S32> tabcntr_arrow_btn_size ("UITabCntrArrowBtnSize", 0);
  1480. LLTabTuple* selected_tuple = getTab(which);
  1481. if (!selected_tuple)
  1482. {
  1483. return FALSE;
  1484. }
  1486. BOOL is_visible = FALSE;
  1487. if (selected_tuple->mButton->getEnabled())
  1488. {
  1489. setCurrentPanelIndex(which);
  1491. S32 i = 0;
  1492. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  1493. {
  1494. LLTabTuple* tuple = *iter;
  1495. BOOL is_selected = ( tuple == selected_tuple );
  1496. tuple->mButton->setUseEllipses(mUseTabEllipses);
  1497. tuple->mButton->setHAlign(mFontHalign);
  1498. tuple->mTabPanel->setVisible( is_selected );
  1499. //  tuple->mTabPanel->setFocus(is_selected); // not clear that we want to do this here.
  1500. tuple->mButton->setToggleState( is_selected );
  1501. // RN: this limits tab-stops to active button only, which would require arrow keys to switch tabs
  1502. tuple->mButton->setTabStop( is_selected );
  1504. if (is_selected)
  1505. {
  1506. // Make sure selected tab is within scroll region
  1507. if (mIsVertical)
  1508. {
  1509. S32 num_visible = getTabCount() - getMaxScrollPos();
  1510. if( i >= getScrollPos() && i <= getScrollPos() + num_visible)
  1511. {
  1512. setCurrentPanelIndex(which);
  1513. is_visible = TRUE;
  1514. }
  1515. else
  1516. {
  1517. is_visible = FALSE;
  1518. }
  1519. }
  1520. else if (getMaxScrollPos() > 0)
  1521. {
  1522. if( i < getScrollPos() )
  1523. {
  1524. setScrollPos(i);
  1525. }
  1526. else
  1527. {
  1528. S32 available_width_with_arrows = getRect().getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + tabcntr_arrow_btn_size  + tabcntr_arrow_btn_size + 1);
  1529. S32 running_tab_width = tuple->mButton->getRect().getWidth();
  1530. S32 j = i - 1;
  1531. S32 min_scroll_pos = i;
  1532. if (running_tab_width < available_width_with_arrows)
  1533. {
  1534. while (j >= 0)
  1535. {
  1536. LLTabTuple* other_tuple = getTab(j);
  1537. running_tab_width += other_tuple->mButton->getRect().getWidth();
  1538. if (running_tab_width > available_width_with_arrows)
  1539. {
  1540. break;
  1541. }
  1542. j--;
  1543. }
  1544. min_scroll_pos = j + 1;
  1545. }
  1546. setScrollPos(llclamp(getScrollPos(), min_scroll_pos, i));
  1547. setScrollPos(llmin(getScrollPos(), getMaxScrollPos()));
  1548. }
  1549. is_visible = TRUE;
  1550. }
  1551. else
  1552. {
  1553. is_visible = TRUE;
  1554. }
  1555. }
  1556. i++;
  1557. }
  1558. }
  1559. if (mIsVertical && getCurrentPanelIndex() >= 0)
  1560. {
  1561. LLTabTuple* tuple = getTab(getCurrentPanelIndex());
  1562. tuple->mTabPanel->setVisible( TRUE );
  1563. tuple->mButton->setToggleState( TRUE );
  1564. }
  1565. return is_visible;
  1566. }
  1568. BOOL LLTabContainer::selectTabByName(const std::string& name)
  1569. {
  1570. LLPanel* panel = getPanelByName(name);
  1571. if (!panel)
  1572. {
  1573. llwarns << "LLTabContainer::selectTabByName("
  1574. << name << ") failed" << llendl;
  1575. return FALSE;
  1576. }
  1578. BOOL result = selectTabPanel(panel);
  1579. return result;
  1580. }
  1582. BOOL LLTabContainer::getTabPanelFlashing(LLPanel *child)
  1583. {
  1584. LLTabTuple* tuple = getTabByPanel(child);
  1585. if( tuple )
  1586. {
  1587. return tuple->mButton->getFlashing();
  1588. }
  1589. return FALSE;
  1590. }
  1592. void LLTabContainer::setTabPanelFlashing(LLPanel* child, BOOL state )
  1593. {
  1594. LLTabTuple* tuple = getTabByPanel(child);
  1595. if( tuple )
  1596. {
  1597. tuple->mButton->setFlashing( state );
  1598. }
  1599. }
  1601. void LLTabContainer::setTabImage(LLPanel* child, std::string image_name, const LLColor4& color)
  1602. {
  1603. LLTabTuple* tuple = getTabByPanel(child);
  1604. if( tuple )
  1605. {
  1606. tuple->mButton->setImageOverlay(image_name, LLFontGL::LEFT, color);
  1607. reshapeTuple(tuple);
  1608. }
  1609. }
  1611. void LLTabContainer::setTabImage(LLPanel* child, const LLUUID& image_id, const LLColor4& color)
  1612. {
  1613. LLTabTuple* tuple = getTabByPanel(child);
  1614. if( tuple )
  1615. {
  1616. tuple->mButton->setImageOverlay(image_id, LLFontGL::LEFT, color);
  1617. reshapeTuple(tuple);
  1618. }
  1619. }
  1621. void LLTabContainer::setTabImage(LLPanel* child, LLIconCtrl* icon)
  1622. {
  1623. LLTabTuple* tuple = getTabByPanel(child);
  1624. LLCustomButtonIconCtrl* button;
  1626. if(tuple)
  1627. {
  1628. button = dynamic_cast<LLCustomButtonIconCtrl*>(tuple->mButton);
  1629. if(button)
  1630. {
  1631. button->setIcon(icon);
  1632. }
  1633. }
  1634. }
  1636. void LLTabContainer::reshapeTuple(LLTabTuple* tuple)
  1637. {
  1638. static LLUICachedControl<S32> tab_padding ("UITabPadding", 0);
  1640. if (!mIsVertical)
  1641. {
  1642. // remove current width from total tab strip width
  1643. mTotalTabWidth -= tuple->mButton->getRect().getWidth();
  1645. S32 image_overlay_width = tuple->mButton->getImageOverlay().notNull() ?
  1646. tuple->mButton->getImageOverlay()->getImage()->getWidth(0) : 0;
  1648. tuple->mPadding = image_overlay_width;
  1650. tuple->mButton->reshape(llclamp(mFont->getWidth(tuple->mButton->getLabelSelected()) + tab_padding + tuple->mPadding, mMinTabWidth, mMaxTabWidth),
  1651. tuple->mButton->getRect().getHeight());
  1652. // add back in button width to total tab strip width
  1653. mTotalTabWidth += tuple->mButton->getRect().getWidth();
  1655. // tabs have changed size, might need to scroll to see current tab
  1656. updateMaxScrollPos();
  1657. }
  1658. }
  1660. void LLTabContainer::setTitle(const std::string& title)
  1661. {
  1662. if (mTitleBox)
  1663. {
  1664. mTitleBox->setText( title );
  1665. }
  1666. }
  1668. const std::string LLTabContainer::getPanelTitle(S32 index)
  1669. {
  1670. if (index >= 0 && index < (S32)mTabList.size())
  1671. {
  1672. LLButton* tab_button = mTabList[index]->mButton;
  1673. return tab_button->getLabelSelected();
  1674. }
  1675. return LLStringUtil::null;
  1676. }
  1678. void LLTabContainer::setTopBorderHeight(S32 height)
  1679. {
  1680. mTopBorderHeight = height;
  1681. }
  1683. S32 LLTabContainer::getTopBorderHeight() const
  1684. {
  1685. return mTopBorderHeight;
  1686. }
  1688. void LLTabContainer::setRightTabBtnOffset(S32 offset)
  1689. {
  1690. mNextArrowBtn->translate( -offset - mRightTabBtnOffset, 0 );
  1691. mRightTabBtnOffset = offset;
  1692. updateMaxScrollPos();
  1693. }
  1695. void LLTabContainer::setPanelTitle(S32 index, const std::string& title)
  1696. {
  1697. static LLUICachedControl<S32> tab_padding ("UITabPadding", 0);
  1699. if (index >= 0 && index < getTabCount())
  1700. {
  1701. LLTabTuple* tuple = getTab(index);
  1702. LLButton* tab_button = tuple->mButton;
  1703. const LLFontGL* fontp = LLFontGL::getFontSansSerifSmall();
  1704. mTotalTabWidth -= tab_button->getRect().getWidth();
  1705. tab_button->reshape(llclamp(fontp->getWidth(title) + tab_padding + tuple->mPadding, mMinTabWidth, mMaxTabWidth), tab_button->getRect().getHeight());
  1706. mTotalTabWidth += tab_button->getRect().getWidth();
  1707. tab_button->setLabelSelected(title);
  1708. tab_button->setLabelUnselected(title);
  1709. }
  1710. updateMaxScrollPos();
  1711. }
  1714. void LLTabContainer::onTabBtn( const LLSD& data, LLPanel* panel )
  1715. {
  1716. LLTabTuple* tuple = getTabByPanel(panel);
  1717. selectTabPanel( panel );
  1719. if (tuple)
  1720. {
  1721. tuple->mTabPanel->setFocus(TRUE);
  1722. }
  1723. }
  1725. void LLTabContainer::onNextBtn( const LLSD& data )
  1726. {
  1727. if (!mScrolled)
  1728. {
  1729. scrollNext();
  1730. }
  1731. mScrolled = FALSE;
  1732. }
  1734. void LLTabContainer::onNextBtnHeld( const LLSD& data )
  1735. {
  1736. if (mScrollTimer.getElapsedTimeF32() > SCROLL_STEP_TIME)
  1737. {
  1738. mScrollTimer.reset();
  1739. scrollNext();
  1740. mScrolled = TRUE;
  1741. }
  1742. }
  1744. void LLTabContainer::onPrevBtn( const LLSD& data )
  1745. {
  1746. if (!mScrolled)
  1747. {
  1748. scrollPrev();
  1749. }
  1750. mScrolled = FALSE;
  1751. }
  1753. void LLTabContainer::onJumpFirstBtn( const LLSD& data )
  1754. {
  1755. mScrollPos = 0;
  1756. }
  1758. void LLTabContainer::onJumpLastBtn( const LLSD& data )
  1759. {
  1760. mScrollPos = mMaxScrollPos;
  1761. }
  1763. void LLTabContainer::onPrevBtnHeld( const LLSD& data )
  1764. {
  1765. if (mScrollTimer.getElapsedTimeF32() > SCROLL_STEP_TIME)
  1766. {
  1767. mScrollTimer.reset();
  1768. scrollPrev();
  1769. mScrolled = TRUE;
  1770. }
  1771. }
  1773. // private
  1775. void LLTabContainer::initButtons()
  1776. {
  1777. // Hack:
  1778. if (getRect().getHeight() == 0 || mPrevArrowBtn)
  1779. {
  1780. return; // Don't have a rect yet or already got called
  1781. }
  1783. if (mIsVertical)
  1784. {
  1785. static LLUICachedControl<S32> tabcntrv_arrow_btn_size ("UITabCntrvArrowBtnSize", 0);
  1786. // Left and right scroll arrows (for when there are too many tabs to show all at once).
  1787. S32 btn_top = getRect().getHeight();
  1788. S32 btn_top_lower = getRect().mBottom+tabcntrv_arrow_btn_size;
  1790. LLRect up_arrow_btn_rect;
  1791. up_arrow_btn_rect.setLeftTopAndSize( mMinTabWidth/2 , btn_top, tabcntrv_arrow_btn_size, tabcntrv_arrow_btn_size );
  1793. LLRect down_arrow_btn_rect;
  1794. down_arrow_btn_rect.setLeftTopAndSize( mMinTabWidth/2 , btn_top_lower, tabcntrv_arrow_btn_size, tabcntrv_arrow_btn_size );
  1796. LLButton::Params prev_btn_params;
  1797. prev_btn_params.name(std::string("Up Arrow"));
  1798. prev_btn_params.rect(up_arrow_btn_rect);
  1799. prev_btn_params.follows.flags(FOLLOWS_TOP | FOLLOWS_LEFT);
  1800. prev_btn_params.image_unselected.name("scrollbutton_up_out_blue.tga");
  1801. prev_btn_params.image_selected.name("scrollbutton_up_in_blue.tga");
  1802. prev_btn_params.click_callback.function(boost::bind(&LLTabContainer::onPrevBtn, this, _2));
  1803. mPrevArrowBtn = LLUICtrlFactory::create<LLButton>(prev_btn_params);
  1805. LLButton::Params next_btn_params;
  1806. next_btn_params.name(std::string("Down Arrow"));
  1807. next_btn_params.rect(down_arrow_btn_rect);
  1808. next_btn_params.follows.flags(FOLLOWS_BOTTOM | FOLLOWS_LEFT);
  1809. next_btn_params.image_unselected.name("scrollbutton_down_out_blue.tga");
  1810. next_btn_params.image_selected.name("scrollbutton_down_in_blue.tga");
  1811. next_btn_params.click_callback.function(boost::bind(&LLTabContainer::onNextBtn, this, _2));
  1812. mNextArrowBtn = LLUICtrlFactory::create<LLButton>(next_btn_params);
  1813. }
  1814. else // Horizontal
  1815. {
  1816. static LLUICachedControl<S32> tabcntr_arrow_btn_size ("UITabCntrArrowBtnSize", 0);
  1817. S32 arrow_fudge = 1; //  match new art better 
  1819. // Left and right scroll arrows (for when there are too many tabs to show all at once).
  1820. S32 btn_top = (getTabPosition() == TOP ) ? getRect().getHeight() - getTopBorderHeight() : tabcntr_arrow_btn_size + 1;
  1822. LLRect left_arrow_btn_rect;
  1823. left_arrow_btn_rect.setLeftTopAndSize( LLPANEL_BORDER_WIDTH+1+tabcntr_arrow_btn_size, btn_top + arrow_fudge, tabcntr_arrow_btn_size, mTabHeight );
  1825. LLRect jump_left_arrow_btn_rect;
  1826. jump_left_arrow_btn_rect.setLeftTopAndSize( LLPANEL_BORDER_WIDTH+1, btn_top + arrow_fudge, tabcntr_arrow_btn_size, mTabHeight );
  1828. S32 right_pad = tabcntr_arrow_btn_size + LLPANEL_BORDER_WIDTH + 1;
  1830. LLRect right_arrow_btn_rect;
  1831. right_arrow_btn_rect.setLeftTopAndSize( getRect().getWidth() - mRightTabBtnOffset - right_pad - tabcntr_arrow_btn_size,
  1832. btn_top + arrow_fudge,
  1833. tabcntr_arrow_btn_size, mTabHeight );
  1836. LLRect jump_right_arrow_btn_rect;
  1837. jump_right_arrow_btn_rect.setLeftTopAndSize( getRect().getWidth() - mRightTabBtnOffset - right_pad,
  1838.  btn_top + arrow_fudge,
  1839.  tabcntr_arrow_btn_size, mTabHeight );
  1841. LLButton::Params p;
  1842. p.name(std::string("Jump Left Arrow"));
  1843. p.image_unselected.name("jump_left_out.tga");
  1844. p.image_selected.name("jump_left_in.tga");
  1845. p.click_callback.function(boost::bind(&LLTabContainer::onJumpFirstBtn, this, _2));
  1846. p.rect(jump_left_arrow_btn_rect);
  1847. p.follows.flags(FOLLOWS_LEFT);
  1849. mJumpPrevArrowBtn = LLUICtrlFactory::create<LLButton>(p);
  1851. p = LLButton::Params();
  1852. p.name(std::string("Left Arrow"));
  1853. p.rect(left_arrow_btn_rect);
  1854. p.follows.flags(FOLLOWS_LEFT);
  1855. p.image_unselected.name("scrollbutton_left_out_blue.tga");
  1856. p.image_selected.name("scrollbutton_left_in_blue.tga");
  1857. p.click_callback.function(boost::bind(&LLTabContainer::onPrevBtn, this, _2));
  1858. p.mouse_held_callback.function(boost::bind(&LLTabContainer::onPrevBtnHeld, this, _2));
  1860. mPrevArrowBtn = LLUICtrlFactory::create<LLButton>(p);
  1862. p = LLButton::Params();
  1863. p.name(std::string("Jump Right Arrow"));
  1864. p.rect(jump_right_arrow_btn_rect);
  1865. p.follows.flags(FOLLOWS_RIGHT);
  1866. p.image_unselected.name("jump_right_out.tga");
  1867. p.image_selected.name("jump_right_in.tga");
  1868. p.click_callback.function(boost::bind(&LLTabContainer::onJumpLastBtn, this, _2));
  1870. mJumpNextArrowBtn = LLUICtrlFactory::create<LLButton>(p);
  1872. p = LLButton::Params();
  1873. p.name(std::string("Right Arrow"));
  1874. p.rect(right_arrow_btn_rect);
  1875. p.follows.flags(FOLLOWS_RIGHT);
  1876. p.image_unselected.name("scrollbutton_right_out_blue.tga");
  1877. p.image_selected.name("scrollbutton_right_in_blue.tga");
  1878. p.click_callback.function(boost::bind(&LLTabContainer::onNextBtn, this, _2));
  1879. p.mouse_held_callback.function(boost::bind(&LLTabContainer::onNextBtnHeld, this, _2));
  1881. mNextArrowBtn = LLUICtrlFactory::create<LLButton>(p);
  1883. if( getTabPosition() == TOP )
  1884. {
  1885. mNextArrowBtn->setFollowsTop();
  1886. mPrevArrowBtn->setFollowsTop();
  1887. mJumpPrevArrowBtn->setFollowsTop();
  1888. mJumpNextArrowBtn->setFollowsTop();
  1889. }
  1890. else
  1891. {
  1892. mNextArrowBtn->setFollowsBottom();
  1893. mPrevArrowBtn->setFollowsBottom();
  1894. mJumpPrevArrowBtn->setFollowsBottom();
  1895. mJumpNextArrowBtn->setFollowsBottom();
  1896. }
  1897. }
  1899. mPrevArrowBtn->setTabStop(FALSE);
  1900. addChild(mPrevArrowBtn);
  1902. mNextArrowBtn->setTabStop(FALSE);
  1903. addChild(mNextArrowBtn);
  1905. if (mJumpPrevArrowBtn)
  1906. {
  1907. mJumpPrevArrowBtn->setTabStop(FALSE);
  1908. addChild(mJumpPrevArrowBtn);
  1909. }
  1911. if (mJumpNextArrowBtn)
  1912. {
  1913. mJumpNextArrowBtn->setTabStop(FALSE);
  1914. addChild(mJumpNextArrowBtn);
  1915. }
  1917. // set default tab group to be panel contents
  1918. setDefaultTabGroup(1);
  1919. }
  1921. //this is a work around for the current LLPanel::initFromParams hack
  1922. //so that it doesn't overwrite the default tab group.
  1923. //will be removed when LLPanel is fixed soon.
  1924. void LLTabContainer::initFromParams(const LLPanel::Params& p)
  1925. {
  1926. LLPanel::initFromParams(p);
  1928. setDefaultTabGroup(1);
  1929. }
  1931. LLTabTuple* LLTabContainer::getTabByPanel(LLPanel* child)
  1932. {
  1933. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  1934. {
  1935. LLTabTuple* tuple = *iter;
  1936. if( tuple->mTabPanel == child )
  1937. {
  1938. return tuple;
  1939. }
  1940. }
  1941. return NULL;
  1942. }
  1944. void LLTabContainer::insertTuple(LLTabTuple * tuple, eInsertionPoint insertion_point)
  1945. {
  1946. switch(insertion_point)
  1947. {
  1948. case START:
  1949. // insert the new tab in the front of the list
  1950. mTabList.insert(mTabList.begin() + mLockedTabCount, tuple);
  1951. break;
  1952. case LEFT_OF_CURRENT:
  1953. // insert the new tab before the current tab (but not before mLockedTabCount)
  1954. {
  1955. tuple_list_t::iterator current_iter = mTabList.begin() + llmax(mLockedTabCount, mCurrentTabIdx);
  1956. mTabList.insert(current_iter, tuple);
  1957. }
  1958. break;
  1960. case RIGHT_OF_CURRENT:
  1961. // insert the new tab after the current tab (but not before mLockedTabCount)
  1962. {
  1963. tuple_list_t::iterator current_iter = mTabList.begin() + llmax(mLockedTabCount, mCurrentTabIdx + 1);
  1964. mTabList.insert(current_iter, tuple);
  1965. }
  1966. break;
  1967. case END:
  1968. default:
  1969. mTabList.push_back( tuple );
  1970. }
  1971. }
  1975. void LLTabContainer::updateMaxScrollPos()
  1976. {
  1977. static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
  1978. BOOL no_scroll = TRUE;
  1979. if (mIsVertical)
  1980. {
  1981. S32 tab_total_height = (BTN_HEIGHT + tabcntrv_pad) * getTabCount();
  1982. S32 available_height = getRect().getHeight() - getTopBorderHeight();
  1983. if( tab_total_height > available_height )
  1984. {
  1985. static LLUICachedControl<S32> tabcntrv_arrow_btn_size ("UITabCntrvArrowBtnSize", 0);
  1986. S32 available_height_with_arrows = getRect().getHeight() - 2*(tabcntrv_arrow_btn_size + 3*tabcntrv_pad);
  1987. S32 additional_needed = tab_total_height - available_height_with_arrows;
  1988. setMaxScrollPos((S32) ceil(additional_needed / float(BTN_HEIGHT) ) );
  1989. no_scroll = FALSE;
  1990. }
  1991. }
  1992. else
  1993. {
  1994. static LLUICachedControl<S32> tabcntr_tab_h_pad ("UITabCntrTabHPad", 0);
  1995. static LLUICachedControl<S32> tabcntr_arrow_btn_size ("UITabCntrArrowBtnSize", 0);
  1996. static LLUICachedControl<S32> tabcntr_tab_partial_width ("UITabCntrTabPartialWidth", 0);
  1997. S32 tab_space = 0;
  1998. S32 available_space = 0;
  1999. tab_space = mTotalTabWidth;
  2000. available_space = getRect().getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + tabcntr_tab_h_pad);
  2002. if( tab_space > available_space )
  2003. {
  2004. S32 available_width_with_arrows = getRect().getWidth() - mRightTabBtnOffset - 2 * (LLPANEL_BORDER_WIDTH + tabcntr_arrow_btn_size  + tabcntr_arrow_btn_size + 1);
  2005. // subtract off reserved portion on left
  2006. available_width_with_arrows -= tabcntr_tab_partial_width;
  2008. S32 running_tab_width = 0;
  2009. setMaxScrollPos(getTabCount());
  2010. for(tuple_list_t::reverse_iterator tab_it = mTabList.rbegin(); tab_it != mTabList.rend(); ++tab_it)
  2011. {
  2012. running_tab_width += (*tab_it)->mButton->getRect().getWidth();
  2013. if (running_tab_width > available_width_with_arrows)
  2014. {
  2015. break;
  2016. }
  2017. setMaxScrollPos(getMaxScrollPos()-1);
  2018. }
  2019. // in case last tab doesn't actually fit on screen, make it the last scrolling position
  2020. setMaxScrollPos(llmin(getMaxScrollPos(), getTabCount() - 1));
  2021. no_scroll = FALSE;
  2022. }
  2023. }
  2024. if (no_scroll)
  2025. {
  2026. setMaxScrollPos(0);
  2027. setScrollPos(0);
  2028. }
  2029. if (getScrollPos() > getMaxScrollPos())
  2030. {
  2031. setScrollPos(getMaxScrollPos()); // maybe just enforce this via limits in setScrollPos instead?
  2032. }
  2033. }
  2035. void LLTabContainer::commitHoveredButton(S32 x, S32 y)
  2036. {
  2037. if (!getTabsHidden() && hasMouseCapture())
  2038. {
  2039. for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
  2040. {
  2041. LLTabTuple* tuple = *iter;
  2042. S32 local_x = x - tuple->mButton->getRect().mLeft;
  2043. S32 local_y = y - tuple->mButton->getRect().mBottom;
  2044. if (tuple->mButton->pointInView(local_x, local_y) && tuple->mButton->getEnabled() && !tuple->mTabPanel->getVisible())
  2045. {
  2046. tuple->mButton->onCommit();
  2047. }
  2048. }
  2049. }
  2050. }