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

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

游戏引擎

开发平台：

C++ Builder

llscrollcontainer.cpp：源码内容
  1. /** 
  2.  * @file llscrollcontainer.cpp
  3.  * @brief LLScrollContainer 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.  */
  34. #include "linden_common.h"
  36. #include "llscrollcontainer.h"
  38. #include "llrender.h"
  39. #include "llcontainerview.h"
  40. #include "lllocalcliprect.h"
  41. // #include "llfolderview.h"
  42. #include "llscrollingpanellist.h"
  43. #include "llscrollbar.h"
  44. #include "llui.h"
  45. #include "llkeyboard.h"
  46. #include "llviewborder.h"
  47. #include "llfocusmgr.h"
  48. #include "llframetimer.h"
  49. #include "lluictrlfactory.h"
  50. #include "llpanel.h"
  51. #include "llfontgl.h"
  53. ///----------------------------------------------------------------------------
  54. /// Local function declarations, constants, enums, and typedefs
  55. ///----------------------------------------------------------------------------
  57. static const S32 HORIZONTAL_MULTIPLE = 8;
  58. static const S32 VERTICAL_MULTIPLE = 16;
  59. static const F32 AUTO_SCROLL_RATE_ACCEL = 120.f;
  61. ///----------------------------------------------------------------------------
  62. /// Class LLScrollContainer
  63. ///----------------------------------------------------------------------------
  65. static LLDefaultChildRegistry::Register<LLScrollContainer> r("scroll_container");
  67. #include "llscrollingpanellist.h"
  68. #include "llcontainerview.h"
  69. #include "llpanel.h"
  71. static ScrollContainerRegistry::Register<LLScrollingPanelList> r1("scrolling_panel_list");
  72. static ScrollContainerRegistry::Register<LLContainerView> r2("container_view");
  73. static ScrollContainerRegistry::Register<LLPanel> r3("panel", &LLPanel::fromXML);
  75. LLScrollContainer::Params::Params()
  76. : is_opaque("opaque"),
  77. bg_color("color"),
  78. border_visible("border_visible"),
  79. hide_scrollbar("hide_scrollbar"),
  80. min_auto_scroll_rate("min_auto_scroll_rate", 100),
  81. max_auto_scroll_rate("max_auto_scroll_rate", 1000),
  82. reserve_scroll_corner("reserve_scroll_corner", false)
  83. {
  84. name = "scroll_container";
  85. mouse_opaque(true);
  86. tab_stop(false);
  87. }
  90. // Default constructor
  91. LLScrollContainer::LLScrollContainer(const LLScrollContainer::Params& p)
  92. : LLUICtrl(p),
  93. mAutoScrolling( FALSE ),
  94. mAutoScrollRate( 0.f ),
  95. mBackgroundColor(p.bg_color()),
  96. mIsOpaque(p.is_opaque),
  97. mHideScrollbar(p.hide_scrollbar),
  98. mReserveScrollCorner(p.reserve_scroll_corner),
  99. mMinAutoScrollRate(p.min_auto_scroll_rate),
  100. mMaxAutoScrollRate(p.max_auto_scroll_rate),
  101. mScrolledView(NULL)
  102. {
  103. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  104. LLRect border_rect( 0, getRect().getHeight(), getRect().getWidth(), 0 );
  105. LLViewBorder::Params params;
  106. params.name("scroll border");
  107. params.rect(border_rect);
  108. params.visible(p.border_visible);
  109. params.bevel_style(LLViewBorder::BEVEL_IN);
  110. mBorder = LLUICtrlFactory::create<LLViewBorder> (params);
  111. LLView::addChild( mBorder );
  113. mInnerRect.set( 0, getRect().getHeight(), getRect().getWidth(), 0 );
  114. mInnerRect.stretch( -getBorderWidth()  );
  116. LLRect vertical_scroll_rect = mInnerRect;
  117. vertical_scroll_rect.mLeft = vertical_scroll_rect.mRight - scrollbar_size;
  118. LLScrollbar::Params sbparams;
  119. sbparams.name("scrollable vertical");
  120. sbparams.rect(vertical_scroll_rect);
  121. sbparams.orientation(LLScrollbar::VERTICAL);
  122. sbparams.doc_size(mInnerRect.getHeight());
  123. sbparams.doc_pos(0);
  124. sbparams.page_size(mInnerRect.getHeight());
  125. sbparams.step_size(VERTICAL_MULTIPLE);
  126. sbparams.follows.flags(FOLLOWS_RIGHT | FOLLOWS_TOP | FOLLOWS_BOTTOM);
  127. sbparams.visible(false);
  128. sbparams.change_callback(p.scroll_callback);
  129. mScrollbar[VERTICAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
  130. LLView::addChild( mScrollbar[VERTICAL] );
  132. LLRect horizontal_scroll_rect = mInnerRect;
  133. horizontal_scroll_rect.mTop = horizontal_scroll_rect.mBottom + scrollbar_size;
  134. sbparams.name("scrollable horizontal");
  135. sbparams.rect(horizontal_scroll_rect);
  136. sbparams.orientation(LLScrollbar::HORIZONTAL);
  137. sbparams.doc_size(mInnerRect.getWidth());
  138. sbparams.doc_pos(0);
  139. sbparams.page_size(mInnerRect.getWidth());
  140. sbparams.step_size(VERTICAL_MULTIPLE);
  141. sbparams.visible(false);
  142. sbparams.follows.flags(FOLLOWS_LEFT | FOLLOWS_RIGHT);
  143. sbparams.change_callback(p.scroll_callback);
  144. mScrollbar[HORIZONTAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
  145. LLView::addChild( mScrollbar[HORIZONTAL] );
  146. }
  148. // Destroys the object
  149. LLScrollContainer::~LLScrollContainer( void )
  150. {
  151. // mScrolledView and mScrollbar are child views, so the LLView
  152. // destructor takes care of memory deallocation.
  153. for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
  154. {
  155. mScrollbar[i] = NULL;
  156. }
  157. mScrolledView = NULL;
  158. }
  160. // internal scrollbar handlers
  161. // virtual
  162. void LLScrollContainer::scrollHorizontal( S32 new_pos )
  163. {
  164. //llinfos << "LLScrollContainer::scrollHorizontal()" << llendl;
  165. if( mScrolledView )
  166. {
  167. LLRect doc_rect = mScrolledView->getRect();
  168. S32 old_pos = -(doc_rect.mLeft - mInnerRect.mLeft);
  169. mScrolledView->translate( -(new_pos - old_pos), 0 );
  170. }
  171. }
  173. // virtual
  174. void LLScrollContainer::scrollVertical( S32 new_pos )
  175. {
  176. // llinfos << "LLScrollContainer::scrollVertical() " << new_pos << llendl;
  177. if( mScrolledView )
  178. {
  179. LLRect doc_rect = mScrolledView->getRect();
  180. S32 old_pos = doc_rect.mTop - mInnerRect.mTop;
  181. mScrolledView->translate( 0, new_pos - old_pos );
  182. }
  183. }
  185. // LLView functionality
  186. void LLScrollContainer::reshape(S32 width, S32 height,
  187. BOOL called_from_parent)
  188. {
  189. LLUICtrl::reshape( width, height, called_from_parent );
  191. mInnerRect = getLocalRect();
  192. mInnerRect.stretch( -getBorderWidth() );
  194. if (mScrolledView)
  195. {
  196. const LLRect& scrolled_rect = mScrolledView->getRect();
  198. S32 visible_width = 0;
  199. S32 visible_height = 0;
  200. BOOL show_v_scrollbar = FALSE;
  201. BOOL show_h_scrollbar = FALSE;
  202. calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
  204. mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
  205. mScrollbar[VERTICAL]->setPageSize( visible_height );
  207. mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
  208. mScrollbar[HORIZONTAL]->setPageSize( visible_width );
  209. updateScroll();
  210. }
  211. }
  213. BOOL LLScrollContainer::handleKeyHere(KEY key, MASK mask)
  214. {
  215. // allow scrolled view to handle keystrokes in case it delegated keyboard focus
  216. // to the scroll container.  
  217. // NOTE: this should not recurse indefinitely as handleKeyHere
  218. // should not propagate to parent controls, so mScrolledView should *not*
  219. // call LLScrollContainer::handleKeyHere in turn
  220. if (mScrolledView && mScrolledView->handleKeyHere(key, mask))
  221. {
  222. return TRUE;
  223. }
  224. for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
  225. {
  226. if( mScrollbar[i]->handleKeyHere(key, mask) )
  227. {
  228. updateScroll();
  229. return TRUE;
  230. }
  231. }
  233. return FALSE;
  234. }
  236. BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks )
  237. {
  238. // Give event to my child views - they may have scroll bars
  239. // (Bad UI design, but technically possible.)
  240. if (LLUICtrl::handleScrollWheel(x,y,clicks))
  241. return TRUE;
  243. // When the vertical scrollbar is visible, scroll wheel
  244. // only affects vertical scrolling.  It's confusing to have
  245. // scroll wheel perform both vertical and horizontal in a
  246. // single container.
  247. LLScrollbar* vertical = mScrollbar[VERTICAL];
  248. if (vertical->getVisible()
  249. && vertical->getEnabled())
  250. {
  251. // Pretend the mouse is over the scrollbar
  252. if (vertical->handleScrollWheel( 0, 0, clicks ) )
  253. {
  254. updateScroll();
  255. }
  256. // Always eat the event
  257. return TRUE;
  258. }
  260. LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
  261. // Test enablement and visibility for consistency with
  262. // LLView::childrenHandleScrollWheel().
  263. if (horizontal->getVisible()
  264. && horizontal->getEnabled()
  265. && horizontal->handleScrollWheel( 0, 0, clicks ) )
  266. {
  267. updateScroll();
  268. return TRUE;
  269. }
  270. return FALSE;
  271. }
  273. BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask,
  274.   BOOL drop,
  275.   EDragAndDropType cargo_type,
  276.   void* cargo_data,
  277.   EAcceptance* accept,
  278.   std::string& tooltip_msg)
  279. {
  280. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  281. // Scroll folder view if needed.  Never accepts a drag or drop.
  282. *accept = ACCEPT_NO;
  283. BOOL handled = autoScroll(x, y);
  285. if( !handled )
  286. {
  287. handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
  288. cargo_data, accept, tooltip_msg) != NULL;
  289. }
  291. return TRUE;
  292. }
  294. bool LLScrollContainer::autoScroll(S32 x, S32 y)
  295. {
  296. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  298. bool scrolling = false;
  299. if( mScrollbar[HORIZONTAL]->getVisible() || mScrollbar[VERTICAL]->getVisible() )
  300. {
  301. LLRect screen_local_extents;
  302. screenRectToLocal(getRootView()->getLocalRect(), &screen_local_extents);
  304. LLRect inner_rect_local( 0, mInnerRect.getHeight(), mInnerRect.getWidth(), 0 );
  305. if( mScrollbar[HORIZONTAL]->getVisible() )
  306. {
  307. inner_rect_local.mBottom += scrollbar_size;
  308. }
  309. if( mScrollbar[VERTICAL]->getVisible() )
  310. {
  311. inner_rect_local.mRight -= scrollbar_size;
  312. }
  314. // clip rect against root view
  315. inner_rect_local.intersectWith(screen_local_extents);
  317. S32 auto_scroll_speed = llround(mAutoScrollRate * LLFrameTimer::getFrameDeltaTimeF32());
  318. // autoscroll region should take up no more than one third of visible scroller area
  319. S32 auto_scroll_region_width = llmin(inner_rect_local.getWidth() / 3, 10); 
  320. S32 auto_scroll_region_height = llmin(inner_rect_local.getHeight() / 3, 10); 
  322. if( mScrollbar[HORIZONTAL]->getVisible() )
  323. {
  324. LLRect left_scroll_rect = screen_local_extents;
  325. left_scroll_rect.mRight = inner_rect_local.mLeft + auto_scroll_region_width;
  326. if( left_scroll_rect.pointInRect( x, y ) && (mScrollbar[HORIZONTAL]->getDocPos() > 0) )
  327. {
  328. mScrollbar[HORIZONTAL]->setDocPos( mScrollbar[HORIZONTAL]->getDocPos() - auto_scroll_speed );
  329. mAutoScrolling = TRUE;
  330. scrolling = true;
  331. }
  333. LLRect right_scroll_rect = screen_local_extents;
  334. right_scroll_rect.mLeft = inner_rect_local.mRight - auto_scroll_region_width;
  335. if( right_scroll_rect.pointInRect( x, y ) && (mScrollbar[HORIZONTAL]->getDocPos() < mScrollbar[HORIZONTAL]->getDocPosMax()) )
  336. {
  337. mScrollbar[HORIZONTAL]->setDocPos( mScrollbar[HORIZONTAL]->getDocPos() + auto_scroll_speed );
  338. mAutoScrolling = TRUE;
  339. scrolling = true;
  340. }
  341. }
  342. if( mScrollbar[VERTICAL]->getVisible() )
  343. {
  344. LLRect bottom_scroll_rect = screen_local_extents;
  345. bottom_scroll_rect.mTop = inner_rect_local.mBottom + auto_scroll_region_height;
  346. if( bottom_scroll_rect.pointInRect( x, y ) && (mScrollbar[VERTICAL]->getDocPos() < mScrollbar[VERTICAL]->getDocPosMax()) )
  347. {
  348. mScrollbar[VERTICAL]->setDocPos( mScrollbar[VERTICAL]->getDocPos() + auto_scroll_speed );
  349. mAutoScrolling = TRUE;
  350. scrolling = true;
  351. }
  353. LLRect top_scroll_rect = screen_local_extents;
  354. top_scroll_rect.mBottom = inner_rect_local.mTop - auto_scroll_region_height;
  355. if( top_scroll_rect.pointInRect( x, y ) && (mScrollbar[VERTICAL]->getDocPos() > 0) )
  356. {
  357. mScrollbar[VERTICAL]->setDocPos( mScrollbar[VERTICAL]->getDocPos() - auto_scroll_speed );
  358. mAutoScrolling = TRUE;
  359. scrolling = true;
  360. }
  361. }
  362. }
  363. return scrolling;
  364. }
  366. void LLScrollContainer::calcVisibleSize( S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar ) const
  367. {
  368. const LLRect& doc_rect = getScrolledViewRect();
  369. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  370. S32 doc_width = doc_rect.getWidth();
  371. S32 doc_height = doc_rect.getHeight();
  373. S32 border_width = getBorderWidth();
  374. *visible_width = getRect().getWidth() - 2 * border_width;
  375. *visible_height = getRect().getHeight() - 2 * border_width;
  377. *show_v_scrollbar = FALSE;
  378. *show_h_scrollbar = FALSE;
  380. if (!mHideScrollbar)
  381. {
  382. if( *visible_height < doc_height )
  383. {
  384. *show_v_scrollbar = TRUE;
  385. *visible_width -= scrollbar_size;
  386. }
  388. if( *visible_width < doc_width )
  389. {
  390. *show_h_scrollbar = TRUE;
  391. *visible_height -= scrollbar_size;
  393. // Must retest now that visible_height has changed
  394. if( !*show_v_scrollbar && (*visible_height < doc_height) )
  395. {
  396. *show_v_scrollbar = TRUE;
  397. *visible_width -= scrollbar_size;
  398. }
  399. }
  400. }
  401. }
  404. void LLScrollContainer::draw()
  405. {
  406. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  407. if (mAutoScrolling)
  408. {
  409. // add acceleration to autoscroll
  410. mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), mMaxAutoScrollRate);
  411. }
  412. else
  413. {
  414. // reset to minimum for next time
  415. mAutoScrollRate = mMinAutoScrollRate;
  416. }
  417. // clear this flag to be set on next call to autoScroll
  418. mAutoScrolling = FALSE;
  420. // auto-focus when scrollbar active
  421. // this allows us to capture user intent (i.e. stop automatically scrolling the view/etc)
  422. if (!hasFocus() 
  423. && (mScrollbar[VERTICAL]->hasMouseCapture() || mScrollbar[HORIZONTAL]->hasMouseCapture()))
  424. {
  425. focusFirstItem();
  426. }
  428. // Draw background
  429. if( mIsOpaque )
  430. {
  431. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  432. gGL.color4fv( mBackgroundColor.get().mV );
  433. gl_rect_2d( mInnerRect );
  434. }
  436. // Draw mScrolledViews and update scroll bars.
  437. // get a scissor region ready, and draw the scrolling view. The
  438. // scissor region ensures that we don't draw outside of the bounds
  439. // of the rectangle.
  440. if( mScrolledView )
  441. {
  442. updateScroll();
  444. // Draw the scrolled area.
  445. {
  446. S32 visible_width = 0;
  447. S32 visible_height = 0;
  448. BOOL show_v_scrollbar = FALSE;
  449. BOOL show_h_scrollbar = FALSE;
  450. calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
  452. LLLocalClipRect clip(LLRect(mInnerRect.mLeft, 
  453. mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0) + visible_height,
  454. mInnerRect.mRight - (show_v_scrollbar ? scrollbar_size: 0),
  455. mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0)
  456. ));
  457. drawChild(mScrolledView);
  458. }
  459. }
  461. // Highlight border if a child of this container has keyboard focus
  462. if( mBorder->getVisible() )
  463. {
  464. mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus(this) );
  465. }
  467. // Draw all children except mScrolledView
  468. // Note: scrollbars have been adjusted by above drawing code
  469. for (child_list_const_reverse_iter_t child_iter = getChildList()->rbegin();
  470.  child_iter != getChildList()->rend(); ++child_iter)
  471. {
  472. LLView *viewp = *child_iter;
  473. if( sDebugRects )
  474. {
  475. sDepth++;
  476. }
  477. if( (viewp != mScrolledView) && viewp->getVisible() )
  478. {
  479. drawChild(viewp);
  480. }
  481. if( sDebugRects )
  482. {
  483. sDepth--;
  484. }
  485. }
  486. } // end draw
  488. bool LLScrollContainer::addChild(LLView* view, S32 tab_group)
  489. {
  490. if (!mScrolledView)
  491. {
  492. // Use the first panel or container as the scrollable view (bit of a hack)
  493. mScrolledView = view;
  494. }
  496. bool ret_val = LLView::addChild(view, tab_group);
  498. //bring the scrollbars to the front
  499. sendChildToFront( mScrollbar[HORIZONTAL] );
  500. sendChildToFront( mScrollbar[VERTICAL] );
  502. return ret_val;
  503. }
  505. void LLScrollContainer::updateScroll()
  506. {
  507. if (!mScrolledView)
  508. {
  509. return;
  510. }
  511. static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
  512. LLRect doc_rect = mScrolledView->getRect();
  513. S32 doc_width = doc_rect.getWidth();
  514. S32 doc_height = doc_rect.getHeight();
  515. S32 visible_width = 0;
  516. S32 visible_height = 0;
  517. BOOL show_v_scrollbar = FALSE;
  518. BOOL show_h_scrollbar = FALSE;
  519. calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
  521. S32 border_width = getBorderWidth();
  522. if( show_v_scrollbar )
  523. {
  524. if( doc_rect.mTop < getRect().getHeight() - border_width )
  525. {
  526. mScrolledView->translate( 0, getRect().getHeight() - border_width - doc_rect.mTop );
  527. }
  529. scrollVertical( mScrollbar[VERTICAL]->getDocPos() );
  530. mScrollbar[VERTICAL]->setVisible( TRUE );
  532. S32 v_scrollbar_height = visible_height;
  533. if( !show_h_scrollbar && mReserveScrollCorner )
  534. {
  535. v_scrollbar_height -= scrollbar_size;
  536. }
  537. mScrollbar[VERTICAL]->reshape( scrollbar_size, v_scrollbar_height, TRUE );
  539. // Make room for the horizontal scrollbar (or not)
  540. S32 v_scrollbar_offset = 0;
  541. if( show_h_scrollbar || mReserveScrollCorner )
  542. {
  543. v_scrollbar_offset = scrollbar_size;
  544. }
  545. LLRect r = mScrollbar[VERTICAL]->getRect();
  546. r.translate( 0, mInnerRect.mBottom - r.mBottom + v_scrollbar_offset );
  547. mScrollbar[VERTICAL]->setRect( r );
  548. }
  549. else
  550. {
  551. mScrolledView->translate( 0, getRect().getHeight() - border_width - doc_rect.mTop );
  553. mScrollbar[VERTICAL]->setVisible( FALSE );
  554. mScrollbar[VERTICAL]->setDocPos( 0 );
  555. }
  557. if( show_h_scrollbar )
  558. {
  559. if( doc_rect.mLeft > border_width )
  560. {
  561. mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
  562. mScrollbar[HORIZONTAL]->setDocPos( 0 );
  563. }
  564. else
  565. {
  566. scrollHorizontal( mScrollbar[HORIZONTAL]->getDocPos() );
  567. }
  569. mScrollbar[HORIZONTAL]->setVisible( TRUE );
  570. S32 h_scrollbar_width = visible_width;
  571. if( !show_v_scrollbar && mReserveScrollCorner )
  572. {
  573. h_scrollbar_width -= scrollbar_size;
  574. }
  575. mScrollbar[HORIZONTAL]->reshape( h_scrollbar_width, scrollbar_size, TRUE );
  576. }
  577. else
  578. {
  579. mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
  581. mScrollbar[HORIZONTAL]->setVisible( FALSE );
  582. mScrollbar[HORIZONTAL]->setDocPos( 0 );
  583. }
  585. mScrollbar[HORIZONTAL]->setDocSize( doc_width );
  586. mScrollbar[HORIZONTAL]->setPageSize( visible_width );
  588. mScrollbar[VERTICAL]->setDocSize( doc_height );
  589. mScrollbar[VERTICAL]->setPageSize( visible_height );
  590. } // end updateScroll
  592. void LLScrollContainer::setBorderVisible(BOOL b)
  593. {
  594. mBorder->setVisible( b );
  595. // Recompute inner rect, as border visibility changes it
  596. mInnerRect = getLocalRect();
  597. mInnerRect.stretch( -getBorderWidth() );
  598. }
  600. LLRect LLScrollContainer::getVisibleContentRect()
  601. {
  602. updateScroll();
  603. LLRect visible_rect = getContentWindowRect();
  604. LLRect contents_rect = mScrolledView->getRect();
  605. visible_rect.translate(-contents_rect.mLeft, -contents_rect.mBottom);
  606. return visible_rect;
  607. }
  609. LLRect LLScrollContainer::getContentWindowRect()
  610. {
  611. updateScroll();
  612. LLRect scroller_view_rect;
  613. S32 visible_width = 0;
  614. S32 visible_height = 0;
  615. BOOL show_h_scrollbar = FALSE;
  616. BOOL show_v_scrollbar = FALSE;
  617. calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
  618. S32 border_width = getBorderWidth();
  619. scroller_view_rect.setOriginAndSize(border_width, 
  620. show_h_scrollbar ? mScrollbar[HORIZONTAL]->getRect().mTop : border_width, 
  621. visible_width, 
  622. visible_height);
  623. return scroller_view_rect;
  624. }
  626. // rect is in document coordinates, constraint is in display coordinates relative to content window rect
  627. void LLScrollContainer::scrollToShowRect(const LLRect& rect, const LLRect& constraint)
  628. {
  629. if (!mScrolledView)
  630. {
  631. llwarns << "LLScrollContainer::scrollToShowRect with no view!" << llendl;
  632. return;
  633. }
  635. LLRect content_window_rect = getContentWindowRect();
  636. // get document rect
  637. LLRect scrolled_rect = mScrolledView->getRect();
  639. // shrink target rect to fit within constraint region, biasing towards top left
  640. LLRect rect_to_constrain = rect;
  641. rect_to_constrain.mBottom = llmax(rect_to_constrain.mBottom, rect_to_constrain.mTop - constraint.getHeight());
  642. rect_to_constrain.mRight = llmin(rect_to_constrain.mRight, rect_to_constrain.mLeft + constraint.getWidth());
  644. // calculate allowable positions for scroller window in document coordinates
  645. LLRect allowable_scroll_rect(rect_to_constrain.mRight - constraint.mRight,
  646. rect_to_constrain.mBottom - constraint.mBottom,
  647. rect_to_constrain.mLeft - constraint.mLeft,
  648. rect_to_constrain.mTop - constraint.mTop);
  650. // translate from allowable region for lower left corner to upper left corner
  651. allowable_scroll_rect.translate(0, content_window_rect.getHeight());
  653. S32 vert_pos = llclamp(mScrollbar[VERTICAL]->getDocPos(), 
  654. mScrollbar[VERTICAL]->getDocSize() - allowable_scroll_rect.mTop, // min vertical scroll
  655. mScrollbar[VERTICAL]->getDocSize() - allowable_scroll_rect.mBottom); // max vertical scroll
  657. mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
  658. mScrollbar[VERTICAL]->setPageSize( content_window_rect.getHeight() );
  659. mScrollbar[VERTICAL]->setDocPos( vert_pos );
  661. S32 horizontal_pos = llclamp(mScrollbar[HORIZONTAL]->getDocPos(), 
  662. allowable_scroll_rect.mLeft,
  663. allowable_scroll_rect.mRight);
  665. mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
  666. mScrollbar[HORIZONTAL]->setPageSize( content_window_rect.getWidth() );
  667. mScrollbar[HORIZONTAL]->setDocPos( horizontal_pos );
  669. // propagate scroll to document
  670. updateScroll();
  672. // In case we are in accordion tab notify parent to show selected rectangle
  673. LLRect screen_rc;
  674. localRectToScreen(rect_to_constrain, &screen_rc);
  675. notifyParent(LLSD().with("scrollToShowRect",screen_rc.getValue()));
  676. }
  678. void LLScrollContainer::pageUp(S32 overlap)
  679. {
  680. mScrollbar[VERTICAL]->pageUp(overlap);
  681. updateScroll();
  682. }
  684. void LLScrollContainer::pageDown(S32 overlap)
  685. {
  686. mScrollbar[VERTICAL]->pageDown(overlap);
  687. updateScroll();
  688. }
  690. void LLScrollContainer::goToTop()
  691. {
  692. mScrollbar[VERTICAL]->setDocPos(0);
  693. updateScroll();
  694. }
  696. void LLScrollContainer::goToBottom()
  697. {
  698. mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocSize());
  699. updateScroll();
  700. }
  702. S32 LLScrollContainer::getBorderWidth() const
  703. {
  704. if (mBorder->getVisible())
  705. {
  706. return mBorder->getBorderWidth();
  707. }
  709. return 0;
  710. }