Merge pull request #1476 from secondlife/marchcat/x-b-merge

Maint X -> Maint B merge

1 files changed, 592 insertions, 592 deletions

diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp
index 22d27b1f2a..d0b28e8f22 100644
--- a/indra/llui/llscrollcontainer.cpp
+++ b/indra/llui/llscrollcontainer.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llscrollcontainer.cpp
  * @brief LLScrollContainer base class
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * 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.
- * 
+ *
  * 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.
- * 
+ *
  * 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
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -66,144 +66,144 @@ static ScrollContainerRegistry::Register<LLContainerView> r2("container_view");
 static ScrollContainerRegistry::Register<LLPanel> r3("panel", &LLPanel::fromXML);
 
 LLScrollContainer::Params::Params()
-:	is_opaque("opaque"),
-	bg_color("color"),
-	border_visible("border_visible"),
-	hide_scrollbar("hide_scrollbar"),
-	ignore_arrow_keys("ignore_arrow_keys"),
-	min_auto_scroll_rate("min_auto_scroll_rate", 100),
-	max_auto_scroll_rate("max_auto_scroll_rate", 1000),
-	max_auto_scroll_zone("max_auto_scroll_zone", 16),
-	reserve_scroll_corner("reserve_scroll_corner", false),
-	size("size", -1)
+:   is_opaque("opaque"),
+    bg_color("color"),
+    border_visible("border_visible"),
+    hide_scrollbar("hide_scrollbar"),
+    ignore_arrow_keys("ignore_arrow_keys"),
+    min_auto_scroll_rate("min_auto_scroll_rate", 100),
+    max_auto_scroll_rate("max_auto_scroll_rate", 1000),
+    max_auto_scroll_zone("max_auto_scroll_zone", 16),
+    reserve_scroll_corner("reserve_scroll_corner", false),
+    size("size", -1)
 {}
 
 
 // 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),
