path: root/indra/llui/llscrollcontainer.cpp

/**
 * @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$
 */


#include "linden_common.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"
#include "llviewborder.h"
#include "llfocusmgr.h"
#include "llframetimer.h"
#include "lluictrlfactory.h"
#include "llpanel.h"
#include "llfontgl.h"

///----------------------------------------------------------------------------
/// Local function declarations, constants, enums, and typedefs
///----------------------------------------------------------------------------

static const S32 VERTICAL_MULTIPLE = 16;
static const F32 AUTO_SCROLL_RATE_ACCEL = 120.f;

///----------------------------------------------------------------------------
/// Class LLScrollContainer
///----------------------------------------------------------------------------

static LLDefaultChildRegistry::Register<LLScrollContainer> r("scroll_container");

#include "llscrollingpanellist.h"
#include "llcontainerview.h"
#include "llpanel.h"

static ScrollContainerRegistry::Register<LLScrollingPanelList> r1("scrolling_panel_list");
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)
{}


// 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)
{
    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;
}

// 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 );
    }
}

// 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 );
    }
}

// LLView functionality
void LLScrollContainer::reshape(S32 width, S32 height,
                                        BOOL called_from_parent)
{
    LLUICtrl::reshape( width, height, called_from_parent );

    mInnerRect = getLocalRect();
    mInnerRect.stretch( -getBorderWidth() );

    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 );

        mScrollbar[VERTICAL]->setDocSize( scrolled_rect.getHeight() );
        mScrollbar[VERTICAL]->setPageSize( visible_height );

        mScrollbar[HORIZONTAL]->setDocSize( scrolled_rect.getWidth() );
        mScrollbar[HORIZONTAL]->setPageSize( visible_width );
        updateScroll();
    }
}

// virtual
BOOL LLScrollContainer::handleKeyHere(KEY key, MASK mask)
{
    if (mIgnoreArrowKeys)
    {
        switch(key)
        {
        case KEY_LEFT:
        case KEY_RIGHT:
        case KEY_UP:
        case KEY_DOWN:
        case KEY_PAGE_UP:
        case KEY_PAGE_DOWN:
        case KEY_HOME:
        case KEY_END:
            return FALSE;
        default:
            break;
        }
    }

    // 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;
}

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;
}

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;
}

BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask,
                                                  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);

    if( !handled )
    {
        handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
                                            cargo_data, accept, tooltip_msg) != NULL;
    }

    return TRUE;
}

bool LLScrollContainer::canAutoScroll(S32 x, S32 y)
{
    if (mAutoScrolling)
    {
        return true; // already scrolling
    }
    return autoScroll(x, y, false);
}

bool LLScrollContainer::autoScroll(S32 x, S32 y)
{
    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;
}

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;
            }
        }
    }
}


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--;
            }
        }
    }
} // 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;
    }

    bool ret_val = LLView::addChild(view, tab_group);

    //bring the scrollbars to the front
    sendChildToFront( mScrollbar[HORIZONTAL] );
    sendChildToFront( mScrollbar[VERTICAL] );

    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 );
} // end updateScroll

void LLScrollContainer::setBorderVisible(BOOL b)
{
    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;
}

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;
}

// 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()));
}

void LLScrollContainer::pageUp(S32 overlap)
{
    mScrollbar[VERTICAL]->pageUp(overlap);
    updateScroll();
}

void LLScrollContainer::pageDown(S32 overlap)
{
    mScrollbar[VERTICAL]->pageDown(overlap);
    updateScroll();
}

void LLScrollContainer::goToTop()
{
    mScrollbar[VERTICAL]->setDocPos(0);
    updateScroll();
}

void LLScrollContainer::goToBottom()
{
    mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocSize());
    updateScroll();
}

S32 LLScrollContainer::getBorderWidth() const
{
    if (mBorder->getVisible())
    {
        return mBorder->getBorderWidth();
    }

    return 0;
}

void LLScrollContainer::setSize(S32 size)
{
    mSize = size;
    mScrollbar[VERTICAL]->setThickness(size);
    mScrollbar[HORIZONTAL]->setThickness(size);
}