1 files changed, 218 insertions, 205 deletions

diff --git a/indra/llui/llscrollbar.cpp b/indra/llui/llscrollbar.cpp
index 3536e6bb03..3a867a10a7 100644
--- a/indra/llui/llscrollbar.cpp
+++ b/indra/llui/llscrollbar.cpp
@@ -2,30 +2,25 @@
  * @file llscrollbar.cpp
  * @brief Scrollbar UI widget
  *
- * $LicenseInfo:firstyear=2001&license=viewergpl$
- * 
- * Copyright (c) 2001-2007, Linden Research, Inc.
- * 
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab.  Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlife.com/developers/opensource/gplv2
+ * Copyright (C) 2010, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
  * 
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlife.com/developers/opensource/flossexception
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
  * 
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  * 
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 
@@ -44,101 +39,93 @@
 #include "llfocusmgr.h"
 #include "llwindow.h"
 #include "llcontrol.h"
-#include "llglimmediate.h"
-
-LLScrollbar::LLScrollbar(
-		const LLString& name, LLRect rect,
-		LLScrollbar::ORIENTATION orientation,
-		S32 doc_size, S32 doc_pos, S32 page_size,
-		void (*change_callback)( S32 new_pos, LLScrollbar* self, void* userdata ),
-		void* callback_user_data,
-		S32 step_size)
-:		LLUICtrl( name, rect, TRUE, NULL, NULL ),
-
-		mChangeCallback( change_callback ),
-		mCallbackUserData( callback_user_data ),
-		mOrientation( orientation ),
-		mDocSize( doc_size ),
-		mDocPos( doc_pos ),
-		mPageSize( page_size ),
-		mStepSize( step_size ),
+#include "llrender.h"
+#include "lluictrlfactory.h"
+
+static LLDefaultChildRegistry::Register<LLScrollbar> register_scrollbar("scroll_bar");
+
+LLScrollbar::Params::Params()
+:	orientation ("orientation", HORIZONTAL),
+	doc_size ("doc_size", 0),
+	doc_pos ("doc_pos", 0),
+	page_size ("page_size", 0),
+	step_size ("step_size", 1),
+	thumb_image_vertical("thumb_image_vertical"),
+	thumb_image_horizontal("thumb_image_horizontal"),
+	track_image_vertical("track_image_vertical"),
+	track_image_horizontal("track_image_horizontal"),
+	track_color("track_color"),
+	thumb_color("thumb_color"),
+	thickness("thickness"),
+	up_button("up_button"),
+	down_button("down_button"),
+	left_button("left_button"),
+	right_button("right_button"),
+	bg_visible("bg_visible", false),
+	bg_color("bg_color", LLColor4::black)
+{
+	tab_stop = false;
+}
+
+LLScrollbar::LLScrollbar(const Params & p)
+:		LLUICtrl(p),
+		mChangeCallback( p.change_callback() ),
+		mOrientation( p.orientation ),
+		mDocSize( p.doc_size ),
+		mDocPos( p.doc_pos ),
+		mPageSize( p.page_size ),
+		mStepSize( p.step_size ),
 		mDocChanged(FALSE),
 		mDragStartX( 0 ),
 		mDragStartY( 0 ),
 		mHoverGlowStrength(0.15f),
 		mCurGlowStrength(0.f),