-	mIgnoreArrowKeys(p.ignore_arrow_keys),
-	mReserveScrollCorner(p.reserve_scroll_corner),
-	mMinAutoScrollRate(p.min_auto_scroll_rate),
-	mMaxAutoScrollRate(p.max_auto_scroll_rate),
-	mMaxAutoScrollZone(p.max_auto_scroll_zone),
-	mScrolledView(NULL),
-	mSize(p.size)
+:   LLUICtrl(p),
+    mAutoScrolling( FALSE ),
+    mAutoScrollRate( 0.f ),
+    mBackgroundColor(p.bg_color()),
+    mIsOpaque(p.is_opaque),
+    mHideScrollbar(p.hide_scrollbar),
+    mIgnoreArrowKeys(p.ignore_arrow_keys),
+    mReserveScrollCorner(p.reserve_scroll_corner),
+    mMinAutoScrollRate(p.min_auto_scroll_rate),
+    mMaxAutoScrollRate(p.max_auto_scroll_rate),
+    mMaxAutoScrollZone(p.max_auto_scroll_zone),
+    mScrolledView(NULL),
+    mSize(p.size)
 {
-	static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
-	S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
-
-	LLRect border_rect( 0, getRect().getHeight(), getRect().getWidth(), 0 );
-	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 = getLocalRect();
-	mInnerRect.stretch( -getBorderWidth() );
-
-	LLRect vertical_scroll_rect = mInnerRect;
-	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;
-	horizontal_scroll_rect.mTop = scrollbar_size;
-	horizontal_scroll_rect.mRight = mInnerRect.getWidth();
-	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 | FOLLOWS_BOTTOM);
-	sbparams.change_callback(p.scroll_callback);
-	mScrollbar[HORIZONTAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
-	LLView::addChild( mScrollbar[HORIZONTAL] );
+    static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
+    S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
+
+    LLRect border_rect( 0, getRect().getHeight(), getRect().getWidth(), 0 );
+    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 = getLocalRect();
+    mInnerRect.stretch( -getBorderWidth() );
+
+    LLRect vertical_scroll_rect = mInnerRect;
+    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;
+    horizontal_scroll_rect.mTop = scrollbar_size;
+    horizontal_scroll_rect.mRight = mInnerRect.getWidth();
+    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 | FOLLOWS_BOTTOM);
+    sbparams.change_callback(p.scroll_callback);
+    mScrollbar[HORIZONTAL] = LLUICtrlFactory::create<LLScrollbar> (sbparams);
+    LLView::addChild( mScrollbar[HORIZONTAL] );
 }
 
 // Destroys the object
 LLScrollContainer::~LLScrollContainer( void )
 {
-	// mScrolledView and mScrollbar are child views, so the LLView
-	// destructor takes care of memory deallocation.
-	for( S32 i = 0; i < ORIENTATION_COUNT; i++ )
-	{
-		mScrollbar[i] = NULL;
-	}
-	mScrolledView = NULL;
+    // mScrolledView and mScrollbar are child views, so the LLView
+    // destructor takes care of memory deallocation.
+    for( S32 i = 0; i < ORIENTATION_COUNT; i++ )
+    {
+        mScrollbar[i] = NULL;
+    }
+    mScrolledView = NULL;
 }
 
 // internal scrollbar handlers
 // virtual
 void LLScrollContainer::scrollHorizontal( S32 new_pos )
 {
-	if( mScrolledView )
-	{
-		LLRect doc_rect = mScrolledView->getRect();
-		S32 old_pos = -(doc_rect.mLeft - mInnerRect.mLeft);
-		mScrolledView->translate( -(new_pos - old_pos), 0 );
-	}
+    if( mScrolledView )
+    {
+        LLRect doc_rect = mScrolledView->getRect();
+        S32 old_pos = -(doc_rect.mLeft - mInnerRect.mLeft);
+        mScrolledView->translate( -(new_pos - old_pos), 0 );
+    }
 }
 
 // virtual
 void LLScrollContainer::scrollVertical( S32 new_pos )
 {
-	if( mScrolledView )
-	{
-		LLRect doc_rect = mScrolledView->getRect();
-		S32 old_pos = doc_rect.mTop - mInnerRect.mTop;
-		mScrolledView->translate( 0, new_pos - old_pos );
-	}
+    if( mScrolledView )
+    {
+        LLRect doc_rect = mScrolledView->getRect();
+        S32 old_pos = doc_rect.mTop - mInnerRect.mTop;
+        mScrolledView->translate( 0, new_pos - old_pos );
+    }
 }
 
 // LLView functionality
 void LLScrollContainer::reshape(S32 width, S32 height,
-										BOOL called_from_parent)
+                                        BOOL called_from_parent)
 {
-	LLUICtrl::reshape( width, height, called_from_parent );
+    LLUICtrl::reshape( width, height, called_from_parent );
 
-	mInnerRect = getLocalRect();
-	mInnerRect.stretch( -getBorderWidth() );
+    mInnerRect = getLocalRect();
+    mInnerRect.stretch( -getBorderWidth() );
 
-	if (mScrolledView)
-	{
-		const LLRect& scrolled_rect = mScrolledView->getRect();
+    if (mScrolledView)
+    {
+        const LLRect& scrolled_rect = mScrolledView->getRect();
 
-		S32 visible_width = 0;
-		S32 visible_height = 0;
-		BOOL show_v_scrollbar = FALSE;
-		BOOL show_h_scrollbar = FALSE;
-		calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+        S32 visible_width = 0;
+        S32 visible_height = 0;
+        BOOL show_v_scrollbar = FALSE;
+        BOOL show_h_scrollbar = FALSE;
+        calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
 
-		mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
-		mScrollbar[VERTICAL]->setPageSize( visible_height );
+        mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
+        mScrollbar[VERTICAL]->setPageSize( visible_height );
 
-		mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
-		mScrollbar[HORIZONTAL]->setPageSize( visible_width );
-		updateScroll();
-	}
+        mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
+        mScrollbar[HORIZONTAL]->setPageSize( visible_width );
+        updateScroll();
+    }
 }
 
 // virtual
