From c285f59ce2a05703e3a1232fcaf3ee3aea714b3f Mon Sep 17 00:00:00 2001 From: Ansariel Date: Sun, 18 Feb 2024 12:52:19 +0100 Subject: Replace BOOL with bool in llwindow and dependent classes --- indra/llui/llscrollcontainer.cpp | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) (limited to 'indra/llui/llscrollcontainer.cpp') diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp index ad32f7186c..48b55a1d87 100644 --- a/indra/llui/llscrollcontainer.cpp +++ b/indra/llui/llscrollcontainer.cpp @@ -227,21 +227,21 @@ BOOL LLScrollContainer::handleKeyHere(KEY key, MASK mask) return FALSE; } -BOOL LLScrollContainer::handleUnicodeCharHere(llwchar uni_char) +bool LLScrollContainer::handleUnicodeCharHere(llwchar uni_char) { if (mScrolledView && mScrolledView->handleUnicodeCharHere(uni_char)) { - return TRUE; + return true; } - return FALSE; + return false; } -BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks ) +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; + return true; // When the vertical scrollbar is visible, scroll wheel // only affects vertical scrolling. It's confusing to have @@ -257,7 +257,7 @@ BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks ) updateScroll(); } // Always eat the event - return TRUE; + return true; } LLScrollbar* horizontal = mScrollbar[HORIZONTAL]; @@ -268,16 +268,16 @@ BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks ) && horizontal->handleScrollWheel( 0, 0, clicks ) ) { updateScroll(); - return TRUE; + return true; } - return FALSE; + return false; } -BOOL LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks) +bool LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks) { if (LLUICtrl::handleScrollHWheel(x,y,clicks)) { - return TRUE; + return true; } LLScrollbar* horizontal = mScrollbar[HORIZONTAL]; @@ -286,10 +286,10 @@ BOOL LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks) && horizontal->handleScrollHWheel( 0, 0, clicks ) ) { updateScroll(); - return TRUE; + return true; } - return FALSE; + return false; } BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask, -- cgit v1.2.3 From a5261a5fa8fad810ecb5c260d92c3e771822bf58 Mon Sep 17 00:00:00 2001 From: Ansariel Date: Tue, 20 Feb 2024 23:46:23 +0100 Subject: Convert BOOL to bool in llui --- indra/llui/llscrollcontainer.cpp | 72 ++++++++++++++++++++-------------------- 1 file changed, 36 insertions(+), 36 deletions(-) (limited to 'indra/llui/llscrollcontainer.cpp') diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp index 48b55a1d87..09e8fd1f84 100644 --- a/indra/llui/llscrollcontainer.cpp +++ b/indra/llui/llscrollcontainer.cpp @@ -81,7 +81,7 @@ LLScrollContainer::Params::Params() // Default constructor LLScrollContainer::LLScrollContainer(const LLScrollContainer::Params& p) : LLUICtrl(p), - mAutoScrolling( FALSE ), + mAutoScrolling( false ), mAutoScrollRate( 0.f ), mBackgroundColor(p.bg_color()), mIsOpaque(p.is_opaque), @@ -178,7 +178,7 @@ void LLScrollContainer::scrollVertical( S32 new_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 ); @@ -191,8 +191,8 @@ void LLScrollContainer::reshape(S32 width, S32 height, S32 visible_width = 0; S32 visible_height = 0; - BOOL show_v_scrollbar = FALSE; - BOOL show_h_scrollbar = FALSE; + 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() ); @@ -204,7 +204,7 @@ void LLScrollContainer::reshape(S32 width, S32 height, } } -BOOL LLScrollContainer::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. @@ -213,18 +213,18 @@ BOOL LLScrollContainer::handleKeyHere(KEY key, MASK mask) // call LLScrollContainer::handleKeyHere in turn if (mScrolledView && mScrolledView->handleKeyHere(key, mask)) { - return TRUE; + return true; } for( S32 i = 0; i < ORIENTATION_COUNT; i++ ) { if( mScrollbar[i]->handleKeyHere(key, mask) ) { updateScroll(); - return TRUE; + return true; } } - return FALSE; + return false; } bool LLScrollContainer::handleUnicodeCharHere(llwchar uni_char) @@ -292,8 +292,8 @@ bool LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks) return false; } -BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask, - BOOL drop, +bool LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask, + bool drop, EDragAndDropType cargo_type, void* cargo_data, EAcceptance* accept, @@ -301,7 +301,7 @@ BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask, { // Scroll folder view if needed. Never accepts a drag or drop. *accept = ACCEPT_NO; - BOOL handled = autoScroll(x, y); + bool handled = autoScroll(x, y); if( !handled ) { @@ -309,7 +309,7 @@ BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask, cargo_data, accept, tooltip_msg) != NULL; } - return TRUE; + return true; } bool LLScrollContainer::canAutoScroll(S32 x, S32 y) @@ -366,7 +366,7 @@ bool LLScrollContainer::autoScroll(S32 x, S32 y, bool do_scroll) if (do_scroll) { mScrollbar[HORIZONTAL]->setDocPos(mScrollbar[HORIZONTAL]->getDocPos() - auto_scroll_speed); - mAutoScrolling = TRUE; + mAutoScrolling = true; } scrolling = true; } @@ -378,7 +378,7 @@ bool LLScrollContainer::autoScroll(S32 x, S32 y, bool do_scroll) if (do_scroll) { mScrollbar[HORIZONTAL]->setDocPos(mScrollbar[HORIZONTAL]->getDocPos() + auto_scroll_speed); - mAutoScrolling = TRUE; + mAutoScrolling = true; } scrolling = true; } @@ -392,7 +392,7 @@ bool LLScrollContainer::autoScroll(S32 x, S32 y, bool do_scroll) if (do_scroll) { mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocPos() + auto_scroll_speed); - mAutoScrolling = TRUE; + mAutoScrolling = true; } scrolling = true; } @@ -404,7 +404,7 @@ bool LLScrollContainer::autoScroll(S32 x, S32 y, bool do_scroll) if (do_scroll) { mScrollbar[VERTICAL]->setDocPos(mScrollbar[VERTICAL]->getDocPos() - auto_scroll_speed); - mAutoScrolling = TRUE; + mAutoScrolling = true; } scrolling = true; } @@ -413,7 +413,7 @@ bool LLScrollContainer::autoScroll(S32 x, S32 y, bool do_scroll) return scrolling; } -void LLScrollContainer::calcVisibleSize( 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 scrollbar_size_control ("UIScrollbarSize", 0); @@ -426,8 +426,8 @@ void LLScrollContainer::calcVisibleSize( S32 *visible_width, S32 *visible_height *visible_width = getRect().getWidth() - 2 * border_width; *visible_height = getRect().getHeight() - 2 * border_width; - *show_v_scrollbar = FALSE; - *show_h_scrollbar = FALSE; + *show_v_scrollbar = false; + *show_h_scrollbar = false; if (!mHideScrollbar) { @@ -435,12 +435,12 @@ void LLScrollContainer::calcVisibleSize( S32 *visible_width, S32 *visible_height // the display of sliders. if ((doc_height - *visible_height) > 1) { - *show_v_scrollbar = TRUE; + *show_v_scrollbar = true; *visible_width -= scrollbar_size; } if ((doc_width - *visible_width) > 1) { - *show_h_scrollbar = TRUE; + *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 @@ -449,7 +449,7 @@ void LLScrollContainer::calcVisibleSize( S32 *visible_width, S32 *visible_height if( !*show_v_scrollbar && ((doc_height - *visible_height) > 1) ) { - *show_v_scrollbar = TRUE; + *show_v_scrollbar = true; *visible_width -= scrollbar_size; } } @@ -473,7 +473,7 @@ void LLScrollContainer::draw() mAutoScrollRate = mMinAutoScrollRate; } // clear this flag to be set on next call to autoScroll - mAutoScrolling = FALSE; + mAutoScrolling = false; // auto-focus when scrollbar active // this allows us to capture user intent (i.e. stop automatically scrolling the view/etc) @@ -506,8 +506,8 @@ void LLScrollContainer::draw() { S32 visible_width = 0; S32 visible_height = 0; - BOOL show_v_scrollbar = FALSE; - BOOL show_h_scrollbar = FALSE; + 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, @@ -578,8 +578,8 @@ void LLScrollContainer::updateScroll() S32 doc_height = doc_rect.getHeight(); S32 visible_width = 0; S32 visible_height = 0; - BOOL show_v_scrollbar = FALSE; - BOOL show_h_scrollbar = FALSE; + 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(); @@ -591,14 +591,14 @@ void LLScrollContainer::updateScroll() } scrollVertical( mScrollbar[VERTICAL]->getDocPos() ); - mScrollbar[VERTICAL]->setVisible( TRUE ); + 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 ); + mScrollbar[VERTICAL]->reshape( scrollbar_size, v_scrollbar_height, true ); // Make room for the horizontal scrollbar (or not) S32 v_scrollbar_offset = 0; @@ -614,7 +614,7 @@ void LLScrollContainer::updateScroll() { mScrolledView->translate( 0, getRect().getHeight() - border_width - doc_rect.mTop ); - mScrollbar[VERTICAL]->setVisible( FALSE ); + mScrollbar[VERTICAL]->setVisible( false ); mScrollbar[VERTICAL]->setDocPos( 0 ); } @@ -630,19 +630,19 @@ void LLScrollContainer::updateScroll() scrollHorizontal( mScrollbar[HORIZONTAL]->getDocPos() ); } - mScrollbar[HORIZONTAL]->setVisible( TRUE ); + 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 ); + mScrollbar[HORIZONTAL]->reshape( h_scrollbar_width, scrollbar_size, true ); } else { mScrolledView->translate( border_width - doc_rect.mLeft, 0 ); - mScrollbar[HORIZONTAL]->setVisible( FALSE ); + mScrollbar[HORIZONTAL]->setVisible( false ); mScrollbar[HORIZONTAL]->setDocPos( 0 ); } @@ -653,7 +653,7 @@ void LLScrollContainer::updateScroll() mScrollbar[VERTICAL]->setPageSize( visible_height ); } // end updateScroll -void LLScrollContainer::setBorderVisible(BOOL b) +void LLScrollContainer::setBorderVisible(bool b) { mBorder->setVisible( b ); // Recompute inner rect, as border visibility changes it @@ -676,8 +676,8 @@ LLRect LLScrollContainer::getContentWindowRect() LLRect scroller_view_rect; S32 visible_width = 0; S32 visible_height = 0; - BOOL show_h_scrollbar = FALSE; - BOOL show_v_scrollbar = FALSE; + 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, -- cgit v1.2.3 From e2e37cced861b98de8c1a7c9c0d3a50d2d90e433 Mon Sep 17 00:00:00 2001 From: Ansariel Date: Wed, 22 May 2024 21:25:21 +0200 Subject: Fix line endlings --- indra/llui/llscrollcontainer.cpp | 1604 +++++++++++++++++++------------------- 1 file changed, 802 insertions(+), 802 deletions(-) (limited to 'indra/llui/llscrollcontainer.cpp') diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp index 1e99d408cc..df99c4f636 100644 --- a/indra/llui/llscrollcontainer.cpp +++ b/indra/llui/llscrollcontainer.cpp @@ -1,802 +1,802 @@ -/** - * @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 r("scroll_container"); - -#include "llscrollingpanellist.h" -#include "llcontainerview.h" -#include "llpanel.h" - -static ScrollContainerRegistry::Register r1("scrolling_panel_list"); -static ScrollContainerRegistry::Register r2("container_view"); -static ScrollContainerRegistry::Register 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 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 (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 (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 (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 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 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 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 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); -} +/** + * @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 r("scroll_container"); + +#include "llscrollingpanellist.h" +#include "llcontainerview.h" +#include "llpanel.h" + +static ScrollContainerRegistry::Register r1("scrolling_panel_list"); +static ScrollContainerRegistry::Register r2("container_view"); +static ScrollContainerRegistry::Register 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 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 (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 (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 (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 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 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 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 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); +} -- cgit v1.2.3