1 files changed, 321 insertions, 363 deletions

diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp
index 72fe2040af..3146418a7d 100644
--- a/indra/llui/llscrollcontainer.cpp
+++ b/indra/llui/llscrollcontainer.cpp
@@ -1,39 +1,39 @@
 /** 
  * @file llscrollcontainer.cpp
- * @brief LLScrollableContainerView base class
+ * @brief LLScrollContainer base class
  *
- * $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$
  */
 
 
 #include "linden_common.h"
 
-#include "llglimmediate.h"
 #include "llscrollcontainer.h"
+
+#include "llrender.h"
+#include "llcontainerview.h"
+#include "lllocalcliprect.h"
+// #include "llfolderview.h"
+#include "llscrollingpanellist.h"
 #include "llscrollbar.h"
 #include "llui.h"
 #include "llkeyboard.h"
@@ -41,6 +41,7 @@
 #include "llfocusmgr.h"
 #include "llframetimer.h"
 #include "lluictrlfactory.h"
+#include "llpanel.h"
 #include "llfontgl.h"
 
 ///----------------------------------------------------------------------------
@@ -49,103 +50,97 @@
 
 static const S32 HORIZONTAL_MULTIPLE = 8;
 static const S32 VERTICAL_MULTIPLE = 16;
-static const F32 MIN_AUTO_SCROLL_RATE = 120.f;
-static const F32 MAX_AUTO_SCROLL_RATE = 500.f;
 static const F32 AUTO_SCROLL_RATE_ACCEL = 120.f;
 
 ///----------------------------------------------------------------------------
-/// Class LLScrollableContainerView
+/// Class LLScrollContainer
 ///----------------------------------------------------------------------------
 
-static LLRegisterWidget<LLScrollableContainerView> r("scroll_container");
+static LLDefaultChildRegistry::Register<LLScrollContainer> r("scroll_container");
 
-// Default constructor
-LLScrollableContainerView::LLScrollableContainerView( const LLString& name,
-													  const LLRect& rect,
-													  LLView* scrolled_view,
-													  BOOL is_opaque,
-													  const LLColor4& bg_color ) :
-	LLUICtrl( name, rect, FALSE, NULL, NULL ),
-	mScrolledView( scrolled_view ),
-	mIsOpaque( is_opaque ),
-	mBackgroundColor( bg_color ),
-	mReserveScrollCorner( FALSE ),
-	mAutoScrolling( FALSE ),
-	mAutoScrollRate( 0.f )
-{
-	if( mScrolledView )
-	{
-		addChild( mScrolledView );
-	}
+#include "llscrollingpanellist.h"
+#include "llcontainerview.h"
+#include "llpanel.h"
 
-	init();
-}
+static ScrollContainerRegistry::Register<LLScrollingPanelList> r1("scrolling_panel_list");
+static ScrollContainerRegistry::Register<LLContainerView> r2("container_view");
+static ScrollContainerRegistry::Register<LLPanel> r3("panel", &LLPanel::fromXML);
 
-// LLUICtrl constructor
-LLScrollableContainerView::LLScrollableContainerView( const LLString& name, const LLRect& rect,
-							   LLUICtrl* scrolled_ctrl, BOOL is_opaque,
-							   const LLColor4& bg_color) :
-	LLUICtrl( name, rect, FALSE, NULL, NULL ),
-	mScrolledView( scrolled_ctrl ),
-	mIsOpaque( is_opaque ),
-	mBackgroundColor( bg_color ),
-	mReserveScrollCorner( FALSE ),
-	mAutoScrolling( FALSE ),
-	mAutoScrollRate( 0.f )
+LLScrollContainer::Params::Params()
+:	is_opaque("opaque"),
+	bg_color("color"),
+	border_visible("border_visible"),
+	hide_scrollbar("hide_scrollbar"),
+	min_auto_scroll_rate("min_auto_scroll_rate", 100),
+	max_auto_scroll_rate("max_auto_scroll_rate", 1000),
+	reserve_scroll_corner("reserve_scroll_corner", false)
 {
-	if( scrolled_ctrl )
-	{
-		addChild( scrolled_ctrl );
-	}
-
-	init();
+	name = "scroll_container";
+	mouse_opaque(true);
+	tab_stop(false);
 }
 