@@ -227,576 +227,576 @@ 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 < ORIENTATION_COUNT; i++ )
-	{
-		if( mScrollbar[i]->handleKeyHere(key, mask) )
-		{
-			updateScroll();
-			return TRUE;
-		}
-	}	
-
-	return FALSE;
+    // 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 < ORIENTATION_COUNT; i++ )
+    {
+        if( mScrollbar[i]->handleKeyHere(key, mask) )
+        {
+            updateScroll();
+            return TRUE;
+        }
+    }
+
+    return FALSE;
 }
 
 BOOL LLScrollContainer::handleUnicodeCharHere(llwchar uni_char)
 {
-	if (mScrolledView && mScrolledView->handleUnicodeCharHere(uni_char))
-	{
-		return TRUE;
-	}
-	return FALSE;
+    if (mScrolledView && mScrolledView->handleUnicodeCharHere(uni_char))
+    {
+        return TRUE;
+    }
+    return FALSE;
 }
 
 BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks )
 {
-	// 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())
-	{
-		// Pretend the mouse is over the scrollbar
-		if (vertical->handleScrollWheel( 0, 0, clicks ) )
-		{
-			updateScroll();
-		}
-		// Always eat the event
-		return TRUE;
-	}
-
-	LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
-	// Test enablement and visibility for consistency with
-	// LLView::childrenHandleScrollWheel().
-	if (horizontal->getVisible()
-		&& horizontal->getEnabled()
-		&& horizontal->handleScrollWheel( 0, 0, clicks ) )
-	{
-		updateScroll();
-		return TRUE;
-	}
-	return FALSE;
+    // 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())
+    {
+        // Pretend the mouse is over the scrollbar
+        if (vertical->handleScrollWheel( 0, 0, clicks ) )
+        {
+            updateScroll();
+        }
+        // Always eat the event
+        return TRUE;
+    }
+
+    LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
+    // Test enablement and visibility for consistency with
+    // LLView::childrenHandleScrollWheel().
+    if (horizontal->getVisible()
+        && horizontal->getEnabled()
+        && horizontal->handleScrollWheel( 0, 0, clicks ) )
+    {
+        updateScroll();
+        return TRUE;
+    }
+    return FALSE;
 }
 
 BOOL LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks)
 {
-	if (LLUICtrl::handleScrollHWheel(x,y,clicks))
-	{
-		return TRUE;
-	}
-
-	LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
-	if (horizontal->getVisible()
-		&& horizontal->getEnabled()
-		&& horizontal->handleScrollHWheel( 0, 0, clicks ) )
-	{
-		updateScroll();
-		return TRUE;
-	}
-
-	return FALSE;
+    if (LLUICtrl::handleScrollHWheel(x,y,clicks))
+    {
+        return TRUE;
+    }
+
+    LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
+    if (horizontal->getVisible()
+        && horizontal->getEnabled()
+        && horizontal->handleScrollHWheel( 0, 0, clicks ) )
+    {
+        updateScroll();
+        return TRUE;
+    }
+
+    return FALSE;
 }
 
 BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask,