-		mTrackColor( LLUI::sColorsGroup->getColor("ScrollbarTrackColor") ),
-		mThumbColor ( LLUI::sColorsGroup->getColor("ScrollbarThumbColor") ),
-		mHighlightColor ( LLUI::sColorsGroup->getColor("DefaultHighlightLight") ),
-		mShadowColor ( LLUI::sColorsGroup->getColor("DefaultShadowLight") ),
-		mOnScrollEndCallback( NULL ),
-		mOnScrollEndData( NULL )
+		mTrackColor( p.track_color() ),
+		mThumbColor ( p.thumb_color() ),
+		mThumbImageV(p.thumb_image_vertical),
+		mThumbImageH(p.thumb_image_horizontal),
+		mTrackImageV(p.track_image_vertical),
+		mTrackImageH(p.track_image_horizontal),
+		mThickness(p.thickness.isProvided() ? p.thickness : LLUI::sSettingGroups["config"]->getS32("UIScrollbarSize")),
+		mBGVisible(p.bg_visible),
+		mBGColor(p.bg_color)
 {
-	//llassert( 0 <= mDocSize );
-	//llassert( 0 <= mDocPos && mDocPos <= mDocSize );
-	
-	setTabStop(FALSE);
 	updateThumbRect();
 	
 	// Page up and page down buttons
 	LLRect line_up_rect;
-	LLString line_up_img;
-	LLString line_up_selected_img;
-	LLString line_down_img;
-	LLString line_down_selected_img;
-
 	LLRect line_down_rect;
 
-	if( LLScrollbar::VERTICAL == mOrientation )
+	if( VERTICAL == mOrientation )
 	{
-		line_up_rect.setLeftTopAndSize( 0, getRect().getHeight(), SCROLLBAR_SIZE, SCROLLBAR_SIZE );
-		line_up_img="UIImgBtnScrollUpOutUUID";
-		line_up_selected_img="UIImgBtnScrollUpInUUID";
-
-		line_down_rect.setOriginAndSize( 0, 0, SCROLLBAR_SIZE, SCROLLBAR_SIZE );
-		line_down_img="UIImgBtnScrollDownOutUUID";
-		line_down_selected_img="UIImgBtnScrollDownInUUID";
+		line_up_rect.setLeftTopAndSize( 0, getRect().getHeight(), mThickness, mThickness );
+		line_down_rect.setOriginAndSize( 0, 0, mThickness, mThickness );
 	}
-	else
+	else // HORIZONTAL
 	{
-		// Horizontal
-		line_up_rect.setOriginAndSize( 0, 0, SCROLLBAR_SIZE, SCROLLBAR_SIZE );
-		line_up_img="UIImgBtnScrollLeftOutUUID";
-		line_up_selected_img="UIImgBtnScrollLeftInUUID";
-
-		line_down_rect.setOriginAndSize( getRect().getWidth() - SCROLLBAR_SIZE, 0, SCROLLBAR_SIZE, SCROLLBAR_SIZE );
-		line_down_img="UIImgBtnScrollRightOutUUID";
-		line_down_selected_img="UIImgBtnScrollRightInUUID";
+		line_up_rect.setOriginAndSize( 0, 0, mThickness, mThickness );
+		line_down_rect.setOriginAndSize( getRect().getWidth() - mThickness, 0, mThickness, mThickness );
 	}
 
-	LLButton* line_up_btn = new LLButton(
-		"Line Up", line_up_rect,
-		line_up_img, line_up_selected_img, "",
-		&LLScrollbar::onLineUpBtnPressed, this, LLFontGL::sSansSerif );
-	if( LLScrollbar::VERTICAL == mOrientation )
-	{
-		line_up_btn->setFollowsRight();
-		line_up_btn->setFollowsTop();
-	}
-	else
-	{
-		// horizontal
-		line_up_btn->setFollowsLeft();
-		line_up_btn->setFollowsBottom();
-	}
-	line_up_btn->setHeldDownCallback( &LLScrollbar::onLineUpBtnPressed );
-	line_up_btn->setTabStop(FALSE);
-	addChild(line_up_btn);
-
-	LLButton* line_down_btn = new LLButton(
-		"Line Down", line_down_rect,
-		line_down_img, line_down_selected_img, "",
-		&LLScrollbar::onLineDownBtnPressed, this, LLFontGL::sSansSerif );
-	line_down_btn->setFollowsRight();
-	line_down_btn->setFollowsBottom();
-	line_down_btn->setHeldDownCallback( &LLScrollbar::onLineDownBtnPressed );
-	line_down_btn->setTabStop(FALSE);
-	addChild(line_down_btn);
+	LLButton::Params up_btn(mOrientation == VERTICAL ? p.up_button : p.left_button);
+	up_btn.name(std::string("Line Up"));
+	up_btn.rect(line_up_rect);
+	up_btn.click_callback.function(boost::bind(&LLScrollbar::onLineUpBtnPressed, this, _2));
+	up_btn.mouse_held_callback.function(boost::bind(&LLScrollbar::onLineUpBtnPressed, this, _2));
+	up_btn.tab_stop(false);
+	up_btn.follows.flags = (mOrientation == VERTICAL ? (FOLLOWS_RIGHT | FOLLOWS_TOP) : (FOLLOWS_LEFT | FOLLOWS_BOTTOM));
+
+	addChild(LLUICtrlFactory::create<LLButton>(up_btn));
+
+	LLButton::Params down_btn(mOrientation == VERTICAL ? p.down_button : p.right_button);
+	down_btn.name(std::string("Line Down"));
+	down_btn.rect(line_down_rect);
+	down_btn.follows.flags(FOLLOWS_RIGHT|FOLLOWS_BOTTOM);
+	down_btn.click_callback.function(boost::bind(&LLScrollbar::onLineDownBtnPressed, this, _2));
+	down_btn.mouse_held_callback.function(boost::bind(&LLScrollbar::onLineDownBtnPressed, this, _2));
+	down_btn.tab_stop(false);
+
+	addChild(LLUICtrlFactory::create<LLButton>(down_btn));
 }
 
 