-void LLScrollableContainerView::init()
+
+// Default constructor
+LLScrollContainer::LLScrollContainer(const LLScrollContainer::Params& p)
+:	LLUICtrl(p),
+	mAutoScrolling( FALSE ),
+	mAutoScrollRate( 0.f ),
+	mBackgroundColor(p.bg_color()),
+	mIsOpaque(p.is_opaque),
+	mHideScrollbar(p.hide_scrollbar),
+	mReserveScrollCorner(p.reserve_scroll_corner),
+	mMinAutoScrollRate(p.min_auto_scroll_rate),
+	mMaxAutoScrollRate(p.max_auto_scroll_rate),
+	mScrolledView(NULL)
 {
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 	LLRect border_rect( 0, getRect().getHeight(), getRect().getWidth(), 0 );
-	mBorder = new LLViewBorder( "scroll border", border_rect, LLViewBorder::BEVEL_IN );
-	addChild( mBorder );
+	LLViewBorder::Params params;
+	params.name("scroll border");
+	params.rect(border_rect);
+	params.visible(p.border_visible);
+	params.bevel_style(LLViewBorder::BEVEL_IN);
+	mBorder = LLUICtrlFactory::create<LLViewBorder> (params);
+	LLView::addChild( mBorder );
 
 	mInnerRect.set( 0, getRect().getHeight(), getRect().getWidth(), 0 );
-	mInnerRect.stretch( -mBorder->getBorderWidth()  );
+	mInnerRect.stretch( -getBorderWidth()  );
 
 	LLRect vertical_scroll_rect = mInnerRect;
-	vertical_scroll_rect.mLeft = vertical_scroll_rect.mRight - SCROLLBAR_SIZE;
-	mScrollbar[VERTICAL] = new LLScrollbar( "scrollable vertical",
-											vertical_scroll_rect,
-											LLScrollbar::VERTICAL,
-											mInnerRect.getHeight(), 
-											0,
-											mInnerRect.getHeight(),
-											NULL, this,
-											VERTICAL_MULTIPLE);
-	addChild( mScrollbar[VERTICAL] );
-	mScrollbar[VERTICAL]->setVisible( FALSE );
-	mScrollbar[VERTICAL]->setFollowsRight();
-	mScrollbar[VERTICAL]->setFollowsTop();
-	mScrollbar[VERTICAL]->setFollowsBottom();
+	vertical_scroll_rect.mLeft = vertical_scroll_rect.mRight - scrollbar_size;
+	LLScrollbar::Params sbparams;
+	sbparams.name("scrollable vertical");
+	sbparams.rect(vertical_scroll_rect);
+	sbparams.orientation(LLScrollbar::VERTICAL);
+	sbparams.doc_size(mInnerRect.getHeight());
+	sbparams.doc_pos(0);
+	sbparams.page_size(mInnerRect.getHeight());
+	sbparams.step_size(VERTICAL_MULTIPLE);
+	sbparams.follows.flags(FOLLOWS_RIGHT | FOLLOWS_TOP | FOLLOWS_BOTTOM);
+	sbparams.visible(false);
+	sbparams.change_callback(p.scroll_callback);
+	mScrollbar[VERTICAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
+	LLView::addChild( mScrollbar[VERTICAL] );
 	
 	LLRect horizontal_scroll_rect = mInnerRect;
-	horizontal_scroll_rect.mTop = horizontal_scroll_rect.mBottom + SCROLLBAR_SIZE;
-	mScrollbar[HORIZONTAL] = new LLScrollbar( "scrollable horizontal",
-											  horizontal_scroll_rect,
-											  LLScrollbar::HORIZONTAL,
-											  mInnerRect.getWidth(),
-											  0,
-											  mInnerRect.getWidth(),
-											  NULL, this,
-											  HORIZONTAL_MULTIPLE);
-	addChild( mScrollbar[HORIZONTAL] );
-	mScrollbar[HORIZONTAL]->setVisible( FALSE );
-	mScrollbar[HORIZONTAL]->setFollowsLeft();
-	mScrollbar[HORIZONTAL]->setFollowsRight();
-
-	setTabStop(FALSE);
+	horizontal_scroll_rect.mTop = horizontal_scroll_rect.mBottom + scrollbar_size;
+	sbparams.name("scrollable horizontal");
+	sbparams.rect(horizontal_scroll_rect);
+	sbparams.orientation(LLScrollbar::HORIZONTAL);
+	sbparams.doc_size(mInnerRect.getWidth());
+	sbparams.doc_pos(0);
+	sbparams.page_size(mInnerRect.getWidth());
+	sbparams.step_size(VERTICAL_MULTIPLE);
+	sbparams.visible(false);
+	sbparams.follows.flags(FOLLOWS_LEFT | FOLLOWS_RIGHT);
+	sbparams.change_callback(p.scroll_callback);
+	mScrollbar[HORIZONTAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
+	LLView::addChild( mScrollbar[HORIZONTAL] );
 }
 
 // Destroys the object
-LLScrollableContainerView::~LLScrollableContainerView( void )
+LLScrollContainer::~LLScrollContainer( void )
 {
 	// mScrolledView and mScrollbar are child views, so the LLView
 	// destructor takes care of memory deallocation.
@@ -158,9 +153,9 @@ LLScrollableContainerView::~LLScrollableContainerView( void )
 
 // internal scrollbar handlers
 // virtual
-void LLScrollableContainerView::scrollHorizontal( S32 new_pos )
+void LLScrollContainer::scrollHorizontal( S32 new_pos )
 {
-	//llinfos << "LLScrollableContainerView::scrollHorizontal()" << llendl;
+	//llinfos << "LLScrollContainer::scrollHorizontal()" << llendl;
 	if( mScrolledView )
 	{
 		LLRect doc_rect = mScrolledView->getRect();
@@ -170,9 +165,9 @@ void LLScrollableContainerView::scrollHorizontal( S32 new_pos )
 }
 
 // virtual
-void LLScrollableContainerView::scrollVertical( S32 new_pos )
+void LLScrollContainer::scrollVertical( S32 new_pos )
 {
-	// llinfos << "LLScrollableContainerView::scrollVertical() " << new_pos << llendl;
+	// llinfos << "LLScrollContainer::scrollVertical() " << new_pos << llendl;
 	if( mScrolledView )
 	{
 		LLRect doc_rect = mScrolledView->getRect();
@@ -182,13 +177,13 @@ void LLScrollableContainerView::scrollVertical( S32 new_pos )
 }
 
 // LLView functionality
-void LLScrollableContainerView::reshape(S32 width, S32 height,
+void LLScrollContainer::reshape(S32 width, S32 height,
 										BOOL called_from_parent)
 {
 	LLUICtrl::reshape( width, height, called_from_parent );
 
-	mInnerRect.set( 0, getRect().getHeight(), getRect().getWidth(), 0 );
-	mInnerRect.stretch( -mBorder->getBorderWidth() );
+	mInnerRect = getLocalRect();
+	mInnerRect.stretch( -getBorderWidth() );
 
 	if (mScrolledView)
 	{
@@ -198,22 +193,33 @@ void LLScrollableContainerView::reshape(S32 width, S32 height,
 		S32 visible_height = 0;
 		BOOL show_v_scrollbar = FALSE;
 		BOOL show_h_scrollbar = FALSE;
-		calcVisibleSize( scrolled_rect, &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+		calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
 
 		mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
 		mScrollbar[VERTICAL]->setPageSize( visible_height );
 
 		mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
 		mScrollbar[HORIZONTAL]->setPageSize( visible_width );
+		updateScroll();
 	}
 }
 
-BOOL LLScrollableContainerView::handleKeyHere(KEY key, MASK mask)
+BOOL LLScrollContainer::handleKeyHere(KEY key, MASK mask)
 {
+	// allow scrolled view to handle keystrokes in case it delegated keyboard focus
+	// to the scroll container.  
+	// NOTE: this should not recurse indefinitely as handleKeyHere
+	// should not propagate to parent controls, so mScrolledView should *not*
+	// call LLScrollContainer::handleKeyHere in turn
+	if (mScrolledView && mScrolledView->handleKeyHere(key, mask))
+	{
+		return TRUE;
+	}
 	for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
 	{
 		if( mScrollbar[i]->handleKeyHere(key, mask) )
 		{
+			updateScroll();
 			return TRUE;
 		}
 	}	
@@ -221,203 +227,194 @@ BOOL LLScrollableContainerView::handleKeyHere(KEY key, MASK mask)
 	return FALSE;
 }
 
-BOOL LLScrollableContainerView::handleScrollWheel( S32 x, S32 y, S32 clicks )
+BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks )
 {
-	for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
+	// Give event to my child views - they may have scroll bars
+	// (Bad UI design, but technically possible.)
+	if (LLUICtrl::handleScrollWheel(x,y,clicks))
+		return TRUE;
+
+	// When the vertical scrollbar is visible, scroll wheel
+	// only affects vertical scrolling.  It's confusing to have
+	// scroll wheel perform both vertical and horizontal in a
+	// single container.
+	LLScrollbar* vertical = mScrollbar[VERTICAL];
+	if (vertical->getVisible()
+		&& vertical->getEnabled())
 	{
-		// Note: tries vertical and then horizontal
-
 		// Pretend the mouse is over the scrollbar
-		if( mScrollbar[i]->handleScrollWheel( 0, 0, clicks ) )
+		if (vertical->handleScrollWheel( 0, 0, clicks ) )
 		{
-			return TRUE;
+			updateScroll();
 		}
+		// Always eat the event
+		return TRUE;
 	}
 
-	// Eat scroll wheel event (to avoid scrolling nested containers?)
-	return TRUE;
-}
-
-BOOL LLScrollableContainerView::needsToScroll(S32 x, S32 y, LLScrollableContainerView::SCROLL_ORIENTATION axis) const
-{
-	if(mScrollbar[axis]->getVisible())
+	LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
+	// Test enablement and visibility for consistency with
+	// LLView::childrenHandleScrollWheel().
+	if (horizontal->getVisible()
+		&& horizontal->getEnabled()
+		&& horizontal->handleScrollWheel( 0, 0, clicks ) )
 	{
-		LLRect inner_rect_local( 0, mInnerRect.getHeight(), mInnerRect.getWidth(), 0 );
-		const S32 AUTOSCROLL_SIZE = 10;
-		if(mScrollbar[axis]->getVisible())
-		{
-			inner_rect_local.mRight -= SCROLLBAR_SIZE;
-			inner_rect_local.mTop += AUTOSCROLL_SIZE;
-			inner_rect_local.mBottom = inner_rect_local.mTop - AUTOSCROLL_SIZE;
-		}
-		if( inner_rect_local.pointInRect( x, y ) && (mScrollbar[axis]->getDocPos() > 0) )
-		{
-			return TRUE;
-		}
-
+		updateScroll();
+		return TRUE;
 	}
 	return FALSE;
 }
 
-BOOL LLScrollableContainerView::handleDragAndDrop(S32 x, S32 y, MASK mask,
+BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask,
 												  BOOL drop,
 												  EDragAndDropType cargo_type,
 												  void* cargo_data,
 												  EAcceptance* accept,
-												  LLString& tooltip_msg)
+												  std::string& tooltip_msg)
 {
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 	// Scroll folder view if needed.  Never accepts a drag or drop.
 	*accept = ACCEPT_NO;
-	BOOL handled = FALSE;
+	BOOL handled = autoScroll(x, y);
+
+	if( !handled )
+	{
+		handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
+											cargo_data, accept, tooltip_msg) != NULL;
+	}
+
+	return TRUE;
+}
+
+bool LLScrollContainer::autoScroll(S32 x, S32 y)
+{
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
+
+	bool scrolling = false;
 	if( mScrollbar[HORIZONTAL]->getVisible() || mScrollbar[VERTICAL]->getVisible() )
 	{
-		const S32 AUTOSCROLL_SIZE = 10;
-		S32 auto_scroll_speed = llround(mAutoScrollRate * LLFrameTimer::getFrameDeltaTimeF32());
-		
+		LLRect screen_local_extents;
+		screenRectToLocal(getRootView()->getLocalRect(), &screen_local_extents);
+
 		LLRect inner_rect_local( 0, mInnerRect.getHeight(), mInnerRect.getWidth(), 0 );
 		if(	mScrollbar[HORIZONTAL]->getVisible() )
 		{
-			inner_rect_local.mBottom += SCROLLBAR_SIZE;
+			inner_rect_local.mBottom += scrollbar_size;
 		}
 		if(	mScrollbar[VERTICAL]->getVisible() )
 		{
-			inner_rect_local.mRight -= SCROLLBAR_SIZE;
+			inner_rect_local.mRight -= scrollbar_size;
 		}
 
+		// clip rect against root view
+		inner_rect_local.intersectWith(screen_local_extents);
+
+		S32 auto_scroll_speed = llround(mAutoScrollRate * LLFrameTimer::getFrameDeltaTimeF32());
+		// autoscroll region should take up no more than one third of visible scroller area
+		S32 auto_scroll_region_width = llmin(inner_rect_local.getWidth() / 3, 10); 
+		S32 auto_scroll_region_height = llmin(inner_rect_local.getHeight() / 3, 10); 
+
 		if(	mScrollbar[HORIZONTAL]->getVisible() )
 		{
-			LLRect left_scroll_rect = inner_rect_local;
-			left_scroll_rect.mRight = AUTOSCROLL_SIZE;
+			LLRect left_scroll_rect = screen_local_extents;
+			left_scroll_rect.mRight = inner_rect_local.mLeft + auto_scroll_region_width;
 			if( left_scroll_rect.pointInRect( x, y ) && (mScrollbar[HORIZONTAL]->getDocPos() > 0) )
 			{
 				mScrollbar[HORIZONTAL]->setDocPos( mScrollbar[HORIZONTAL]->getDocPos() - auto_scroll_speed );
 				mAutoScrolling = TRUE;
-				handled = TRUE;
+				scrolling = true;
 			}
 
-			LLRect right_scroll_rect = inner_rect_local;
-			right_scroll_rect.mLeft = inner_rect_local.mRight - AUTOSCROLL_SIZE;
+			LLRect right_scroll_rect = screen_local_extents;
+			right_scroll_rect.mLeft = inner_rect_local.mRight - auto_scroll_region_width;
 			if( right_scroll_rect.pointInRect( x, y ) && (mScrollbar[HORIZONTAL]->getDocPos() < mScrollbar[HORIZONTAL]->getDocPosMax()) )
 			{
 				mScrollbar[HORIZONTAL]->setDocPos( mScrollbar[HORIZONTAL]->getDocPos() + auto_scroll_speed );
 				mAutoScrolling = TRUE;
-				handled = TRUE;
+				scrolling = true;
 			}
 		}
 		if(	mScrollbar[VERTICAL]->getVisible() )
 		{
-			LLRect bottom_scroll_rect = inner_rect_local;
-			bottom_scroll_rect.mTop = AUTOSCROLL_SIZE + bottom_scroll_rect.mBottom;
+			LLRect bottom_scroll_rect = screen_local_extents;
+			bottom_scroll_rect.mTop = inner_rect_local.mBottom + auto_scroll_region_height;
 			if( bottom_scroll_rect.pointInRect( x, y ) && (mScrollbar[VERTICAL]->getDocPos() < mScrollbar[VERTICAL]->getDocPosMax()) )
 			{
 				mScrollbar[VERTICAL]->setDocPos( mScrollbar[VERTICAL]->getDocPos() + auto_scroll_speed );
 				mAutoScrolling = TRUE;
-				handled = TRUE;
+				scrolling = true;
 			}
 
-			LLRect top_scroll_rect = inner_rect_local;
-			top_scroll_rect.mBottom = inner_rect_local.mTop - AUTOSCROLL_SIZE;
+			LLRect top_scroll_rect = screen_local_extents;
+			top_scroll_rect.mBottom = inner_rect_local.mTop - auto_scroll_region_height;
 			if( top_scroll_rect.pointInRect( x, y ) && (mScrollbar[VERTICAL]->getDocPos() > 0) )
 			{
 				mScrollbar[VERTICAL]->setDocPos( mScrollbar[VERTICAL]->getDocPos() - auto_scroll_speed );
 				mAutoScrolling = TRUE;
-				handled = TRUE;
+				scrolling = true;
 			}
 		}
 	}
-
-	if( !handled )
-	{
-		handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
-											cargo_data, accept, tooltip_msg) != NULL;
-	}
-
-	return TRUE;
-}
-
-
-BOOL LLScrollableContainerView::handleToolTip(S32 x, S32 y, LLString& msg, LLRect* sticky_rect)
-{
-	S32 local_x, local_y;
-	for( S32 i = 0; i < SCROLLBAR_COUNT; i++ )
-	{
-		local_x = x - mScrollbar[i]->getRect().mLeft;
-		local_y = y - mScrollbar[i]->getRect().mBottom;
-		if( mScrollbar[i]->handleToolTip(local_x, local_y, msg, sticky_rect) )
-		{
-			return TRUE;
-		}
-	}
-	// Handle 'child' view.
-	if( mScrolledView )
-	{
-		local_x = x - mScrolledView->getRect().mLeft;
-		local_y = y - mScrolledView->getRect().mBottom;
-		if( mScrolledView->handleToolTip(local_x, local_y, msg, sticky_rect) )
-		{
-			return TRUE;
-		}
-	}
-
-	// Opaque
-	return TRUE;
+	return scrolling;
 }
 
-void LLScrollableContainerView::calcVisibleSize( S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar ) const
-{
-	const LLRect& rect = mScrolledView->getRect();
-	calcVisibleSize(rect, visible_width, visible_height, show_h_scrollbar, show_v_scrollbar);
-}
-
-void LLScrollableContainerView::calcVisibleSize( const LLRect& doc_rect, S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar ) const
+void LLScrollContainer::calcVisibleSize( S32 *visible_width, S32 *visible_height, BOOL* show_h_scrollbar, BOOL* show_v_scrollbar ) const
 {
+	const LLRect& doc_rect = getScrolledViewRect();
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 	S32 doc_width = doc_rect.getWidth();
 	S32 doc_height = doc_rect.getHeight();
 
-	*visible_width = getRect().getWidth() - 2 * mBorder->getBorderWidth();
-	*visible_height = getRect().getHeight() - 2 * mBorder->getBorderWidth();
+	S32 border_width = getBorderWidth();
+	*visible_width = getRect().getWidth() - 2 * border_width;
+	*visible_height = getRect().getHeight() - 2 * border_width;
 	
 	*show_v_scrollbar = FALSE;
-	if( *visible_height < doc_height )
-	{
-		*show_v_scrollbar = TRUE;
-		*visible_width -= SCROLLBAR_SIZE;
-	}
-
 	*show_h_scrollbar = FALSE;
-	if( *visible_width < doc_width )
-	{
-		*show_h_scrollbar = TRUE;
-		*visible_height -= SCROLLBAR_SIZE;
 
-		// Must retest now that visible_height has changed
-		if( !*show_v_scrollbar && (*visible_height < doc_height) )
+	if (!mHideScrollbar)
+	{
+		if( *visible_height < doc_height )
 		{
 			*show_v_scrollbar = TRUE;
-			*visible_width -= SCROLLBAR_SIZE;
+			*visible_width -= scrollbar_size;
+		}
+
+		if( *visible_width < doc_width )
+		{
+			*show_h_scrollbar = TRUE;
+			*visible_height -= scrollbar_size;
+
+			// Must retest now that visible_height has changed
+			if( !*show_v_scrollbar && (*visible_height < doc_height) )
+			{
+				*show_v_scrollbar = TRUE;
+				*visible_width -= scrollbar_size;
+			}
 		}
 	}
 }
+	
 
-void LLScrollableContainerView::draw()
+void LLScrollContainer::draw()
 {
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 	if (mAutoScrolling)
 	{
 		// add acceleration to autoscroll
-		mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), MAX_AUTO_SCROLL_RATE);
+		mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), mMaxAutoScrollRate);
 	}
 	else
 	{
-		// reset to minimum
-		mAutoScrollRate = MIN_AUTO_SCROLL_RATE;
+		// reset to minimum for next time
+		mAutoScrollRate = mMinAutoScrollRate;
 	}
-	// clear this flag to be set on next call to handleDragAndDrop
+	// clear this flag to be set on next call to autoScroll
 	mAutoScrolling = FALSE;
 
 	// auto-focus when scrollbar active
 	// this allows us to capture user intent (i.e. stop automatically scrolling the view/etc)
-	if (!gFocusMgr.childHasKeyboardFocus(this) && 
-		(mScrollbar[VERTICAL]->hasMouseCapture() || mScrollbar[HORIZONTAL]->hasMouseCapture()))
+	if (!hasFocus() 
+		&& (mScrollbar[VERTICAL]->hasMouseCapture() || mScrollbar[HORIZONTAL]->hasMouseCapture()))
 	{
 		focusFirstItem();
 	}
@@ -425,8 +422,8 @@ void LLScrollableContainerView::draw()
 	// Draw background
 	if( mIsOpaque )
 	{
-		LLGLSNoTexture no_texture;
-		gGL.color4fv( mBackgroundColor.mV );
+		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+		gGL.color4fv( mBackgroundColor.get().mV );
 		gl_rect_2d( mInnerRect );
 	}
 	
@@ -444,12 +441,12 @@ void LLScrollableContainerView::draw()
 			S32 visible_height = 0;
 			BOOL show_v_scrollbar = FALSE;
 			BOOL show_h_scrollbar = FALSE;
-			calcVisibleSize( mScrolledView->getRect(), &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+			calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
 
 			LLLocalClipRect clip(LLRect(mInnerRect.mLeft, 
-					mInnerRect.mBottom + (show_h_scrollbar ? SCROLLBAR_SIZE : 0) + visible_height,
-					visible_width,
-					mInnerRect.mBottom + (show_h_scrollbar ? SCROLLBAR_SIZE : 0)
+					mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0) + visible_height,
+					mInnerRect.mRight - (show_v_scrollbar ? scrollbar_size: 0),
+					mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0)
 					));
 			drawChild(mScrolledView);
 		}