-												  BOOL drop,
-												  EDragAndDropType cargo_type,
-												  void* cargo_data,
-												  EAcceptance* accept,
-												  std::string& tooltip_msg)
+                                                  BOOL drop,
+                                                  EDragAndDropType cargo_type,
+                                                  void* cargo_data,
+                                                  EAcceptance* accept,
+                                                  std::string& tooltip_msg)
 {
-	// Scroll folder view if needed.  Never accepts a drag or drop.
-	*accept = ACCEPT_NO;
-	BOOL handled = autoScroll(x, y);
+    // Scroll folder view if needed.  Never accepts a drag or drop.
+    *accept = ACCEPT_NO;
+    BOOL handled = autoScroll(x, y);
 
-	if( !handled )
-	{
-		handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
-											cargo_data, accept, tooltip_msg) != NULL;
-	}
+    if( !handled )
+    {
+        handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
+                                            cargo_data, accept, tooltip_msg) != NULL;
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 bool LLScrollContainer::canAutoScroll(S32 x, S32 y)
 {
-	if (mAutoScrolling)
-	{
-		return true; // already scrolling
-	}
-	return autoScroll(x, y, false);
+    if (mAutoScrolling)
+    {
+        return true; // already scrolling
+    }
+    return autoScroll(x, y, false);
 }
 
 bool LLScrollContainer::autoScroll(S32 x, S32 y)
 {
-	return autoScroll(x, y, true);
+    return autoScroll(x, y, true);
 }
 
 bool LLScrollContainer::autoScroll(S32 x, S32 y, bool do_scroll)
 {
-	static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
-	S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
-
-	bool scrolling = false;
-	if( mScrollbar[HORIZONTAL]->getVisible() || mScrollbar[VERTICAL]->getVisible() )
-	{
-		LLRect screen_local_extents;
-		screenRectToLocal(getRootView()->getLocalRect(), &screen_local_extents);
-
-		LLRect inner_rect_local( 0, mInnerRect.getHeight(), mInnerRect.getWidth(), 0 );
-		// Note: Will also include scrollers as scroll zones, so opposite
-		// scroll zones might have different size due to visible scrollers
-		if(	mScrollbar[HORIZONTAL]->getVisible() )
-		{
-			inner_rect_local.mBottom += scrollbar_size;
-		}
-		if(	mScrollbar[VERTICAL]->getVisible() )
-		{
-			inner_rect_local.mRight -= scrollbar_size;
-		}
-
-		// clip rect against root view
-		inner_rect_local.intersectWith(screen_local_extents);
-
-		S32 auto_scroll_speed = ll_round(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, (S32)mMaxAutoScrollZone); 
-		S32 auto_scroll_region_height = llmin(inner_rect_local.getHeight() / 3, (S32)mMaxAutoScrollZone); 
-
-		if(	mScrollbar[HORIZONTAL]->getVisible() )
-		{
-			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) )
-			{
-				if (do_scroll)
-				{
-					mScrollbar[HORIZONTAL]->setDocPos(mScrollbar[HORIZONTAL]->getDocPos() - auto_scroll_speed);
-					mAutoScrolling = TRUE;
-				}
-				scrolling = true;
-			}
-
-			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()) )
-			{
-				if (do_scroll)
-				{
-					mScrollbar[HORIZONTAL]->setDocPos(mScrollbar[HORIZONTAL]->getDocPos() + auto_scroll_speed);
-					mAutoScrolling = TRUE;
-				}
-				scrolling = true;
-			}
-		}
-		if(	mScrollbar[VERTICAL]->getVisible() )
-		{
-			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()) )
-			{
-				if (do_scroll)
-				{
-					mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocPos() + auto_scroll_speed);
-					mAutoScrolling = TRUE;
-				}
-				scrolling = true;
-			}
-
-			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) )
-			{
-				if (do_scroll)
-				{
-					mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocPos() - auto_scroll_speed);
-					mAutoScrolling = TRUE;
-				}
-				scrolling = true;
-			}
-		}
-	}
-	return scrolling;
+    static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
+    S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
+
+    bool scrolling = false;
+    if( mScrollbar[HORIZONTAL]->getVisible() || mScrollbar[VERTICAL]->getVisible() )
+    {
+        LLRect screen_local_extents;
+        screenRectToLocal(getRootView()->getLocalRect(), &screen_local_extents);
+
+        LLRect inner_rect_local( 0, mInnerRect.getHeight(), mInnerRect.getWidth(), 0 );
+        // Note: Will also include scrollers as scroll zones, so opposite
+        // scroll zones might have different size due to visible scrollers
+        if( mScrollbar[HORIZONTAL]->getVisible() )
+        {
+            inner_rect_local.mBottom += scrollbar_size;
+        }
+        if( mScrollbar[VERTICAL]->getVisible() )
+        {
+            inner_rect_local.mRight -= scrollbar_size;
+        }
+
+        // clip rect against root view
+        inner_rect_local.intersectWith(screen_local_extents);
+
+        S32 auto_scroll_speed = ll_round(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, (S32)mMaxAutoScrollZone);
+        S32 auto_scroll_region_height = llmin(inner_rect_local.getHeight() / 3, (S32)mMaxAutoScrollZone);
+
+        if( mScrollbar[HORIZONTAL]->getVisible() )
+        {
+            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) )
+            {
+                if (do_scroll)
+                {
+                    mScrollbar[HORIZONTAL]->setDocPos(mScrollbar[HORIZONTAL]->getDocPos() - auto_scroll_speed);
+                    mAutoScrolling = TRUE;
+                }
+                scrolling = true;
+            }
+
+            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()) )
+            {
+                if (do_scroll)
+                {
+                    mScrollbar[HORIZONTAL]->setDocPos(mScrollbar[HORIZONTAL]->getDocPos() + auto_scroll_speed);
+                    mAutoScrolling = TRUE;
+                }
+                scrolling = true;
+            }
+        }
+        if( mScrollbar[VERTICAL]->getVisible() )
+        {
+            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()) )
+            {
+                if (do_scroll)
+                {
+                    mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocPos() + auto_scroll_speed);
+                    mAutoScrolling = TRUE;
+                }
+                scrolling = true;
+            }
+
+            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) )
+            {
+                if (do_scroll)
+                {
+                    mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocPos() - auto_scroll_speed);
+                    mAutoScrolling = TRUE;
+                }
+                scrolling = true;
+            }
+        }
+    }
+    return scrolling;
 }
 
 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_control ("UIScrollbarSize", 0);
