llscrollbar.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:18k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llscrollbar.cpp
  3.  * @brief Scrollbar UI widget
  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.  */
  32. #include "linden_common.h"
  33. #include "llscrollbar.h"
  34. #include "llmath.h"
  35. #include "lltimer.h"
  36. #include "v3color.h"
  37. #include "llbutton.h"
  38. #include "llcriticaldamp.h"
  39. #include "llkeyboard.h"
  40. #include "llui.h"
  41. #include "llfocusmgr.h"
  42. #include "llwindow.h"
  43. #include "llcontrol.h"
  44. #include "llrender.h"
  45. #include "lluictrlfactory.h"
  46. static LLDefaultChildRegistry::Register<LLScrollbar> register_scrollbar("scroll_bar");
  47. LLScrollbar::Params::Params()
  48. : orientation ("orientation", HORIZONTAL),
  49. doc_size ("doc_size", 0),
  50. doc_pos ("doc_pos", 0),
  51. page_size ("page_size", 0),
  52. step_size ("step_size", 1),
  53. thumb_image_vertical("thumb_image_vertical"),
  54. thumb_image_horizontal("thumb_image_horizontal"),
  55. track_image_vertical("track_image_vertical"),
  56. track_image_horizontal("track_image_horizontal"),
  57. track_color("track_color"),
  58. thumb_color("thumb_color"),
  59. thickness("thickness"),
  60. up_button("up_button"),
  61. down_button("down_button"),
  62. left_button("left_button"),
  63. right_button("right_button"),
  64. bg_visible("bg_visible", false),
  65. bg_color("bg_color", LLColor4::black)
  66. {
  67. tab_stop = false;
  68. }
  69. LLScrollbar::LLScrollbar(const Params & p)
  70. : LLUICtrl(p),
  71. mChangeCallback( p.change_callback() ),
  72. mOrientation( p.orientation ),
  73. mDocSize( p.doc_size ),
  74. mDocPos( p.doc_pos ),
  75. mPageSize( p.page_size ),
  76. mStepSize( p.step_size ),
  77. mDocChanged(FALSE),
  78. mDragStartX( 0 ),
  79. mDragStartY( 0 ),
  80. mHoverGlowStrength(0.15f),
  81. mCurGlowStrength(0.f),
  82. mTrackColor( p.track_color() ),
  83. mThumbColor ( p.thumb_color() ),
  84. mThumbImageV(p.thumb_image_vertical),
  85. mThumbImageH(p.thumb_image_horizontal),
  86. mTrackImageV(p.track_image_vertical),
  87. mTrackImageH(p.track_image_horizontal),
  88. mThickness(p.thickness.isProvided() ? p.thickness : LLUI::sSettingGroups["config"]->getS32("UIScrollbarSize")),
  89. mBGVisible(p.bg_visible),
  90. mBGColor(p.bg_color)
  91. {
  92. updateThumbRect();
  93. // Page up and page down buttons
  94. LLRect line_up_rect;
  95. LLRect line_down_rect;
  96. if( VERTICAL == mOrientation )
  97. {
  98. line_up_rect.setLeftTopAndSize( 0, getRect().getHeight(), mThickness, mThickness );
  99. line_down_rect.setOriginAndSize( 0, 0, mThickness, mThickness );
  100. }
  101. else // HORIZONTAL
  102. {
  103. line_up_rect.setOriginAndSize( 0, 0, mThickness, mThickness );
  104. line_down_rect.setOriginAndSize( getRect().getWidth() - mThickness, 0, mThickness, mThickness );
  105. }
  106. LLButton::Params up_btn(mOrientation == VERTICAL ? p.up_button : p.left_button);
  107. up_btn.name(std::string("Line Up"));
  108. up_btn.rect(line_up_rect);
  109. up_btn.click_callback.function(boost::bind(&LLScrollbar::onLineUpBtnPressed, this, _2));
  110. up_btn.mouse_held_callback.function(boost::bind(&LLScrollbar::onLineUpBtnPressed, this, _2));
  111. up_btn.tab_stop(false);
  112. up_btn.follows.flags = (mOrientation == VERTICAL ? (FOLLOWS_RIGHT | FOLLOWS_TOP) : (FOLLOWS_LEFT | FOLLOWS_BOTTOM));
  113. addChild(LLUICtrlFactory::create<LLButton>(up_btn));
  114. LLButton::Params down_btn(mOrientation == VERTICAL ? p.down_button : p.right_button);
  115. down_btn.name(std::string("Line Down"));
  116. down_btn.rect(line_down_rect);
  117. down_btn.follows.flags(FOLLOWS_RIGHT|FOLLOWS_BOTTOM);
  118. down_btn.click_callback.function(boost::bind(&LLScrollbar::onLineDownBtnPressed, this, _2));
  119. down_btn.mouse_held_callback.function(boost::bind(&LLScrollbar::onLineDownBtnPressed, this, _2));
  120. down_btn.tab_stop(false);
  121. addChild(LLUICtrlFactory::create<LLButton>(down_btn));
  122. }
  123. LLScrollbar::~LLScrollbar()
  124. {
  125. // Children buttons killed by parent class
  126. }
  127. void LLScrollbar::setDocParams( S32 size, S32 pos )
  128. {
  129. mDocSize = size;
  130. setDocPos(pos);
  131. mDocChanged = TRUE;
  132. updateThumbRect();
  133. }
  134. // returns true if document position really changed
  135. bool LLScrollbar::setDocPos(S32 pos, BOOL update_thumb)
  136. {
  137. pos = llclamp(pos, 0, getDocPosMax());
  138. if (pos != mDocPos)
  139. {
  140. mDocPos = pos;
  141. mDocChanged = TRUE;
  142. if( mChangeCallback )
  143. {
  144. mChangeCallback( mDocPos, this );
  145. }
  146. if( update_thumb )
  147. {
  148. updateThumbRect();
  149. }
  150. return true;
  151. }
  152. return false;
  153. }
  154. void LLScrollbar::setDocSize(S32 size)
  155. {
  156. if (size != mDocSize)
  157. {
  158. mDocSize = size;
  159. setDocPos(mDocPos);
  160. mDocChanged = TRUE;
  161. updateThumbRect();
  162. }
  163. }
  164. void LLScrollbar::setPageSize( S32 page_size )
  165. {
  166. if (page_size != mPageSize)
  167. {
  168. mPageSize = page_size;
  169. setDocPos(mDocPos);
  170. mDocChanged = TRUE;
  171. updateThumbRect();
  172. }
  173. }
  174. BOOL LLScrollbar::isAtBeginning()
  175. {
  176. return mDocPos == 0;
  177. }
  178. BOOL LLScrollbar::isAtEnd()
  179. {
  180. return mDocPos == getDocPosMax();
  181. }
  182. void LLScrollbar::updateThumbRect()
  183. {
  184. // llassert( 0 <= mDocSize );
  185. // llassert( 0 <= mDocPos && mDocPos <= getDocPosMax() );
  186. const S32 THUMB_MIN_LENGTH = 16;
  187. S32 window_length = (mOrientation == LLScrollbar::HORIZONTAL) ? getRect().getWidth() : getRect().getHeight();
  188. S32 thumb_bg_length = llmax(0, window_length - 2 * mThickness);
  189. S32 visible_lines = llmin( mDocSize, mPageSize );
  190. S32 thumb_length = mDocSize ? llmin(llmax( visible_lines * thumb_bg_length / mDocSize, THUMB_MIN_LENGTH), thumb_bg_length) : thumb_bg_length;
  191. S32 variable_lines = mDocSize - visible_lines;
  192. if( mOrientation == LLScrollbar::VERTICAL )
  193. S32 thumb_start_max = thumb_bg_length + mThickness;
  194. S32 thumb_start_min = mThickness + THUMB_MIN_LENGTH;
  195. S32 thumb_start = variable_lines ? llmin( llmax(thumb_start_max - (mDocPos * (thumb_bg_length - thumb_length)) / variable_lines, thumb_start_min), thumb_start_max ) : thumb_start_max;
  196. mThumbRect.mLeft =  0;
  197. mThumbRect.mTop = thumb_start;
  198. mThumbRect.mRight = mThickness;
  199. mThumbRect.mBottom = thumb_start - thumb_length;
  200. }
  201. else
  202. {
  203. // Horizontal
  204. S32 thumb_start_max = thumb_bg_length + mThickness - thumb_length;
  205. S32 thumb_start_min = mThickness;
  206. S32 thumb_start = variable_lines ? llmin(llmax( thumb_start_min + (mDocPos * (thumb_bg_length - thumb_length)) / variable_lines, thumb_start_min), thumb_start_max ) : thumb_start_min;
  207. mThumbRect.mLeft = thumb_start;
  208. mThumbRect.mTop = mThickness;
  209. mThumbRect.mRight = thumb_start + thumb_length;
  210. mThumbRect.mBottom = 0;
  211. }
  212. }
  213. BOOL LLScrollbar::handleMouseDown(S32 x, S32 y, MASK mask)
  214. {
  215. // Check children first
  216. BOOL handled_by_child = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
  217. if( !handled_by_child )
  218. {
  219. if( mThumbRect.pointInRect(x,y) )
  220. {
  221. // Start dragging the thumb
  222. // No handler needed for focus lost since this clas has no state that depends on it.
  223. gFocusMgr.setMouseCapture( this );  
  224. mDragStartX = x;
  225. mDragStartY = y;
  226. mOrigRect.mTop = mThumbRect.mTop;
  227. mOrigRect.mBottom = mThumbRect.mBottom;
  228. mOrigRect.mLeft = mThumbRect.mLeft;
  229. mOrigRect.mRight = mThumbRect.mRight;
  230. mLastDelta = 0;
  231. }
  232. else
  233. {
  234. if( 
  235. ( (LLScrollbar::VERTICAL == mOrientation) && (mThumbRect.mTop < y) ) ||
  236. ( (LLScrollbar::HORIZONTAL == mOrientation) && (x < mThumbRect.mLeft) )
  237. )
  238. {
  239. // Page up
  240. pageUp(0);
  241. }
  242. else
  243. if(
  244. ( (LLScrollbar::VERTICAL == mOrientation) && (y < mThumbRect.mBottom) ) ||
  245. ( (LLScrollbar::HORIZONTAL == mOrientation) && (mThumbRect.mRight < x) )
  246. )
  247. {
  248. // Page down
  249. pageDown(0);
  250. }
  251. }
  252. }
  253. return TRUE;
  254. }
  255. BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
  256. {
  257. // Note: we don't bother sending the event to the children (the arrow buttons)
  258. // because they'll capture the mouse whenever they need hover events.
  259. BOOL handled = FALSE;
  260. if( hasMouseCapture() )
  261. {
  262. S32 height = getRect().getHeight();
  263. S32 width = getRect().getWidth();
  264. if( VERTICAL == mOrientation )
  265. {
  266. // S32 old_pos = mThumbRect.mTop;
  267. S32 delta_pixels = y - mDragStartY;
  268. if( mOrigRect.mBottom + delta_pixels < mThickness )
  269. {
  270. delta_pixels = mThickness - mOrigRect.mBottom - 1;
  271. }
  272. else
  273. if( mOrigRect.mTop + delta_pixels > height - mThickness )
  274. {
  275. delta_pixels = height - mThickness - mOrigRect.mTop + 1;
  276. }
  277. mThumbRect.mTop = mOrigRect.mTop + delta_pixels;
  278. mThumbRect.mBottom = mOrigRect.mBottom + delta_pixels;
  279. S32 thumb_length = mThumbRect.getHeight();
  280. S32 thumb_track_length = height - 2 * mThickness;
  281. if( delta_pixels != mLastDelta || mDocChanged)
  282. {
  283. // Note: delta_pixels increases as you go up.  mDocPos increases down (line 0 is at the top of the page).
  284. S32 usable_track_length = thumb_track_length - thumb_length;
  285. if( 0 < usable_track_length )
  286. {
  287. S32 variable_lines = getDocPosMax();
  288. S32 pos = mThumbRect.mTop;
  289. F32 ratio = F32(pos - mThickness - thumb_length) / usable_track_length;
  290. S32 new_pos = llclamp( S32(variable_lines - ratio * variable_lines + 0.5f), 0, variable_lines );
  291. // Note: we do not call updateThumbRect() here.  Instead we let the thumb and the document go slightly
  292. // out of sync (less than a line's worth) to make the thumb feel responsive.
  293. changeLine( new_pos - mDocPos, FALSE );
  294. }
  295. }
  296. mLastDelta = delta_pixels;
  297. }
  298. else
  299. {
  300. // Horizontal
  301. // S32 old_pos = mThumbRect.mLeft;
  302. S32 delta_pixels = x - mDragStartX;
  303. if( mOrigRect.mLeft + delta_pixels < mThickness )
  304. {
  305. delta_pixels = mThickness - mOrigRect.mLeft - 1;
  306. }
  307. else
  308. if( mOrigRect.mRight + delta_pixels > width - mThickness )
  309. {
  310. delta_pixels = width - mThickness - mOrigRect.mRight + 1;
  311. }
  312. mThumbRect.mLeft = mOrigRect.mLeft + delta_pixels;
  313. mThumbRect.mRight = mOrigRect.mRight + delta_pixels;
  314. S32 thumb_length = mThumbRect.getWidth();
  315. S32 thumb_track_length = width - 2 * mThickness;
  316. if( delta_pixels != mLastDelta || mDocChanged)
  317. {
  318. // Note: delta_pixels increases as you go up.  mDocPos increases down (line 0 is at the top of the page).
  319. S32 usable_track_length = thumb_track_length - thumb_length;
  320. if( 0 < usable_track_length )
  321. {
  322. S32 variable_lines = getDocPosMax();
  323. S32 pos = mThumbRect.mLeft;
  324. F32 ratio = F32(pos - mThickness) / usable_track_length;
  325. S32 new_pos = llclamp( S32(ratio * variable_lines + 0.5f), 0, variable_lines);
  326. // Note: we do not call updateThumbRect() here.  Instead we let the thumb and the document go slightly
  327. // out of sync (less than a line's worth) to make the thumb feel responsive.
  328. changeLine( new_pos - mDocPos, FALSE );
  329. }
  330. }
  331. mLastDelta = delta_pixels;
  332. }
  333. getWindow()->setCursor(UI_CURSOR_ARROW);
  334. lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;
  335. handled = TRUE;
  336. }
  337. else
  338. {
  339. handled = childrenHandleHover( x, y, mask ) != NULL;
  340. }
  341. // Opaque
  342. if( !handled )
  343. {
  344. getWindow()->setCursor(UI_CURSOR_ARROW);
  345. lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)"  << llendl;
  346. handled = TRUE;
  347. }
  348. mDocChanged = FALSE;
  349. return handled;
  350. } // end handleHover
  351. BOOL LLScrollbar::handleScrollWheel(S32 x, S32 y, S32 clicks)
  352. {
  353. BOOL handled = changeLine( clicks * mStepSize, TRUE );
  354. return handled;
  355. }
  356. BOOL LLScrollbar::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  357. EDragAndDropType cargo_type, void *cargo_data, EAcceptance *accept, std::string &tooltip_msg)
  358. {
  359. // enable this to get drag and drop to control scrollbars
  360. //if (!drop)
  361. //{
  362. // //TODO: refactor this
  363. // S32 variable_lines = getDocPosMax();
  364. // S32 pos = (VERTICAL == mOrientation) ? y : x;
  365. // S32 thumb_length = (VERTICAL == mOrientation) ? mThumbRect.getHeight() : mThumbRect.getWidth();
  366. // S32 thumb_track_length = (VERTICAL == mOrientation) ? (getRect().getHeight() - 2 * SCROLLBAR_SIZE) : (getRect().getWidth() - 2 * SCROLLBAR_SIZE);
  367. // S32 usable_track_length = thumb_track_length - thumb_length;
  368. // F32 ratio = (VERTICAL == mOrientation) ? F32(pos - SCROLLBAR_SIZE - thumb_length) / usable_track_length
  369. // : F32(pos - SCROLLBAR_SIZE) / usable_track_length;
  370. // S32 new_pos = (VERTICAL == mOrientation) ? llclamp( S32(variable_lines - ratio * variable_lines + 0.5f), 0, variable_lines )
  371. // : llclamp( S32(ratio * variable_lines + 0.5f), 0, variable_lines );
  372. // changeLine( new_pos - mDocPos, TRUE );
  373. //}
  374. //return TRUE;
  375. return FALSE;
  376. }
  377. BOOL LLScrollbar::handleMouseUp(S32 x, S32 y, MASK mask)
  378. {
  379. BOOL handled = FALSE;
  380. if( hasMouseCapture() )
  381. {
  382. gFocusMgr.setMouseCapture( NULL );
  383. handled = TRUE;
  384. }
  385. else
  386. {
  387. // Opaque, so don't just check children
  388. handled = LLView::handleMouseUp( x, y, mask );
  389. }
  390. return handled;
  391. }
  392. BOOL LLScrollbar::handleDoubleClick(S32 x, S32 y, MASK mask)
  393. {
  394. // just treat a double click as a second click
  395. return handleMouseDown(x, y, mask);
  396. }
  397. void LLScrollbar::reshape(S32 width, S32 height, BOOL called_from_parent)
  398. {
  399. if (width == getRect().getWidth() && height == getRect().getHeight()) return;
  400. LLView::reshape( width, height, called_from_parent );
  401. LLButton* up_button = getChild<LLButton>("Line Up");
  402. LLButton* down_button = getChild<LLButton>("Line Down");
  403. if (mOrientation == VERTICAL)
  404. {
  405. up_button->reshape(up_button->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
  406. down_button->reshape(down_button->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
  407. up_button->setOrigin(up_button->getRect().mLeft, getRect().getHeight() - up_button->getRect().getHeight());
  408. }
  409. else
  410. {
  411. up_button->reshape(llmin(getRect().getWidth() / 2, mThickness), up_button->getRect().getHeight());
  412. down_button->reshape(llmin(getRect().getWidth() / 2, mThickness), down_button->getRect().getHeight());
  413. down_button->setOrigin(getRect().getWidth() - down_button->getRect().getWidth(), down_button->getRect().mBottom);
  414. }
  415. updateThumbRect();
  416. }
  417. void LLScrollbar::draw()
  418. {
  419. if (!getRect().isValid()) return;
  420. if(mBGVisible)
  421. {
  422. gl_rect_2d(getLocalRect(), mBGColor.get(), TRUE);
  423. }
  424. S32 local_mouse_x;
  425. S32 local_mouse_y;
  426. LLUI::getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
  427. BOOL other_captor = gFocusMgr.getMouseCapture() && gFocusMgr.getMouseCapture() != this;
  428. BOOL hovered = getEnabled() && !other_captor && (hasMouseCapture() || mThumbRect.pointInRect(local_mouse_x, local_mouse_y));
  429. if (hovered)
  430. {
  431. mCurGlowStrength = lerp(mCurGlowStrength, mHoverGlowStrength, LLCriticalDamp::getInterpolant(0.05f));
  432. }
  433. else
  434. {
  435. mCurGlowStrength = lerp(mCurGlowStrength, 0.f, LLCriticalDamp::getInterpolant(0.05f));
  436. }
  437. // Draw background and thumb.
  438. if (   ( mOrientation == VERTICAL&&(mThumbImageV.isNull() || mThumbImageH.isNull()) ) 
  439. || (mOrientation == HORIZONTAL&&(mTrackImageH.isNull() || mTrackImageV.isNull()) ))
  440. {
  441. gl_rect_2d(mOrientation == HORIZONTAL ? mThickness : 0, 
  442. mOrientation == VERTICAL ? getRect().getHeight() - 2 * mThickness : getRect().getHeight(),
  443. mOrientation == HORIZONTAL ? getRect().getWidth() - 2 * mThickness : getRect().getWidth(), 
  444. mOrientation == VERTICAL ? mThickness : 0, mTrackColor.get(), TRUE);
  445. gl_rect_2d(mThumbRect, mThumbColor.get(), TRUE);
  446. }
  447. else
  448. {
  449. // Thumb
  450. LLRect outline_rect = mThumbRect;
  451. outline_rect.stretch(2);
  452. // Background
  453. if(mOrientation == HORIZONTAL)
  454. {
  455. mTrackImageH->drawSolid(mThickness //S32 x
  456.    , 0 //S32 y
  457.    , getRect().getWidth() - 2 * mThickness  //S32 width
  458.    , getRect().getHeight() //S32 height
  459.    , mTrackColor.get());                    //const LLColor4& color
  460. if (gFocusMgr.getKeyboardFocus() == this)
  461. {
  462. mTrackImageH->draw(outline_rect, gFocusMgr.getFocusColor());
  463. }
  464. mThumbImageH->draw(mThumbRect, mThumbColor.get());
  465. if (mCurGlowStrength > 0.01f)
  466. {
  467. gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
  468. mThumbImageH->drawSolid(mThumbRect, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength));
  469. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  470. }
  471. }
  472. else if(mOrientation == VERTICAL)
  473. {
  474. mTrackImageV->drawSolid(  0 //S32 x
  475.    , mThickness //S32 y
  476.    , getRect().getWidth() //S32 width
  477.    , getRect().getHeight() - 2 * mThickness //S32 height
  478.    , mTrackColor.get());                    //const LLColor4& color
  479. if (gFocusMgr.getKeyboardFocus() == this)
  480. {
  481. mTrackImageV->draw(outline_rect, gFocusMgr.getFocusColor());
  482. }
  483. mThumbImageV->draw(mThumbRect, mThumbColor.get());
  484. if (mCurGlowStrength > 0.01f)
  485. {
  486. gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
  487. mThumbImageV->drawSolid(mThumbRect, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength));
  488. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  489. }
  490. }
  491. }
  492. // Draw children
  493. LLView::draw();
  494. } // end draw
  495. bool LLScrollbar::changeLine( S32 delta, BOOL update_thumb )
  496. {
  497. return setDocPos(mDocPos + delta, update_thumb);
  498. }
  499. void LLScrollbar::setValue(const LLSD& value) 
  500. setDocPos((S32) value.asInteger());
  501. }
  502. BOOL LLScrollbar::handleKeyHere(KEY key, MASK mask)
  503. {
  504. BOOL handled = FALSE;
  505. switch( key )
  506. {
  507. case KEY_HOME:
  508. setDocPos( 0 );
  509. handled = TRUE;
  510. break;
  511. case KEY_END:
  512. setDocPos( getDocPosMax() );
  513. handled = TRUE;
  514. break;
  515. case KEY_DOWN:
  516. setDocPos( getDocPos() + mStepSize );
  517. handled = TRUE;
  518. break;
  519. case KEY_UP:
  520. setDocPos( getDocPos() - mStepSize );
  521. handled = TRUE;
  522. break;
  523. case KEY_PAGE_DOWN:
  524. pageDown(1);
  525. break;
  526. case KEY_PAGE_UP:
  527. pageUp(1);
  528. break;
  529. }
  530. return handled;
  531. }
  532. void LLScrollbar::pageUp(S32 overlap)
  533. {
  534. if (mDocSize > mPageSize)
  535. {
  536. changeLine( -(mPageSize - overlap), TRUE );
  537. }
  538. }
  539. void LLScrollbar::pageDown(S32 overlap)
  540. {
  541. if (mDocSize > mPageSize)
  542. {
  543. changeLine( mPageSize - overlap, TRUE );
  544. }
  545. }
  546. void LLScrollbar::onLineUpBtnPressed( const LLSD& data )
  547. {
  548. changeLine( -mStepSize, TRUE );
  549. }
  550. void LLScrollbar::onLineDownBtnPressed( const LLSD& data )
  551. {
  552. changeLine( mStepSize, TRUE );
  553. }