@@ -150,21 +137,33 @@ LLScrollbar::~LLScrollbar()
 void LLScrollbar::setDocParams( S32 size, S32 pos )
 {
 	mDocSize = size;
-	mDocPos = llclamp( pos, 0, getDocPosMax() );
+	setDocPos(pos);
 	mDocChanged = TRUE;
 
 	updateThumbRect();
 }
 
-void LLScrollbar::setDocPos(S32 pos)
+// returns true if document position really changed
+bool LLScrollbar::setDocPos(S32 pos, BOOL update_thumb)
 {
+	pos = llclamp(pos, 0, getDocPosMax());
 	if (pos != mDocPos)
 	{
-		mDocPos = llclamp( pos, 0, getDocPosMax() );
+		mDocPos = pos;
 		mDocChanged = TRUE;
 
-		updateThumbRect();
+		if( mChangeCallback )
+		{
+			mChangeCallback( mDocPos, this );
+		}
+
+		if( update_thumb )
+		{
+			updateThumbRect();
+		}
+		return true;
 	}
+	return false;
 }
 
 void LLScrollbar::setDocSize(S32 size)
@@ -172,7 +171,7 @@ void LLScrollbar::setDocSize(S32 size)
 	if (size != mDocSize)
 	{
 		mDocSize = size;
-		mDocPos = llclamp( mDocPos, 0, getDocPosMax() );
+		setDocPos(mDocPos);
 		mDocChanged = TRUE;
 
 		updateThumbRect();
@@ -184,7 +183,7 @@ void LLScrollbar::setPageSize( S32 page_size )
 	if (page_size != mPageSize)
 	{
 		mPageSize = page_size;
-		mDocPos = llclamp( mDocPos, 0, getDocPosMax() );
+		setDocPos(mDocPos);
 		mDocChanged = TRUE;
 
 		updateThumbRect();
@@ -210,40 +209,35 @@ void LLScrollbar::updateThumbRect()
 	const S32 THUMB_MIN_LENGTH = 16;
 
 	S32 window_length = (mOrientation == LLScrollbar::HORIZONTAL) ? getRect().getWidth() : getRect().getHeight();
-	S32 thumb_bg_length = window_length - 2 * SCROLLBAR_SIZE;
+	S32 thumb_bg_length = llmax(0, window_length - 2 * mThickness);
 	S32 visible_lines = llmin( mDocSize, mPageSize );
-	S32 thumb_length = mDocSize ? llmax( visible_lines * thumb_bg_length / mDocSize, THUMB_MIN_LENGTH ) : thumb_bg_length;
+	S32 thumb_length = mDocSize ? llmin(llmax( visible_lines * thumb_bg_length / mDocSize, THUMB_MIN_LENGTH), thumb_bg_length) : thumb_bg_length;
 
 	S32 variable_lines = mDocSize - visible_lines;
 
 	if( mOrientation == LLScrollbar::VERTICAL )
 	{ 
-		S32 thumb_start_max = thumb_bg_length + SCROLLBAR_SIZE;
-		S32 thumb_start_min = SCROLLBAR_SIZE + THUMB_MIN_LENGTH;
-		S32 thumb_start = variable_lines ? llclamp( thumb_start_max - (mDocPos * (thumb_bg_length - thumb_length)) / variable_lines, thumb_start_min, thumb_start_max ) : thumb_start_max;
+		S32 thumb_start_max = thumb_bg_length + mThickness;
+		S32 thumb_start_min = mThickness + THUMB_MIN_LENGTH;
+		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;
 
 		mThumbRect.mLeft =  0;
 		mThumbRect.mTop = thumb_start;
-		mThumbRect.mRight = SCROLLBAR_SIZE;
+		mThumbRect.mRight = mThickness;
 		mThumbRect.mBottom = thumb_start - thumb_length;
 	}
 	else
 	{
 		// Horizontal
-		S32 thumb_start_max = thumb_bg_length + SCROLLBAR_SIZE - thumb_length;
-		S32 thumb_start_min = SCROLLBAR_SIZE;
-		S32 thumb_start = variable_lines ? llclamp( thumb_start_min + (mDocPos * (thumb_bg_length - thumb_length)) / variable_lines, thumb_start_min, thumb_start_max ) : thumb_start_min;
+		S32 thumb_start_max = thumb_bg_length + mThickness - thumb_length;
+		S32 thumb_start_min = mThickness;
+		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;
 	
 		mThumbRect.mLeft = thumb_start;
-		mThumbRect.mTop = SCROLLBAR_SIZE;
+		mThumbRect.mTop = mThickness;
 		mThumbRect.mRight = thumb_start + thumb_length;
 		mThumbRect.mBottom = 0;
 	}
-	
-	if (mOnScrollEndCallback && mOnScrollEndData && (mDocPos == getDocPosMax()))
-	{
-		mOnScrollEndCallback(mOnScrollEndData);
-	}
 }
 
 BOOL LLScrollbar::handleMouseDown(S32 x, S32 y, MASK mask)
@@ -307,21 +301,21 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 //			S32 old_pos = mThumbRect.mTop;
 
 			S32 delta_pixels = y - mDragStartY;
-			if( mOrigRect.mBottom + delta_pixels < SCROLLBAR_SIZE )
+			if( mOrigRect.mBottom + delta_pixels < mThickness )
 			{
-				delta_pixels = SCROLLBAR_SIZE - mOrigRect.mBottom - 1;
+				delta_pixels = mThickness - mOrigRect.mBottom - 1;
 			}
 			else
-			if( mOrigRect.mTop + delta_pixels > height - SCROLLBAR_SIZE )
+			if( mOrigRect.mTop + delta_pixels > height - mThickness )
 			{
-				delta_pixels = height - SCROLLBAR_SIZE - mOrigRect.mTop + 1;
+				delta_pixels = height - mThickness - mOrigRect.mTop + 1;
 			}
 
 			mThumbRect.mTop = mOrigRect.mTop + delta_pixels;
 			mThumbRect.mBottom = mOrigRect.mBottom + delta_pixels;
 
 			S32 thumb_length = mThumbRect.getHeight();
-			S32 thumb_track_length = height - 2 * SCROLLBAR_SIZE;
+			S32 thumb_track_length = height - 2 * mThickness;
 
 
 			if( delta_pixels != mLastDelta || mDocChanged)
@@ -332,7 +326,7 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 				{
 					S32 variable_lines = getDocPosMax();
 					S32 pos = mThumbRect.mTop;
-					F32 ratio = F32(pos - SCROLLBAR_SIZE - thumb_length) / usable_track_length;	
+					F32 ratio = F32(pos - mThickness - thumb_length) / usable_track_length;	
 	
 					S32 new_pos = llclamp( S32(variable_lines - ratio * variable_lines + 0.5f), 0, variable_lines );
 					// Note: we do not call updateThumbRect() here.  Instead we let the thumb and the document go slightly
@@ -351,21 +345,21 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 
 			S32 delta_pixels = x - mDragStartX;
 
-			if( mOrigRect.mLeft + delta_pixels < SCROLLBAR_SIZE )
+			if( mOrigRect.mLeft + delta_pixels < mThickness )
 			{
-				delta_pixels = SCROLLBAR_SIZE - mOrigRect.mLeft - 1;
+				delta_pixels = mThickness - mOrigRect.mLeft - 1;
 			}
 			else
-			if( mOrigRect.mRight + delta_pixels > width - SCROLLBAR_SIZE )
+			if( mOrigRect.mRight + delta_pixels > width - mThickness )
 			{
-				delta_pixels = width - SCROLLBAR_SIZE - mOrigRect.mRight + 1;
+				delta_pixels = width - mThickness - mOrigRect.mRight + 1;
 			}
 
 			mThumbRect.mLeft = mOrigRect.mLeft + delta_pixels;
 			mThumbRect.mRight = mOrigRect.mRight + delta_pixels;
 			
 			S32 thumb_length = mThumbRect.getWidth();
-			S32 thumb_track_length = width - 2 * SCROLLBAR_SIZE;
+			S32 thumb_track_length = width - 2 * mThickness;
 
 			if( delta_pixels != mLastDelta || mDocChanged)
 			{	
@@ -375,7 +369,7 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 				{
 					S32 variable_lines = getDocPosMax();
 					S32 pos = mThumbRect.mLeft;
-					F32 ratio = F32(pos - SCROLLBAR_SIZE) / usable_track_length;	
+					F32 ratio = F32(pos - mThickness) / usable_track_length;	
 	
 					S32 new_pos = llclamp( S32(ratio * variable_lines + 0.5f), 0, variable_lines);
 	
@@ -394,7 +388,7 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 	}
 	else
 	{
-		handled = childrenHandleMouseUp( x, y, mask ) != NULL;
+		handled = childrenHandleHover( x, y, mask ) != NULL;
 	}
 
 	// Opaque
@@ -412,12 +406,12 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 
 BOOL LLScrollbar::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
-	changeLine( clicks * mStepSize, TRUE );
-	return TRUE;
+	BOOL handled = changeLine( clicks * mStepSize, TRUE );
+	return handled;
 }
 
 BOOL LLScrollbar::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
-									EDragAndDropType cargo_type, void *cargo_data, EAcceptance *accept, LLString &tooltip_msg)
+									EDragAndDropType cargo_type, void *cargo_data, EAcceptance *accept, std::string &tooltip_msg)
 {
 	// enable this to get drag and drop to control scrollbars
 	//if (!drop)
@@ -448,30 +442,55 @@ BOOL LLScrollbar::handleMouseUp(S32 x, S32 y, MASK mask)
 	}
 	else
 	{
-		// Opaque, so don't just check children
+		// Opaque, so don't just check children	
 		handled = LLView::handleMouseUp( x, y, mask );
 	}
 
 	return handled;
 }
 