-	S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
-
-	S32 doc_width = doc_rect.getWidth();
-	S32 doc_height = doc_rect.getHeight();
-
-	S32 border_width = getBorderWidth();
-	*visible_width = getRect().getWidth() - 2 * border_width;
-	*visible_height = getRect().getHeight() - 2 * border_width;
-	
-	*show_v_scrollbar = FALSE;
-	*show_h_scrollbar = FALSE;
-
-	if (!mHideScrollbar)
-	{
-		// Note: 1 pixel change can happen on final animation and should not trigger 
-		// the display of sliders.
-		if ((doc_height - *visible_height) > 1)
-		{
-			*show_v_scrollbar = TRUE;
-			*visible_width -= scrollbar_size;
-		}
-		if ((doc_width - *visible_width) > 1)
-		{
-			*show_h_scrollbar = TRUE;
-			*visible_height -= scrollbar_size;
-			// Note: Do *not* recompute *show_v_scrollbar here because with
-			// The view inside the scroll container should not be extended
-			// to container's full height to ensure the correct computation
-			// of *show_v_scrollbar after subtracting horizontal scrollbar_size.
-
-			if( !*show_v_scrollbar && ((doc_height - *visible_height) > 1) )
-			{
-				*show_v_scrollbar = TRUE;
-				*visible_width -= scrollbar_size;
-			}
-		}
-	}
+    const LLRect& doc_rect = getScrolledViewRect();
+    static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
+    S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
+
+    S32 doc_width = doc_rect.getWidth();
+    S32 doc_height = doc_rect.getHeight();
+
+    S32 border_width = getBorderWidth();
+    *visible_width = getRect().getWidth() - 2 * border_width;
+    *visible_height = getRect().getHeight() - 2 * border_width;
+
+    *show_v_scrollbar = FALSE;
+    *show_h_scrollbar = FALSE;
+
+    if (!mHideScrollbar)
+    {
+        // Note: 1 pixel change can happen on final animation and should not trigger
+        // the display of sliders.
+        if ((doc_height - *visible_height) > 1)
+        {
+            *show_v_scrollbar = TRUE;
+            *visible_width -= scrollbar_size;
+        }
+        if ((doc_width - *visible_width) > 1)
+        {
+            *show_h_scrollbar = TRUE;
+            *visible_height -= scrollbar_size;
+            // Note: Do *not* recompute *show_v_scrollbar here because with
+            // The view inside the scroll container should not be extended
+            // to container's full height to ensure the correct computation
+            // of *show_v_scrollbar after subtracting horizontal scrollbar_size.
+
+            if( !*show_v_scrollbar && ((doc_height - *visible_height) > 1) )
+            {
+                *show_v_scrollbar = TRUE;
+                *visible_width -= scrollbar_size;
+            }
+        }
+    }
 }
