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

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

游戏引擎

开发平台：

C++ Builder

llaccordionctrl.cpp：源码内容
  1. /** 
  2.  * @file llaccordionctrl.cpp
  3.  * @brief Accordion panel  implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2009-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #include "linden_common.h"
  34. #include "llaccordionctrl.h"
  35. #include "llaccordionctrltab.h"
  37. #include "lluictrlfactory.h" // builds floaters from XML
  39. #include "llwindow.h"
  40. #include "llfocusmgr.h"
  41. #include "lllocalcliprect.h"
  43. #include "boost/bind.hpp"
  45. static const S32 DRAGGER_BAR_MARGIN = 4;
  46. static const S32 DRAGGER_BAR_HEIGHT = 5;
  47. static const S32 BORDER_MARGIN = 2;
  48. static const S32 PARENT_BORDER_MARGIN = 5;
  50. static const S32 panel_delta = DRAGGER_BAR_MARGIN;  // Distanse between two panels 
  52. static const S32 HORIZONTAL_MULTIPLE = 8;
  53. static const S32 VERTICAL_MULTIPLE = 16;
  54. static const F32 MIN_AUTO_SCROLL_RATE = 120.f;
  55. static const F32 MAX_AUTO_SCROLL_RATE = 500.f;
  56. static const F32 AUTO_SCROLL_RATE_ACCEL = 120.f;
  59. // LLAccordionCtrl =================================================================|
  61. static LLDefaultChildRegistry::Register<LLAccordionCtrl> t2("accordion");
  64. LLAccordionCtrl::LLAccordionCtrl(const Params& params):LLPanel(params)
  65.  , mFitParent(params.fit_parent)
  66.  , mAutoScrolling( false )
  67.  , mAutoScrollRate( 0.f )
  68. {
  69.   mSingleExpansion = params.single_expansion;
  70. if(mFitParent && !mSingleExpansion)
  71. {
  72. llinfos << "fit_parent works best when combined with single_expansion" << llendl;
  73. }
  74. }
  76. LLAccordionCtrl::LLAccordionCtrl() : LLPanel()
  77.  , mAutoScrolling( false )
  78.  , mAutoScrollRate( 0.f )
  79. {
  80. mSingleExpansion = false;
  81. mFitParent = false;
  82. LLUICtrlFactory::getInstance()->buildPanel(this, "accordion_parent.xml");
  83. }
  85. //---------------------------------------------------------------------------------
  86. void LLAccordionCtrl::draw()
  87. {
  88. if (mAutoScrolling)
  89. {
  90. // add acceleration to autoscroll
  91. mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), MAX_AUTO_SCROLL_RATE);
  92. }
  93. else
  94. {
  95. // reset to minimum for next time
  96. mAutoScrollRate = MIN_AUTO_SCROLL_RATE;
  97. }
  98. // clear this flag to be set on next call to autoScroll
  99. mAutoScrolling = false;
  101. LLRect local_rect(0, getRect().getHeight(), getRect().getWidth(), 0);
  103. LLLocalClipRect clip(local_rect);
  105. LLPanel::draw();
  106. }
  109. //---------------------------------------------------------------------------------
  110. BOOL LLAccordionCtrl::postBuild()
  111. {
  112. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  114. LLRect scroll_rect;
  115. scroll_rect.setOriginAndSize( 
  116. getRect().getWidth() - scrollbar_size,
  117. 1,
  118. scrollbar_size,
  119. getRect().getHeight() - 1);
  122. LLScrollbar::Params sbparams;
  123. sbparams.name("scrollable vertical");
  124. sbparams.rect(scroll_rect);
  125. sbparams.orientation(LLScrollbar::VERTICAL);
  126. sbparams.doc_size(mInnerRect.getHeight());
  127. sbparams.doc_pos(0);
  128. sbparams.page_size(mInnerRect.getHeight());
  129. sbparams.step_size(VERTICAL_MULTIPLE);
  130. sbparams.follows.flags(FOLLOWS_RIGHT | FOLLOWS_TOP | FOLLOWS_BOTTOM);
  131. sbparams.change_callback(boost::bind(&LLAccordionCtrl::onScrollPosChangeCallback, this, _1, _2));
  133. mScrollbar = LLUICtrlFactory::create<LLScrollbar> (sbparams);
  134. LLView::addChild( mScrollbar );
  135. mScrollbar->setVisible( false );
  136. mScrollbar->setFollowsRight();
  137. mScrollbar->setFollowsTop();
  138. mScrollbar->setFollowsBottom();
  140. //if it was created from xml...
  141. std::vector<LLUICtrl*> accordion_tabs;
  142. for(child_list_const_iter_t it = getChildList()->begin(); 
  143. getChildList()->end() != it; ++it)
  144. {
  145. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(*it);
  146. if(accordion_tab == NULL)
  147. continue;
  148. if(std::find(mAccordionTabs.begin(),mAccordionTabs.end(),accordion_tab) == mAccordionTabs.end())
  149. {
  150. accordion_tabs.push_back(accordion_tab);
  151. }
  152. }
  154. for(std::vector<LLUICtrl*>::reverse_iterator it = accordion_tabs.rbegin();it!=accordion_tabs.rend();++it)
  155. addCollapsibleCtrl(*it);
  157. arrange ();
  159. if(mSingleExpansion)
  160. {
  161. if(!mAccordionTabs[0]->getDisplayChildren())
  162. mAccordionTabs[0]->setDisplayChildren(true);
  163. for(size_t i=1;i<mAccordionTabs.size();++i)
  164. {
  165. if(mAccordionTabs[i]->getDisplayChildren())
  166. mAccordionTabs[i]->setDisplayChildren(false);
  167. }
  168. }
  170. return TRUE;
  171. }
  174. //---------------------------------------------------------------------------------
  175. LLAccordionCtrl::~LLAccordionCtrl()
  176. {
  177.   mAccordionTabs.clear();
  178. }
  180. //---------------------------------------------------------------------------------
  182. void LLAccordionCtrl::reshape(S32 width, S32 height, BOOL called_from_parent)
  183. {
  184. // adjust our rectangle
  185. LLRect rcLocal = getRect();
  186. rcLocal.mRight = rcLocal.mLeft + width;
  187. rcLocal.mTop = rcLocal.mBottom + height;
  189. setRect(rcLocal);
  191. arrange();
  192. }
  194. //---------------------------------------------------------------------------------
  195. BOOL LLAccordionCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
  196. {
  197. return LLPanel::handleRightMouseDown(x, y, mask);
  198. }
  200. //---------------------------------------------------------------------------------
  201. void LLAccordionCtrl::shiftAccordionTabs(S16 panel_num, S32 delta)
  202. {
  203. for(size_t i = panel_num; i < mAccordionTabs.size(); i++ )
  204. {
  205. ctrlShiftVertical(mAccordionTabs[i],delta);
  206. }
  207. }
  210. //---------------------------------------------------------------------------------
  211. void LLAccordionCtrl::onCollapseCtrlCloseOpen(S16 panel_num) 
  212. {
  213. if(mSingleExpansion)
  214. {
  215. for(size_t i=0;i<mAccordionTabs.size();++i)
  216. {
  217. if(i==panel_num)
  218. continue;
  219. if(mAccordionTabs[i]->getDisplayChildren())
  220. mAccordionTabs[i]->setDisplayChildren(false);
  221. }
  223. }
  224. arrange();
  225. }
  227. void LLAccordionCtrl::show_hide_scrollbar(S32 width, S32 height)
  228. {
  229. calcRecuiredHeight();
  230. if(getRecuiredHeight() > height )
  231. showScrollbar(width,height);
  232. else
  233. hideScrollbar(width,height);
  234. }
  236. void LLAccordionCtrl::showScrollbar(S32 width, S32 height)
  237. {
  238. bool was_visible = mScrollbar->getVisible();
  240. mScrollbar->setVisible(true);
  242. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  244. ctrlSetLeftTopAndSize(mScrollbar
  245. ,width-scrollbar_size - PARENT_BORDER_MARGIN/2
  246. ,height-PARENT_BORDER_MARGIN
  247. ,scrollbar_size
  248. ,height-2*PARENT_BORDER_MARGIN);
  250. mScrollbar->setPageSize(height);
  251. mScrollbar->setDocParams(mInnerRect.getHeight(),mScrollbar->getDocPos());
  253. if(was_visible)
  254. {
  255. S32 scroll_pos = llmin(mScrollbar->getDocPos(), getRecuiredHeight() - height - 1);
  256. mScrollbar->setDocPos(scroll_pos);
  257. }
  258. }
  260. void LLAccordionCtrl::hideScrollbar( S32 width, S32 height )
  261. {
  262. if(mScrollbar->getVisible() == false)
  263. return;
  264. mScrollbar->setVisible(false);
  266. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  268. S32 panel_width = width - 2*BORDER_MARGIN;
  270. //reshape all accordeons and shift all draggers
  271. for(size_t i=0;i<mAccordionTabs.size();++i)
  272. {
  273. LLRect panel_rect = mAccordionTabs[i]->getRect();
  274. ctrlSetLeftTopAndSize(mAccordionTabs[i],panel_rect.mLeft,panel_rect.mTop,panel_width,panel_rect.getHeight());
  275. }
  277. mScrollbar->setDocPos(0);
  279. if(mAccordionTabs.size()>0)
  280. {
  281. S32 panel_top = height - BORDER_MARGIN;   // Top coordinate of the first panel
  282. S32 diff = panel_top - mAccordionTabs[0]->getRect().mTop;
  283. shiftAccordionTabs(0,diff);
  284. }
  285. }
  288. //---------------------------------------------------------------------------------
  289. S32 LLAccordionCtrl::calcRecuiredHeight()
  290. {
  291. S32 rec_height = 0;
  293. std::vector<LLAccordionCtrlTab*>::iterator panel;
  294. for(panel=mAccordionTabs.begin(); panel!=mAccordionTabs.end(); ++panel)
  295. {
  296. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(*panel);
  297. if(accordion_tab && accordion_tab->getVisible())
  298. {
  299. rec_height += accordion_tab->getRect().getHeight();
  300. }
  301. }
  303. mInnerRect.setLeftTopAndSize(0,rec_height + BORDER_MARGIN*2,getRect().getWidth(),rec_height + BORDER_MARGIN);
  305. return mInnerRect.getHeight();
  306. }
  308. //---------------------------------------------------------------------------------
  309. void LLAccordionCtrl::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top, S32 width, S32 height)
  310. {
  311. if(!panel)
  312. return;
  313. LLRect panel_rect = panel->getRect();
  314. panel_rect.setLeftTopAndSize( left, top, width, height);
  315. panel->reshape( width, height, 1);
  316. panel->setRect(panel_rect);
  317. }
  319. void LLAccordionCtrl::ctrlShiftVertical(LLView* panel,S32 delta)
  320. {
  321. if(!panel)
  322. return;
  323. panel->translate(0,delta);
  324. }
  326. //---------------------------------------------------------------------------------
  328. void LLAccordionCtrl::addCollapsibleCtrl(LLView* view)
  329. {
  330. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(view);
  331. if(!accordion_tab)
  332. return;
  333. if(std::find(getChildList()->begin(),getChildList()->end(),accordion_tab) == getChildList()->end())
  334. addChild(accordion_tab);
  335. mAccordionTabs.push_back(accordion_tab);
  337. accordion_tab->setDropDownStateChangedCallback( boost::bind(&LLAccordionCtrl::onCollapseCtrlCloseOpen, this, mAccordionTabs.size() - 1) );
  339. }
  342. void LLAccordionCtrl::arrange()
  343. {
  344. if( mAccordionTabs.size() == 0)
  345. {
  346. //We do not arrange if we do not have what should be arranged
  347. return;
  348. }
  350. //Calculate params
  351. S32 panel_left = BORDER_MARGIN;   // Margin from left side of Splitter
  352. S32 panel_top = getRect().getHeight() - BORDER_MARGIN;   // Top coordinate of the first panel
  353. S32 panel_width = getRect().getWidth() - 4;   // Top coordinate of the first panel
  356. if(mAccordionTabs.size() == 1)
  357. {
  358. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[0]);
  360. LLRect panel_rect = accordion_tab->getRect();
  362. S32 panel_height = getRect().getHeight() - 2*BORDER_MARGIN;
  364. ctrlSetLeftTopAndSize(accordion_tab,panel_rect.mLeft,panel_top,panel_width,panel_height);
  366. show_hide_scrollbar(getRect().getWidth(),getRect().getHeight());
  367. return;
  369. }
  371. for(size_t i = 0; i < mAccordionTabs.size(); i++ )
  372. {
  373. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
  375. if(accordion_tab->getVisible() == false) //skip hidden accordion tabs
  376. continue;
  378. if(!accordion_tab->isExpanded() )
  379. {
  380. ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_left, panel_top, panel_width, accordion_tab->getRect().getHeight());
  381. panel_top-=mAccordionTabs[i]->getRect().getHeight();
  382. }
  383. else
  384. {
  385. S32 panel_height = accordion_tab->getRect().getHeight();
  387. if(mFitParent)
  388. {
  389. // all expanded tabs will have equal height
  390. panel_height = calcExpandedTabHeight(i, panel_top);
  391. ctrlSetLeftTopAndSize(accordion_tab, panel_left, panel_top, panel_width, panel_height);
  393. // try to make accordion tab fit accordion view height.
  394. // Accordion View should implement getRequiredRect() and provide valid height
  395. S32 optimal_height = accordion_tab->getAccordionView()->getRequiredRect().getHeight();
  396. optimal_height += accordion_tab->getHeaderHeight() + 2 * BORDER_MARGIN;
  397. if(optimal_height < panel_height)
  398. {
  399. panel_height = optimal_height;
  400. }
  402. // minimum tab height is equal to header height
  403. if(mAccordionTabs[i]->getHeaderHeight() > panel_height)
  404. {
  405. panel_height = mAccordionTabs[i]->getHeaderHeight();
  406. }
  407. }
  409. ctrlSetLeftTopAndSize(mAccordionTabs[i], panel_left, panel_top, panel_width, panel_height);
  410. panel_top-=panel_height;
  412. }
  413. }
  415. show_hide_scrollbar(getRect().getWidth(),getRect().getHeight());
  417. updateLayout(getRect().getWidth(),getRect().getHeight());
  419. }
  421. //---------------------------------------------------------------------------------
  423. BOOL LLAccordionCtrl::handleScrollWheel ( S32 x, S32 y, S32 clicks )
  424. {
  425. if(LLPanel::handleScrollWheel(x,y,clicks))
  426. return TRUE;
  427. if( mScrollbar->getVisible() && mScrollbar->handleScrollWheel( 0, 0, clicks ) )
  428. return TRUE;
  429. return false;
  431. }
  433. BOOL LLAccordionCtrl::handleKeyHere (KEY key, MASK mask)
  434. {
  435. if( mScrollbar->getVisible() && mScrollbar->handleKeyHere( key,mask ) )
  436. return TRUE;
  437. return LLPanel::handleKeyHere(key,mask);
  438. }
  440. BOOL LLAccordionCtrl::handleDragAndDrop (S32 x, S32 y, MASK mask,
  441.  BOOL drop,
  442.  EDragAndDropType cargo_type,
  443.  void* cargo_data,
  444.  EAcceptance* accept,
  445.  std::string& tooltip_msg)
  446. {
  447. // Scroll folder view if needed.  Never accepts a drag or drop.
  448. *accept = ACCEPT_NO;
  449. BOOL handled = autoScroll(x, y);
  451. if( !handled )
  452. {
  453. handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
  454. cargo_data, accept, tooltip_msg) != NULL;
  455. }
  456. return TRUE;
  457. }
  459. BOOL LLAccordionCtrl::autoScroll (S32 x, S32 y)
  460. {
  461. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  463. bool scrolling = false;
  464. if( mScrollbar->getVisible() )
  465. {
  466. LLRect rect_local( 0, getRect().getHeight(), getRect().getWidth() - scrollbar_size, 0 );
  467. LLRect screen_local_extents;
  469. // clip rect against root view
  470. screenRectToLocal(getRootView()->getLocalRect(), &screen_local_extents);
  471. rect_local.intersectWith(screen_local_extents);
  473. // autoscroll region should take up no more than one third of visible scroller area
  474. S32 auto_scroll_region_height = llmin(rect_local.getHeight() / 3, 10);
  475. S32 auto_scroll_speed = llround(mAutoScrollRate * LLFrameTimer::getFrameDeltaTimeF32());
  477. LLRect bottom_scroll_rect = screen_local_extents;
  478. bottom_scroll_rect.mTop = rect_local.mBottom + auto_scroll_region_height;
  479. if( bottom_scroll_rect.pointInRect( x, y ) && (mScrollbar->getDocPos() < mScrollbar->getDocPosMax()) )
  480. {
  481. mScrollbar->setDocPos( mScrollbar->getDocPos() + auto_scroll_speed );
  482. mAutoScrolling = true;
  483. scrolling = true;
  484. }
  486. LLRect top_scroll_rect = screen_local_extents;
  487. top_scroll_rect.mBottom = rect_local.mTop - auto_scroll_region_height;
  488. if( top_scroll_rect.pointInRect( x, y ) && (mScrollbar->getDocPos() > 0) )
  489. {
  490. mScrollbar->setDocPos( mScrollbar->getDocPos() - auto_scroll_speed );
  491. mAutoScrolling = true;
  492. scrolling = true;
  493. }
  494. }
  495. return scrolling;
  496. }
  498. void LLAccordionCtrl::updateLayout (S32 width, S32 height)
  499. {
  500. S32 panel_top = height - BORDER_MARGIN ;
  501. if(mScrollbar->getVisible())
  502. panel_top+=mScrollbar->getDocPos();
  504. S32 panel_width = width - 2*BORDER_MARGIN;
  506. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  507. if(mScrollbar->getVisible())
  508. panel_width-=scrollbar_size;
  510. //set sizes for first panels and dragbars
  511. for(size_t i=0;i<mAccordionTabs.size();++i)
  512. {
  513. if(!mAccordionTabs[i]->getVisible())
  514. continue;
  515. LLRect panel_rect = mAccordionTabs[i]->getRect();
  516. ctrlSetLeftTopAndSize(mAccordionTabs[i],panel_rect.mLeft,panel_top,panel_width,panel_rect.getHeight());
  517. panel_top-=panel_rect.getHeight();
  518. }
  519. }
  521. void LLAccordionCtrl::onScrollPosChangeCallback(S32, LLScrollbar*)
  522. {
  523. updateLayout(getRect().getWidth(),getRect().getHeight());
  524. }
  525. void LLAccordionCtrl::onOpen (const LLSD& key)
  526. {
  527. for(size_t i=0;i<mAccordionTabs.size();++i)
  528. {
  529. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
  530. LLPanel* panel = dynamic_cast<LLPanel*>(accordion_tab->getAccordionView());
  531. if(panel!=NULL)
  532. {
  533. panel->onOpen(key);
  534. }
  535. }
  536. }
  537. S32 LLAccordionCtrl::notifyParent(const LLSD& info)
  538. {
  539. if(info.has("action"))
  540. {
  541. std::string str_action = info["action"];
  542. if(str_action == "size_changes")
  543. {
  544. //
  545. arrange();
  546. return 1;
  547. }
  548. else if(str_action == "select_next")
  549. {
  550. for(size_t i=0;i<mAccordionTabs.size();++i)
  551. {
  552. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
  553. if(accordion_tab->hasFocus())
  554. {
  555. while(++i<mAccordionTabs.size())
  556. {
  557. if(mAccordionTabs[i]->getVisible())
  558. break;
  559. }
  560. if(i<mAccordionTabs.size())
  561. {
  562. accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
  563. accordion_tab->notify(LLSD().with("action","select_first"));
  564. return 1;
  565. }
  566. break;
  567. }
  568. }
  569. return 0;
  570. }
  571. else if(str_action == "select_prev")
  572. {
  573. for(size_t i=0;i<mAccordionTabs.size();++i)
  574. {
  575. LLAccordionCtrlTab* accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
  576. if(accordion_tab->hasFocus() && i>0)
  577. {
  578. while(i>0)
  579. {
  580. if(mAccordionTabs[--i]->getVisible())
  581. break;
  582. }
  584. accordion_tab = dynamic_cast<LLAccordionCtrlTab*>(mAccordionTabs[i]);
  585. accordion_tab->notify(LLSD().with("action","select_last"));
  586. return 1;
  587. }
  588. }
  589. return 0;
  590. }
  591. }
  592. else if (info.has("scrollToShowRect"))
  593. {
  594. LLRect screen_rc, local_rc;
  595. screen_rc.setValue(info["scrollToShowRect"]);
  596. screenRectToLocal(screen_rc, &local_rc);
  598. // Translate to parent coordinatess to check if we are in visible rectangle
  599. local_rc.translate( getRect().mLeft, getRect().mBottom );
  601. if ( !getRect().contains (local_rc) )
  602. {
  603. // Back to local coords and calculate position for scroller
  604. S32 bottom = mScrollbar->getDocPos() - local_rc.mBottom + getRect().mBottom;
  605. S32 top = mScrollbar->getDocPos() - local_rc.mTop + getRect().mTop;
  607. S32 scroll_pos = llclamp(mScrollbar->getDocPos(),
  608.  bottom, // min vertical scroll
  609.  top); // max vertical scroll 
  611. mScrollbar->setDocPos( scroll_pos );
  612. }
  613. return 1;
  614. }
  615. return LLPanel::notifyParent(info);
  616. }
  617. void LLAccordionCtrl::reset ()
  618. {
  619. if(mScrollbar)
  620. mScrollbar->setDocPos(0);
  621. }
  623. S32 LLAccordionCtrl::calcExpandedTabHeight(S32 tab_index /* = 0 */, S32 available_height /* = 0 */)
  624. {
  625. if(tab_index < 0)
  626. {
  627. return available_height;
  628. }
  630. S32 collapsed_tabs_height = 0;
  631. S32 num_expanded = 0;
  633. for(size_t n = tab_index; n < mAccordionTabs.size(); ++n)
  634. {
  635. if(!mAccordionTabs[n]->isExpanded())
  636. {
  637. collapsed_tabs_height += mAccordionTabs[n]->getHeaderHeight();
  638. }
  639. else
  640. {
  641. ++num_expanded;
  642. }
  643. }
  645. if(0 == num_expanded)
  646. {
  647. return available_height;
  648. }
  650. S32 expanded_tab_height = available_height - collapsed_tabs_height - BORDER_MARGIN; // top BORDER_MARGIN is added in arrange(), here we add bottom BORDER_MARGIN
  651. expanded_tab_height /= num_expanded;
  652. return expanded_tab_height;
  653. }