@@ -480,16 +477,32 @@ void LLScrollableContainerView::draw()
 			sDepth--;
 		}
 	}
+} // end draw
 
-	if (sDebugRects)
+bool LLScrollContainer::addChild(LLView* view, S32 tab_group)
+{
+	if (!mScrolledView)
 	{
-		drawDebugRect();
+		// Use the first panel or container as the scrollable view (bit of a hack)
+		mScrolledView = view;
 	}
 
-} // end draw
+	bool ret_val = LLView::addChild(view, tab_group);
+
+	//bring the scrollbars to the front
+	sendChildToFront( mScrollbar[HORIZONTAL] );
+	sendChildToFront( mScrollbar[VERTICAL] );
+
+	return ret_val;
+}
 
-void LLScrollableContainerView::updateScroll()
+void LLScrollContainer::updateScroll()
 {
+	if (!mScrolledView)
+	{
+		return;
+	}
+	static LLUICachedControl<S32> scrollbar_size ("UIScrollbarSize", 0);
 	LLRect doc_rect = mScrolledView->getRect();
 	S32 doc_width = doc_rect.getWidth();
 	S32 doc_height = doc_rect.getHeight();
@@ -497,9 +510,9 @@ void LLScrollableContainerView::updateScroll()
 	S32 visible_height = 0;
 	BOOL show_v_scrollbar = FALSE;
 	BOOL show_h_scrollbar = FALSE;
-	calcVisibleSize( doc_rect, &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+	calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
 
-	S32 border_width = mBorder->getBorderWidth();
+	S32 border_width = getBorderWidth();
 	if( show_v_scrollbar )
 	{
 		if( doc_rect.mTop < getRect().getHeight() - border_width )
@@ -513,15 +526,15 @@ void LLScrollableContainerView::updateScroll()
 		S32 v_scrollbar_height = visible_height;
 		if( !show_h_scrollbar && mReserveScrollCorner )
 		{
-			v_scrollbar_height -= SCROLLBAR_SIZE;
+			v_scrollbar_height -= scrollbar_size;
 		}
-		mScrollbar[VERTICAL]->reshape( SCROLLBAR_SIZE, v_scrollbar_height, TRUE );
+		mScrollbar[VERTICAL]->reshape( scrollbar_size, v_scrollbar_height, TRUE );
 
 		// Make room for the horizontal scrollbar (or not)
 		S32 v_scrollbar_offset = 0;
 		if( show_h_scrollbar || mReserveScrollCorner )
 		{
-			v_scrollbar_offset = SCROLLBAR_SIZE;
+			v_scrollbar_offset = scrollbar_size;
 		}
 		LLRect r = mScrollbar[VERTICAL]->getRect();
 		r.translate( 0, mInnerRect.mBottom - r.mBottom + v_scrollbar_offset );
@@ -551,9 +564,9 @@ void LLScrollableContainerView::updateScroll()
 		S32 h_scrollbar_width = visible_width;
 		if( !show_v_scrollbar && mReserveScrollCorner )
 		{
-			h_scrollbar_width -= SCROLLBAR_SIZE;
+			h_scrollbar_width -= scrollbar_size;
 		}
-		mScrollbar[HORIZONTAL]->reshape( h_scrollbar_width, SCROLLBAR_SIZE, TRUE );
+		mScrollbar[HORIZONTAL]->reshape( h_scrollbar_width, scrollbar_size, TRUE );
 	}
 	else
 	{
@@ -570,104 +583,119 @@ void LLScrollableContainerView::updateScroll()
 	mScrollbar[VERTICAL]->setPageSize( visible_height );
 } // end updateScroll
 
-void LLScrollableContainerView::setBorderVisible(BOOL b)
+void LLScrollContainer::setBorderVisible(BOOL b)
 {
 	mBorder->setVisible( b );
+	// Recompute inner rect, as border visibility changes it
+	mInnerRect = getLocalRect();
+	mInnerRect.stretch( -getBorderWidth() );
 }
 
-// Scroll so that as much of rect as possible is showing (where rect is defined in the space of scroller view, not scrolled)
-void LLScrollableContainerView::scrollToShowRect(const LLRect& rect, const LLCoordGL& desired_offset)
+LLRect LLScrollContainer::getVisibleContentRect()
 {
-	if (!mScrolledView)
-	{
-		llwarns << "LLScrollableContainerView::scrollToShowRect with no view!" << llendl;
-		return;
-	}
+	updateScroll();
+	LLRect visible_rect = getContentWindowRect();
+	LLRect contents_rect = mScrolledView->getRect();
+	visible_rect.translate(-contents_rect.mLeft, -contents_rect.mBottom);
+	return visible_rect;
+}
 
+LLRect LLScrollContainer::getContentWindowRect()
+{
+	updateScroll();
+	LLRect scroller_view_rect;
 	S32 visible_width = 0;
 	S32 visible_height = 0;
-	BOOL show_v_scrollbar = FALSE;
 	BOOL show_h_scrollbar = FALSE;
-	const LLRect& scrolled_rect = mScrolledView->getRect();
-	calcVisibleSize( scrolled_rect, &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
-
-	// can't be so far left that right side of rect goes off screen, or so far right that left side does
-	S32 horiz_offset = llclamp(desired_offset.mX, llmin(0, -visible_width + rect.getWidth()), 0);
-	// can't be so high that bottom of rect goes off screen, or so low that top does
-	S32 vert_offset = llclamp(desired_offset.mY, 0, llmax(0, visible_height - rect.getHeight()));
-
-	// Vertical
-	// 1. First make sure the top is visible
-	// 2. Then, if possible without hiding the top, make the bottom visible.
-	S32 vert_pos = mScrollbar[VERTICAL]->getDocPos();
-
-	// find scrollbar position to get top of rect on screen (scrolling up)
-	S32 top_offset = scrolled_rect.mTop - rect.mTop - vert_offset;
-	// find scrollbar position to get bottom of rect on screen (scrolling down)
-	S32 bottom_offset = vert_offset == 0 ? scrolled_rect.mTop - rect.mBottom - visible_height : top_offset;
-	// scroll up far enough to see top or scroll down just enough if item is bigger than visual area
-	if( vert_pos >= top_offset || visible_height < rect.getHeight())
-	{
-		vert_pos = top_offset;
-	}
-	// else scroll down far enough to see bottom
-	else
-	if( vert_pos <= bottom_offset )
+	BOOL show_v_scrollbar = FALSE;
+	calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+	S32 border_width = getBorderWidth();
+	scroller_view_rect.setOriginAndSize(border_width, 
+										show_h_scrollbar ? mScrollbar[HORIZONTAL]->getRect().mTop : border_width, 
+										visible_width, 
+										visible_height);
+	return scroller_view_rect;
+}
+
+// rect is in document coordinates, constraint is in display coordinates relative to content window rect
+void LLScrollContainer::scrollToShowRect(const LLRect& rect, const LLRect& constraint)
+{
+	if (!mScrolledView)
 	{
-		vert_pos = bottom_offset;
+		llwarns << "LLScrollContainer::scrollToShowRect with no view!" << llendl;
+		return;
 	}
 
+	LLRect content_window_rect = getContentWindowRect();
+	// get document rect
+	LLRect scrolled_rect = mScrolledView->getRect();
+
+	// shrink target rect to fit within constraint region, biasing towards top left
+	LLRect rect_to_constrain = rect;
+	rect_to_constrain.mBottom = llmax(rect_to_constrain.mBottom, rect_to_constrain.mTop - constraint.getHeight());
+	rect_to_constrain.mRight = llmin(rect_to_constrain.mRight, rect_to_constrain.mLeft + constraint.getWidth());
+
+	// calculate allowable positions for scroller window in document coordinates
+	LLRect allowable_scroll_rect(rect_to_constrain.mRight - constraint.mRight,
+								rect_to_constrain.mBottom - constraint.mBottom,
+								rect_to_constrain.mLeft - constraint.mLeft,
+								rect_to_constrain.mTop - constraint.mTop);
+
+	// translate from allowable region for lower left corner to upper left corner
+	allowable_scroll_rect.translate(0, content_window_rect.getHeight());
+
+	S32 vert_pos = llclamp(mScrollbar[VERTICAL]->getDocPos(), 
+					mScrollbar[VERTICAL]->getDocSize() - allowable_scroll_rect.mTop, // min vertical scroll
+					mScrollbar[VERTICAL]->getDocSize() - allowable_scroll_rect.mBottom); // max vertical scroll	
+
 	mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
-	mScrollbar[VERTICAL]->setPageSize( visible_height );
+	mScrollbar[VERTICAL]->setPageSize( content_window_rect.getHeight() );
 	mScrollbar[VERTICAL]->setDocPos( vert_pos );
 
-	// Horizontal
-	// 1. First make sure left side is visible
-	// 2. Then, if possible without hiding the left side, make the right side visible.
-	S32 horiz_pos = mScrollbar[HORIZONTAL]->getDocPos();
-	S32 left_offset = rect.mLeft - scrolled_rect.mLeft + horiz_offset;
-	S32 right_offset = horiz_offset == 0 ? rect.mRight - scrolled_rect.mLeft - visible_width : left_offset;
+	S32 horizontal_pos = llclamp(mScrollbar[HORIZONTAL]->getDocPos(), 
+								allowable_scroll_rect.mLeft,
+								allowable_scroll_rect.mRight);
 
-	if( horiz_pos >= left_offset || visible_width < rect.getWidth() )
-	{
-		horiz_pos = left_offset;
-	}
-	else if( horiz_pos <= right_offset )
-	{
-		horiz_pos = right_offset;
-	}
-	
 	mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
-	mScrollbar[HORIZONTAL]->setPageSize( visible_width );
-	mScrollbar[HORIZONTAL]->setDocPos( horiz_pos );
+	mScrollbar[HORIZONTAL]->setPageSize( content_window_rect.getWidth() );
+	mScrollbar[HORIZONTAL]->setDocPos( horizontal_pos );
 
 	// propagate scroll to document
 	updateScroll();
+
+	// In case we are in accordion tab notify parent to show selected rectangle
+	LLRect screen_rc;
+	localRectToScreen(rect_to_constrain, &screen_rc);
+	notifyParent(LLSD().with("scrollToShowRect",screen_rc.getValue()));
 }
 
-void LLScrollableContainerView::pageUp(S32 overlap)
+void LLScrollContainer::pageUp(S32 overlap)
 {
 	mScrollbar[VERTICAL]->pageUp(overlap);
+	updateScroll();
 }
 
-void LLScrollableContainerView::pageDown(S32 overlap)
+void LLScrollContainer::pageDown(S32 overlap)
 {
 	mScrollbar[VERTICAL]->pageDown(overlap);
+	updateScroll();
 }
 
-void LLScrollableContainerView::goToTop()
+void LLScrollContainer::goToTop()
 {
 	mScrollbar[VERTICAL]->setDocPos(0);
+	updateScroll();
 }
 
-void LLScrollableContainerView::goToBottom()
+void LLScrollContainer::goToBottom()
 {
 	mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocSize());
+	updateScroll();
 }
 
-S32 LLScrollableContainerView::getBorderWidth() const
+S32 LLScrollContainer::getBorderWidth() const
 {
-	if (mBorder)
+	if (mBorder->getVisible())
 	{
 		return mBorder->getBorderWidth();
 	}
@@ -675,73 +703,3 @@ S32 LLScrollableContainerView::getBorderWidth() const
 	return 0;
 }
 
-// virtual
-LLXMLNodePtr LLScrollableContainerView::getXML(bool save_children) const
-{
-	LLXMLNodePtr node = LLView::getXML();
-
-	// Attributes
-
-	node->createChild("opaque", TRUE)->setBoolValue(mIsOpaque);
-
-	if (mIsOpaque)
-	{
-		node->createChild("color", TRUE)->setFloatValue(4, mBackgroundColor.mV);
-	}
-
-	// Contents
-
-	LLXMLNodePtr child_node = mScrolledView->getXML();
-
-	node->addChild(child_node);
-
-	return node;
-}
-
-LLView* LLScrollableContainerView::fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory)
-{
-	LLString name("scroll_container");
-	node->getAttributeString("name", name);
-
-	LLRect rect;
-	createRect(node, rect, parent, LLRect());
-	
-	BOOL opaque = FALSE;
-	node->getAttributeBOOL("opaque", opaque);
-
-	LLColor4 color(0,0,0,0);
-	LLUICtrlFactory::getAttributeColor(node,"color", color);
-
-	// Create the scroll view
-	LLScrollableContainerView *ret = new LLScrollableContainerView(name, rect, (LLPanel*)NULL, opaque, color);
-
-	LLPanel* panelp = NULL;
-
-	// Find a child panel to add
-	LLXMLNodePtr child;
-	for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
-	{
-		LLView *control = factory->createCtrlWidget(panelp, child);
-		if (control && control->isPanel())
-		{
-			if (panelp)
-			{
-				llinfos << "Warning! Attempting to put multiple panels into a scrollable container view!" << llendl;
-				delete control;
-			}
-			else
-			{
-				panelp = (LLPanel*)control;
-			}
-		}
-	}
-
-	if (panelp == NULL)
-	{
-		panelp = new LLPanel("dummy", LLRect::null, FALSE);
-	}
-
-	ret->mScrolledView = panelp;
-
-	return ret;
-}