-	
+
 
 void LLScrollContainer::draw()
 {
-	static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
-	S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
-
-	if (mAutoScrolling)
-	{
-		// add acceleration to autoscroll
-		mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), mMaxAutoScrollRate);
-	}
-	else
-	{
-		// reset to minimum for next time
-		mAutoScrollRate = mMinAutoScrollRate;
-	}
-	// 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 (!hasFocus() 
-		&& (mScrollbar[VERTICAL]->hasMouseCapture() || mScrollbar[HORIZONTAL]->hasMouseCapture()))
-	{
-		focusFirstItem();
-	}
-
-	if (getRect().isValid()) 
-	{
-		// Draw background
-		if( mIsOpaque )
-		{
-			F32 alpha = getCurrentTransparency();
-
-			gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-			gl_rect_2d(mInnerRect, mBackgroundColor.get() % alpha);
-		}
-	
-		// Draw mScrolledViews and update scroll bars.
-		// get a scissor region ready, and draw the scrolling view. The
-		// scissor region ensures that we don't draw outside of the bounds
-		// of the rectangle.
-		if( mScrolledView )
-		{
-			updateScroll();
-
-			// Draw the scrolled area.
-			{
-				S32 visible_width = 0;
-				S32 visible_height = 0;
-				BOOL show_v_scrollbar = FALSE;
-				BOOL show_h_scrollbar = FALSE;
-				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,
-						mInnerRect.mRight - (show_v_scrollbar ? scrollbar_size: 0),
-						mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0)
-						));
-				drawChild(mScrolledView);
-			}
-		}
-
-		// Highlight border if a child of this container has keyboard focus
-		if( mBorder->getVisible() )
-		{
-			mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus(this) );
-		}
-
-		// Draw all children except mScrolledView
-		// Note: scrollbars have been adjusted by above drawing code
-		for (child_list_const_reverse_iter_t child_iter = getChildList()->rbegin();
-			 child_iter != getChildList()->rend(); ++child_iter)
-		{
-			LLView *viewp = *child_iter;
-			if( sDebugRects )
-			{
-				sDepth++;
-			}
-			if( (viewp != mScrolledView) && viewp->getVisible() )
-			{
-				drawChild(viewp);
-			}
-			if( sDebugRects )
-			{
-				sDepth--;
-			}
-		}
-	}
+    static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
+    S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
+
+    if (mAutoScrolling)
+    {
+        // add acceleration to autoscroll
+        mAutoScrollRate = llmin(mAutoScrollRate + (LLFrameTimer::getFrameDeltaTimeF32() * AUTO_SCROLL_RATE_ACCEL), mMaxAutoScrollRate);
+    }
+    else
+    {
+        // reset to minimum for next time
+        mAutoScrollRate = mMinAutoScrollRate;
+    }
+    // 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 (!hasFocus()
+        && (mScrollbar[VERTICAL]->hasMouseCapture() || mScrollbar[HORIZONTAL]->hasMouseCapture()))
+    {
+        focusFirstItem();
+    }
+
+    if (getRect().isValid())
+    {
+        // Draw background
+        if( mIsOpaque )
+        {
+            F32 alpha = getCurrentTransparency();
+
+            gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+            gl_rect_2d(mInnerRect, mBackgroundColor.get() % alpha);
+        }
+
+        // Draw mScrolledViews and update scroll bars.
+        // get a scissor region ready, and draw the scrolling view. The
+        // scissor region ensures that we don't draw outside of the bounds
+        // of the rectangle.
+        if( mScrolledView )
+        {
+            updateScroll();
+
+            // Draw the scrolled area.
+            {
+                S32 visible_width = 0;
+                S32 visible_height = 0;
+                BOOL show_v_scrollbar = FALSE;
+                BOOL show_h_scrollbar = FALSE;
+                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,
+                        mInnerRect.mRight - (show_v_scrollbar ? scrollbar_size: 0),
+                        mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0)
+                        ));
+                drawChild(mScrolledView);
+            }
+        }
+
+        // Highlight border if a child of this container has keyboard focus
+        if( mBorder->getVisible() )
+        {
+            mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus(this) );
+        }
+
+        // Draw all children except mScrolledView
+        // Note: scrollbars have been adjusted by above drawing code
+        for (child_list_const_reverse_iter_t child_iter = getChildList()->rbegin();
+             child_iter != getChildList()->rend(); ++child_iter)
+        {
+            LLView *viewp = *child_iter;
+            if( sDebugRects )
+            {
+                sDepth++;
+            }
+            if( (viewp != mScrolledView) && viewp->getVisible() )
+            {
+                drawChild(viewp);
+            }
+            if( sDebugRects )
+            {
+                sDepth--;
+            }
+        }
+    }
 } // end draw
 
 bool LLScrollContainer::addChild(LLView* view, S32 tab_group)
 {
-	if (!mScrolledView)
-	{
-		// Use the first panel or container as the scrollable view (bit of a hack)
-		mScrolledView = view;
-	}
+    if (!mScrolledView)
+    {
+        // Use the first panel or container as the scrollable view (bit of a hack)
+        mScrolledView = view;
+    }
 
-	bool ret_val = LLView::addChild(view, tab_group);
+    bool ret_val = LLView::addChild(view, tab_group);
 
-	//bring the scrollbars to the front
-	sendChildToFront( mScrollbar[HORIZONTAL] );
-	sendChildToFront( mScrollbar[VERTICAL] );
+    //bring the scrollbars to the front
+    sendChildToFront( mScrollbar[HORIZONTAL] );
+    sendChildToFront( mScrollbar[VERTICAL] );
 
-	return ret_val;
+    return ret_val;
 }
 
 void LLScrollContainer::updateScroll()
 {
-	if (!getVisible() || !mScrolledView)
-	{
-		return;
-	}
-	static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
-	S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
-
-	LLRect doc_rect = mScrolledView->getRect();
-	S32 doc_width = doc_rect.getWidth();
-	S32 doc_height = doc_rect.getHeight();
-	S32 visible_width = 0;
-	S32 visible_height = 0;
-	BOOL show_v_scrollbar = FALSE;
-	BOOL show_h_scrollbar = FALSE;
-	calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
-
-	S32 border_width = getBorderWidth();
-	if( show_v_scrollbar )
-	{
-		if( doc_rect.mTop < getRect().getHeight() - border_width )
-		{
-			mScrolledView->translate( 0, getRect().getHeight() - border_width - doc_rect.mTop );
-		}
-
-		scrollVertical(	mScrollbar[VERTICAL]->getDocPos() );
-		mScrollbar[VERTICAL]->setVisible( TRUE );
-
-		S32 v_scrollbar_height = visible_height;
-		if( !show_h_scrollbar && mReserveScrollCorner )
-		{
-			v_scrollbar_height -= scrollbar_size;
-		}
-		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;
-		}
-		LLRect r = mScrollbar[VERTICAL]->getRect();
-		r.translate( 0, mInnerRect.mBottom - r.mBottom + v_scrollbar_offset );
-		mScrollbar[VERTICAL]->setRect( r );
-	}
-	else
-	{
-		mScrolledView->translate( 0, getRect().getHeight() - border_width - doc_rect.mTop );
-
-		mScrollbar[VERTICAL]->setVisible( FALSE );
-		mScrollbar[VERTICAL]->setDocPos( 0 );
-	}
-		
-	if( show_h_scrollbar )
-	{
-		if( doc_rect.mLeft > border_width )
-		{
-			mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
-			mScrollbar[HORIZONTAL]->setDocPos( 0 );
-		}
-		else
-		{
-			scrollHorizontal( mScrollbar[HORIZONTAL]->getDocPos() );
-		}
-	
-		mScrollbar[HORIZONTAL]->setVisible( TRUE );
-		S32 h_scrollbar_width = visible_width;
-		if( !show_v_scrollbar && mReserveScrollCorner )
-		{
-			h_scrollbar_width -= scrollbar_size;
-		}
-		mScrollbar[HORIZONTAL]->reshape( h_scrollbar_width, scrollbar_size, TRUE );
-	}
-	else
-	{
-		mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
-		
-		mScrollbar[HORIZONTAL]->setVisible( FALSE );
-		mScrollbar[HORIZONTAL]->setDocPos( 0 );
-	}
-
-	mScrollbar[HORIZONTAL]->setDocSize( doc_width );
-	mScrollbar[HORIZONTAL]->setPageSize( visible_width );
-
-	mScrollbar[VERTICAL]->setDocSize( doc_height );
-	mScrollbar[VERTICAL]->setPageSize( visible_height );
+    if (!getVisible() || !mScrolledView)
+    {
+        return;
+    }
+    static LLUICachedControl<S32> scrollbar_size_control ("UIScrollbarSize", 0);
+    S32 scrollbar_size = (mSize == -1 ? scrollbar_size_control : mSize);
+
+    LLRect doc_rect = mScrolledView->getRect();
+    S32 doc_width = doc_rect.getWidth();
+    S32 doc_height = doc_rect.getHeight();
+    S32 visible_width = 0;
+    S32 visible_height = 0;
+    BOOL show_v_scrollbar = FALSE;
+    BOOL show_h_scrollbar = FALSE;
+    calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+
+    S32 border_width = getBorderWidth();
+    if( show_v_scrollbar )
+    {
+        if( doc_rect.mTop < getRect().getHeight() - border_width )
+        {
+            mScrolledView->translate( 0, getRect().getHeight() - border_width - doc_rect.mTop );
+        }
+
+        scrollVertical( mScrollbar[VERTICAL]->getDocPos() );
+        mScrollbar[VERTICAL]->setVisible( TRUE );
+
+        S32 v_scrollbar_height = visible_height;
+        if( !show_h_scrollbar && mReserveScrollCorner )
+        {
+            v_scrollbar_height -= scrollbar_size;
+        }
+        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;
+        }
+        LLRect r = mScrollbar[VERTICAL]->getRect();
+        r.translate( 0, mInnerRect.mBottom - r.mBottom + v_scrollbar_offset );
+        mScrollbar[VERTICAL]->setRect( r );
+    }
+    else
+    {
+        mScrolledView->translate( 0, getRect().getHeight() - border_width - doc_rect.mTop );
+
+        mScrollbar[VERTICAL]->setVisible( FALSE );
+        mScrollbar[VERTICAL]->setDocPos( 0 );
+    }
+
+    if( show_h_scrollbar )
+    {
+        if( doc_rect.mLeft > border_width )
+        {
+            mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
+            mScrollbar[HORIZONTAL]->setDocPos( 0 );
+        }
+        else
+        {
+            scrollHorizontal( mScrollbar[HORIZONTAL]->getDocPos() );
+        }
+
+        mScrollbar[HORIZONTAL]->setVisible( TRUE );
+        S32 h_scrollbar_width = visible_width;
+        if( !show_v_scrollbar && mReserveScrollCorner )
+        {
+            h_scrollbar_width -= scrollbar_size;
+        }
+        mScrollbar[HORIZONTAL]->reshape( h_scrollbar_width, scrollbar_size, TRUE );
+    }
+    else
+    {
+        mScrolledView->translate( border_width - doc_rect.mLeft, 0 );
+
+        mScrollbar[HORIZONTAL]->setVisible( FALSE );
+        mScrollbar[HORIZONTAL]->setDocPos( 0 );
+    }
+
+    mScrollbar[HORIZONTAL]->setDocSize( doc_width );
+    mScrollbar[HORIZONTAL]->setPageSize( visible_width );
+
+    mScrollbar[VERTICAL]->setDocSize( doc_height );
+    mScrollbar[VERTICAL]->setPageSize( visible_height );
 } // end updateScroll
 
 void LLScrollContainer::setBorderVisible(BOOL b)
 {
-	mBorder->setVisible( b );
-	// Recompute inner rect, as border visibility changes it
-	mInnerRect = getLocalRect();
-	mInnerRect.stretch( -getBorderWidth() );
+    mBorder->setVisible( b );
+    // Recompute inner rect, as border visibility changes it
+    mInnerRect = getLocalRect();
+    mInnerRect.stretch( -getBorderWidth() );
 }
 
 LLRect LLScrollContainer::getVisibleContentRect()
 {
-	updateScroll();
-	LLRect visible_rect = getContentWindowRect();
-	LLRect contents_rect = mScrolledView->getRect();
-	visible_rect.translate(-contents_rect.mLeft, -contents_rect.mBottom);
-	return visible_rect;
+    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_h_scrollbar = FALSE;
-	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;
+    updateScroll();
+    LLRect scroller_view_rect;
+    S32 visible_width = 0;
+    S32 visible_height = 0;
+    BOOL show_h_scrollbar = FALSE;
+    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)
-	{
-		LL_WARNS() << "LLScrollContainer::scrollToShowRect with no view!" << LL_ENDL;
-		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( content_window_rect.getHeight() );
-	mScrollbar[VERTICAL]->setDocPos( vert_pos );
-
-	S32 horizontal_pos = llclamp(mScrollbar[HORIZONTAL]->getDocPos(), 
-								allowable_scroll_rect.mLeft,
-								allowable_scroll_rect.mRight);
-
-	mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
-	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()));
+    if (!mScrolledView)
+    {
+        LL_WARNS() << "LLScrollContainer::scrollToShowRect with no view!" << LL_ENDL;
+        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( content_window_rect.getHeight() );
+    mScrollbar[VERTICAL]->setDocPos( vert_pos );
+
+    S32 horizontal_pos = llclamp(mScrollbar[HORIZONTAL]->getDocPos(),
+                                allowable_scroll_rect.mLeft,
+                                allowable_scroll_rect.mRight);
+
+    mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
+    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 LLScrollContainer::pageUp(S32 overlap)
 {
-	mScrollbar[VERTICAL]->pageUp(overlap);
-	updateScroll();
+    mScrollbar[VERTICAL]->pageUp(overlap);
+    updateScroll();
 }
 
 void LLScrollContainer::pageDown(S32 overlap)
 {
-	mScrollbar[VERTICAL]->pageDown(overlap);
-	updateScroll();
+    mScrollbar[VERTICAL]->pageDown(overlap);
+    updateScroll();
 }
 
 void LLScrollContainer::goToTop()
 {
-	mScrollbar[VERTICAL]->setDocPos(0);
-	updateScroll();
+    mScrollbar[VERTICAL]->setDocPos(0);
+    updateScroll();
 }
 
 void LLScrollContainer::goToBottom()
 {
-	mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocSize());
-	updateScroll();
+    mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocSize());
+    updateScroll();
 }
 
 S32 LLScrollContainer::getBorderWidth() const
 {
-	if (mBorder->getVisible())
-	{
-		return mBorder->getBorderWidth();
-	}
+    if (mBorder->getVisible())
+    {
+        return mBorder->getBorderWidth();
+    }
 
-	return 0;
+    return 0;
 }
 
 void LLScrollContainer::setSize(S32 size)
 {
-	mSize = size;
-	mScrollbar[VERTICAL]->setThickness(size);
-	mScrollbar[HORIZONTAL]->setThickness(size);
+    mSize = size;
+    mScrollbar[VERTICAL]->setThickness(size);
+    mScrollbar[HORIZONTAL]->setThickness(size);
 }