+BOOL LLScrollbar::handleDoubleClick(S32 x, S32 y, MASK mask)
+{
+	// just treat a double click as a second click
+	return handleMouseDown(x, y, mask);
+}
+
+
 void LLScrollbar::reshape(S32 width, S32 height, BOOL called_from_parent)
 {
+	if (width == getRect().getWidth() && height == getRect().getHeight()) return;
 	LLView::reshape( width, height, called_from_parent );
+	LLButton* up_button = getChild<LLButton>("Line Up");
+	LLButton* down_button = getChild<LLButton>("Line Down");
+
+	if (mOrientation == VERTICAL)
+	{
+		up_button->reshape(up_button->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
+		down_button->reshape(down_button->getRect().getWidth(), llmin(getRect().getHeight() / 2, mThickness));
+		up_button->setOrigin(up_button->getRect().mLeft, getRect().getHeight() - up_button->getRect().getHeight());
+	}
+	else
+	{
+		up_button->reshape(llmin(getRect().getWidth() / 2, mThickness), up_button->getRect().getHeight());
+		down_button->reshape(llmin(getRect().getWidth() / 2, mThickness), down_button->getRect().getHeight());
+		down_button->setOrigin(getRect().getWidth() - down_button->getRect().getWidth(), down_button->getRect().mBottom);
+	}
 	updateThumbRect();
 }
 
 
 void LLScrollbar::draw()
 {
+	if (!getRect().isValid()) return;
+
+	if(mBGVisible)
+	{
+		gl_rect_2d(getLocalRect(), mBGColor.get(), TRUE);
+	}
+
 	S32 local_mouse_x;
 	S32 local_mouse_y;
-	LLCoordWindow cursor_pos_window;
-	getWindow()->getCursorPosition(&cursor_pos_window);
-	LLCoordGL cursor_pos_gl;
-	getWindow()->convertCoords(cursor_pos_window, &cursor_pos_gl);
-
-	screenPointToLocal(cursor_pos_gl.mX, cursor_pos_gl.mY, &local_mouse_x, &local_mouse_y);
+	LLUI::getMousePositionLocal(this, &local_mouse_x, &local_mouse_y);
 	BOOL other_captor = gFocusMgr.getMouseCapture() && gFocusMgr.getMouseCapture() != this;
 	BOOL hovered = getEnabled() && !other_captor && (hasMouseCapture() || mThumbRect.pointInRect(local_mouse_x, local_mouse_y));
 	if (hovered)
@@ -483,52 +502,67 @@ void LLScrollbar::draw()
 		mCurGlowStrength = lerp(mCurGlowStrength, 0.f, LLCriticalDamp::getInterpolant(0.05f));
 	}
 
-
 	// Draw background and thumb.
-	LLUIImage* rounded_rect_imagep = LLUI::sImageProvider->getUIImage("rounded_square.tga");
-
-	if (!rounded_rect_imagep)
+	if (   ( mOrientation == VERTICAL&&(mThumbImageV.isNull() || mThumbImageH.isNull()) ) 
+		|| (mOrientation == HORIZONTAL&&(mTrackImageH.isNull() || mTrackImageV.isNull()) ))
 	{
-		gl_rect_2d(mOrientation == HORIZONTAL ? SCROLLBAR_SIZE : 0, 
-		mOrientation == VERTICAL ? getRect().getHeight() - 2 * SCROLLBAR_SIZE : getRect().getHeight(),
-		mOrientation == HORIZONTAL ? getRect().getWidth() - 2 * SCROLLBAR_SIZE : getRect().getWidth(), 
-		mOrientation == VERTICAL ? SCROLLBAR_SIZE : 0, mTrackColor, TRUE);
+		gl_rect_2d(mOrientation == HORIZONTAL ? mThickness : 0, 
+		mOrientation == VERTICAL ? getRect().getHeight() - 2 * mThickness : getRect().getHeight(),
+		mOrientation == HORIZONTAL ? getRect().getWidth() - 2 * mThickness : getRect().getWidth(), 
+		mOrientation == VERTICAL ? mThickness : 0, mTrackColor.get(), TRUE);
 
-		gl_rect_2d(mThumbRect, mThumbColor, TRUE);
+		gl_rect_2d(mThumbRect, mThumbColor.get(), TRUE);
 
 	}
 	else
 	{
-		// Background
-		rounded_rect_imagep->drawSolid(mOrientation == HORIZONTAL ? SCROLLBAR_SIZE : 0, 
-			mOrientation == VERTICAL ? SCROLLBAR_SIZE : 0,
-			mOrientation == HORIZONTAL ? getRect().getWidth() - 2 * SCROLLBAR_SIZE : getRect().getWidth(), 
-			mOrientation == VERTICAL ? getRect().getHeight() - 2 * SCROLLBAR_SIZE : getRect().getHeight(),
-			mTrackColor);
-
 		// Thumb
 		LLRect outline_rect = mThumbRect;
 		outline_rect.stretch(2);
-
-		if (gFocusMgr.getKeyboardFocus() == this)
+		// Background
+		
+		if(mOrientation == HORIZONTAL)
 		{
-			rounded_rect_imagep->draw(outline_rect, gFocusMgr.getFocusColor());
+			mTrackImageH->drawSolid(mThickness								//S32 x
+								   , 0										//S32 y
+								   , getRect().getWidth() - 2 * mThickness  //S32 width
+								   , getRect().getHeight()					//S32 height
+								   , mTrackColor.get());                    //const LLColor4& color
+			
+			if (gFocusMgr.getKeyboardFocus() == this)
+			{
+				mTrackImageH->draw(outline_rect, gFocusMgr.getFocusColor());
+			}
+			
+			mThumbImageH->draw(mThumbRect, mThumbColor.get());
+			if (mCurGlowStrength > 0.01f)
+			{
+				gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
+				mThumbImageH->drawSolid(mThumbRect, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength));
+				gGL.setSceneBlendType(LLRender::BT_ALPHA);
+			}
+			
 		}
-
-		rounded_rect_imagep->draw(mThumbRect, mThumbColor);
-		if (mCurGlowStrength > 0.01f)
+		else if(mOrientation == VERTICAL)
 		{
-			glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-			rounded_rect_imagep->drawSolid(mThumbRect, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength));
-			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			mTrackImageV->drawSolid(  0										//S32 x
+								   , mThickness								//S32 y
+								   , getRect().getWidth()					//S32 width
+								   , getRect().getHeight() - 2 * mThickness	//S32 height
+								   , mTrackColor.get());                    //const LLColor4& color
+			if (gFocusMgr.getKeyboardFocus() == this)
+			{
+				mTrackImageV->draw(outline_rect, gFocusMgr.getFocusColor());
+			}
+			
+			mThumbImageV->draw(mThumbRect, mThumbColor.get());
+			if (mCurGlowStrength > 0.01f)
+			{
+				gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
+				mThumbImageV->drawSolid(mThumbRect, LLColor4(1.f, 1.f, 1.f, mCurGlowStrength));
+				gGL.setSceneBlendType(LLRender::BT_ALPHA);
+			}
 		}
-
-	}
-
-	BOOL was_scrolled_to_bottom = (getDocPos() == getDocPosMax());
-	if (mOnScrollEndCallback && was_scrolled_to_bottom)
-	{
-		mOnScrollEndCallback(mOnScrollEndData);
 	}
 
 	// Draw children
@@ -536,23 +570,9 @@ void LLScrollbar::draw()
 } // end draw
 
 
-void LLScrollbar::changeLine( S32 delta, BOOL update_thumb )
+bool LLScrollbar::changeLine( S32 delta, BOOL update_thumb )
 {
-	S32 new_pos = llclamp( mDocPos + delta, 0, getDocPosMax() );
-	if( new_pos != mDocPos )
-	{
-		mDocPos = new_pos;
-	}
-
-	if( mChangeCallback )
-	{
-		mChangeCallback( mDocPos, this, mCallbackUserData );
-	}
-
-	if( update_thumb )
-	{
-		updateThumbRect();
-	}
+	return setDocPos(mDocPos + delta, update_thumb);
 }
 
 void LLScrollbar::setValue(const LLSD& value) 
@@ -568,22 +588,22 @@ BOOL LLScrollbar::handleKeyHere(KEY key, MASK mask)
 	switch( key )
 	{
 	case KEY_HOME:
-		changeLine( -mDocPos, TRUE );
+		setDocPos( 0 );
 		handled = TRUE;
 		break;
 	
 	case KEY_END:
-		changeLine( getDocPosMax() - mDocPos, TRUE );
+		setDocPos( getDocPosMax() );
 		handled = TRUE;
 		break;
 	
 	case KEY_DOWN:
-		changeLine( mStepSize, TRUE );
+		setDocPos( getDocPos() + mStepSize );
 		handled = TRUE;
 		break;
 	
 	case KEY_UP:
-		changeLine( - mStepSize, TRUE );
+		setDocPos( getDocPos() - mStepSize );
 		handled = TRUE;
 		break;
 
@@ -615,19 +635,12 @@ void LLScrollbar::pageDown(S32 overlap)
 	}
 }
 
-// static
-void LLScrollbar::onLineUpBtnPressed( void* userdata )
+void LLScrollbar::onLineUpBtnPressed( const LLSD& data )
 {
-	LLScrollbar* self = (LLScrollbar*) userdata;
-
-	self->changeLine( - self->mStepSize, TRUE );
+	changeLine( -mStepSize, TRUE );
 }
 
-// static
-void LLScrollbar::onLineDownBtnPressed( void* userdata )
+void LLScrollbar::onLineDownBtnPressed( const LLSD& data )
 {
-	LLScrollbar* self = (LLScrollbar*) userdata;
-	self->changeLine( self->mStepSize, TRUE );
+	changeLine( mStepSize, TRUE );
 }
-
-