blob: 628dc1ce2d0a8c7a302813e450636408017f97dd [file] [log] [blame]
/*
* Copyright (C) 2004, 2006, 2008, 2015 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "Scrollbar.h"
#include "FrameView.h"
#include "GraphicsContext.h"
#include "PlatformMouseEvent.h"
#include "ScrollAnimator.h"
#include "ScrollView.h"
#include "ScrollableArea.h"
#include "ScrollbarTheme.h"
#include "ScrollbarsController.h"
#include <algorithm>
#if PLATFORM(GTK)
// The position of the scrollbar thumb affects the appearance of the steppers, so
// when the thumb moves, we have to invalidate them for painting.
#define THUMB_POSITION_AFFECTS_BUTTONS
#endif
namespace WebCore {
Ref<Scrollbar> Scrollbar::createNativeScrollbar(ScrollableArea& scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize size)
{
return adoptRef(*new Scrollbar(scrollableArea, orientation, size));
}
int Scrollbar::maxOverlapBetweenPages()
{
static int maxOverlapBetweenPages = ScrollbarTheme::theme().maxOverlapBetweenPages();
return maxOverlapBetweenPages;
}
Scrollbar::Scrollbar(ScrollableArea& scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize controlSize, ScrollbarTheme* customTheme, bool isCustomScrollbar)
: m_scrollableArea(scrollableArea)
, m_orientation(orientation)
, m_controlSize(controlSize)
, m_theme(customTheme ? *customTheme : ScrollbarTheme::theme())
, m_isCustomScrollbar(isCustomScrollbar)
, m_scrollTimer(*this, &Scrollbar::autoscrollTimerFired)
{
theme().registerScrollbar(*this);
// FIXME: This is ugly and would not be necessary if we fix cross-platform code to actually query for
// scrollbar thickness and use it when sizing scrollbars (rather than leaving one dimension of the scrollbar
// alone when sizing).
int thickness = theme().scrollbarThickness(controlSize);
Widget::setFrameRect(IntRect(0, 0, thickness, thickness));
m_currentPos = static_cast<float>(offsetForOrientation(m_scrollableArea.scrollOffset(), m_orientation));
}
Scrollbar::~Scrollbar()
{
stopTimerIfNeeded();
theme().unregisterScrollbar(*this);
}
int Scrollbar::occupiedWidth() const
{
return isOverlayScrollbar() ? 0 : width();
}
int Scrollbar::occupiedHeight() const
{
return isOverlayScrollbar() ? 0 : height();
}
void Scrollbar::offsetDidChange()
{
float position = static_cast<float>(offsetForOrientation(m_scrollableArea.scrollOffset(), m_orientation));
if (position == m_currentPos)
return;
int oldThumbPosition = theme().thumbPosition(*this);
m_currentPos = position;
updateThumbPosition();
if (m_pressedPart == ThumbPart)
setPressedPos(m_pressedPos + theme().thumbPosition(*this) - oldThumbPosition);
}
void Scrollbar::setProportion(int visibleSize, int totalSize)
{
if (visibleSize == m_visibleSize && totalSize == m_totalSize)
return;
m_visibleSize = visibleSize;
m_totalSize = totalSize;
updateThumbProportion();
}
void Scrollbar::setSteps(int lineStep, int pageStep, int pixelsPerStep)
{
m_lineStep = lineStep;
m_pageStep = pageStep;
m_pixelStep = 1.0f / pixelsPerStep;
}
void Scrollbar::updateThumb()
{
#ifdef THUMB_POSITION_AFFECTS_BUTTONS
invalidate();
#else
theme().invalidateParts(*this, ForwardTrackPart | BackTrackPart | ThumbPart);
#endif
}
void Scrollbar::updateThumbPosition()
{
updateThumb();
}
void Scrollbar::updateThumbProportion()
{
updateThumb();
}
void Scrollbar::paint(GraphicsContext& context, const IntRect& damageRect, Widget::SecurityOriginPaintPolicy, EventRegionContext*)
{
if (context.invalidatingControlTints() && theme().supportsControlTints()) {
invalidate();
return;
}
if (context.paintingDisabled() || !frameRect().intersects(damageRect))
return;
if (!theme().paint(*this, context, damageRect))
Widget::paint(context, damageRect);
}
void Scrollbar::autoscrollTimerFired()
{
autoscrollPressedPart(theme().autoscrollTimerDelay());
}
static bool thumbUnderMouse(Scrollbar* scrollbar)
{
int thumbPos = scrollbar->theme().trackPosition(*scrollbar) + scrollbar->theme().thumbPosition(*scrollbar);
int thumbLength = scrollbar->theme().thumbLength(*scrollbar);
return scrollbar->pressedPos() >= thumbPos && scrollbar->pressedPos() < thumbPos + thumbLength;
}
void Scrollbar::autoscrollPressedPart(Seconds delay)
{
// Don't do anything for the thumb or if nothing was pressed.
if (m_pressedPart == ThumbPart || m_pressedPart == NoPart)
return;
// Handle the track.
if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
theme().invalidatePart(*this, m_pressedPart);
setHoveredPart(ThumbPart);
return;
}
// Handle the arrows and track.
if (m_scrollableArea.scroll(pressedPartScrollDirection(), pressedPartScrollGranularity()))
startTimerIfNeeded(delay);
}
void Scrollbar::startTimerIfNeeded(Seconds delay)
{
// Don't do anything for the thumb.
if (m_pressedPart == ThumbPart)
return;
// Handle the track. We halt track scrolling once the thumb is level
// with us.
if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
theme().invalidatePart(*this, m_pressedPart);
setHoveredPart(ThumbPart);
return;
}
// We can't scroll if we've hit the beginning or end.
ScrollDirection dir = pressedPartScrollDirection();
if (dir == ScrollUp || dir == ScrollLeft) {
if (m_currentPos == 0)
return;
} else {
if (m_currentPos == maximum())
return;
}
m_scrollTimer.startOneShot(delay);
}
void Scrollbar::stopTimerIfNeeded()
{
if (m_scrollTimer.isActive())
m_scrollTimer.stop();
}
ScrollDirection Scrollbar::pressedPartScrollDirection()
{
if (m_orientation == ScrollbarOrientation::Horizontal) {
if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart || m_pressedPart == BackTrackPart)
return ScrollLeft;
return ScrollRight;
} else {
if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart || m_pressedPart == BackTrackPart)
return ScrollUp;
return ScrollDown;
}
}
ScrollGranularity Scrollbar::pressedPartScrollGranularity()
{
if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart || m_pressedPart == ForwardButtonStartPart || m_pressedPart == ForwardButtonEndPart)
return ScrollGranularity::Line;
return ScrollGranularity::Page;
}
void Scrollbar::moveThumb(int pos, bool draggingDocument)
{
int delta = pos - m_pressedPos;
if (draggingDocument) {
if (m_draggingDocument)
delta = pos - m_documentDragPos;
m_draggingDocument = true;
FloatPoint currentPosition = m_scrollableArea.scrollAnimator().currentPosition();
int destinationPosition = (m_orientation == ScrollbarOrientation::Horizontal ? currentPosition.x() : currentPosition.y()) + delta;
if (delta > 0)
destinationPosition = std::min(destinationPosition + delta, maximum());
else if (delta < 0)
destinationPosition = std::max(destinationPosition + delta, 0);
m_scrollableArea.scrollToOffsetWithoutAnimation(m_orientation, destinationPosition);
m_documentDragPos = pos;
return;
}
if (m_draggingDocument) {
delta += m_pressedPos - m_documentDragPos;
m_draggingDocument = false;
}
// Drag the thumb.
int thumbPos = theme().thumbPosition(*this);
int thumbLen = theme().thumbLength(*this);
int trackLen = theme().trackLength(*this);
int maxPos = trackLen - thumbLen;
if (delta > 0)
delta = std::min(maxPos - thumbPos, delta);
else if (delta < 0)
delta = std::max(-thumbPos, delta);
if (delta) {
float newPosition = static_cast<float>(thumbPos + delta) * maximum() / (trackLen - thumbLen);
m_scrollableArea.scrollToOffsetWithoutAnimation(m_orientation, newPosition);
}
}
void Scrollbar::setHoveredPart(ScrollbarPart part)
{
if (part == m_hoveredPart)
return;
if ((m_hoveredPart == NoPart || part == NoPart) && theme().invalidateOnMouseEnterExit())
invalidate(); // Just invalidate the whole scrollbar, since the buttons at either end change anyway.
else if (m_pressedPart == NoPart) { // When there's a pressed part, we don't draw a hovered state, so there's no reason to invalidate.
theme().invalidatePart(*this, part);
theme().invalidatePart(*this, m_hoveredPart);
}
m_hoveredPart = part;
}
void Scrollbar::setPressedPart(ScrollbarPart part)
{
if (m_pressedPart != NoPart)
theme().invalidatePart(*this, m_pressedPart);
m_pressedPart = part;
if (m_pressedPart != NoPart)
theme().invalidatePart(*this, m_pressedPart);
else if (m_hoveredPart != NoPart) // When we no longer have a pressed part, we can start drawing a hovered state on the hovered part.
theme().invalidatePart(*this, m_hoveredPart);
}
#if !PLATFORM(IOS_FAMILY)
bool Scrollbar::mouseMoved(const PlatformMouseEvent& evt)
{
if (m_pressedPart == ThumbPart) {
if (theme().shouldSnapBackToDragOrigin(*this, evt))
m_scrollableArea.scrollToOffsetWithoutAnimation(m_orientation, m_dragOrigin);
else {
moveThumb(m_orientation == ScrollbarOrientation::Horizontal ?
convertFromContainingWindow(evt.position()).x() :
convertFromContainingWindow(evt.position()).y(), theme().shouldDragDocumentInsteadOfThumb(*this, evt));
}
return true;
}
if (m_pressedPart != NoPart)
m_pressedPos = (orientation() == ScrollbarOrientation::Horizontal ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y());
ScrollbarPart part = theme().hitTest(*this, evt.position());
if (part != m_hoveredPart) {
if (m_pressedPart != NoPart) {
if (part == m_pressedPart) {
// The mouse is moving back over the pressed part. We
// need to start up the timer action again.
startTimerIfNeeded(theme().autoscrollTimerDelay());
theme().invalidatePart(*this, m_pressedPart);
} else if (m_hoveredPart == m_pressedPart) {
// The mouse is leaving the pressed part. Kill our timer
// if needed.
stopTimerIfNeeded();
theme().invalidatePart(*this, m_pressedPart);
}
}
setHoveredPart(part);
}
return true;
}
#endif
void Scrollbar::mouseEntered()
{
m_scrollableArea.mouseEnteredScrollbar(this);
}
bool Scrollbar::mouseExited()
{
m_scrollableArea.mouseExitedScrollbar(this);
setHoveredPart(NoPart);
return true;
}
bool Scrollbar::mouseUp(const PlatformMouseEvent& mouseEvent)
{
auto previouslyPressedPart = m_pressedPart;
setPressedPart(NoPart);
m_pressedPos = 0;
m_draggingDocument = false;
stopTimerIfNeeded();
m_scrollableArea.mouseIsDownInScrollbar(this, false);
// m_hoveredPart won't be updated until the next mouseMoved or mouseDown, so we have to hit test
// to really know if the mouse has exited the scrollbar on a mouseUp.
ScrollbarPart part = theme().hitTest(*this, mouseEvent.position());
if (part == NoPart)
m_scrollableArea.mouseExitedScrollbar(this);
if (previouslyPressedPart == ThumbPart)
m_scrollableArea.doPostThumbMoveSnapping(m_orientation);
return true;
}
bool Scrollbar::mouseDown(const PlatformMouseEvent& evt)
{
ScrollbarPart pressedPart = theme().hitTest(*this, evt.position());
auto action = theme().handleMousePressEvent(*this, evt, pressedPart);
if (action == ScrollbarButtonPressAction::None)
return true;
m_scrollableArea.mouseIsDownInScrollbar(this, true);
setPressedPart(pressedPart);
int pressedPosition = (orientation() == ScrollbarOrientation::Horizontal ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y());
if (action == ScrollbarButtonPressAction::CenterOnThumb) {
setHoveredPart(ThumbPart);
setPressedPart(ThumbPart);
m_dragOrigin = m_currentPos;
// Set the pressed position to the middle of the thumb so that when we do the move, the delta
// will be from the current pixel position of the thumb to the new desired position for the thumb.
m_pressedPos = theme().trackPosition(*this) + theme().thumbPosition(*this) + theme().thumbLength(*this) / 2;
moveThumb(pressedPosition);
return true;
}
m_pressedPos = pressedPosition;
if (action == ScrollbarButtonPressAction::StartDrag)
m_dragOrigin = m_currentPos;
if (action == ScrollbarButtonPressAction::Scroll)
autoscrollPressedPart(theme().initialAutoscrollTimerDelay());
return true;
}
void Scrollbar::setEnabled(bool e)
{
if (m_enabled == e)
return;
m_enabled = e;
theme().updateEnabledState(*this);
invalidate();
}
bool Scrollbar::isOverlayScrollbar() const
{
return theme().usesOverlayScrollbars();
}
bool Scrollbar::shouldParticipateInHitTesting()
{
// Non-overlay scrollbars should always participate in hit testing.
if (!isOverlayScrollbar())
return true;
return m_scrollableArea.scrollbarsController().shouldScrollbarParticipateInHitTesting(this);
}
bool Scrollbar::isWindowActive() const
{
return m_scrollableArea.isActive();
}
void Scrollbar::invalidateRect(const IntRect& rect)
{
if (suppressInvalidation())
return;
m_scrollableArea.invalidateScrollbar(*this, rect);
}
IntRect Scrollbar::convertToContainingView(const IntRect& localRect) const
{
return m_scrollableArea.convertFromScrollbarToContainingView(*this, localRect);
}
IntRect Scrollbar::convertFromContainingView(const IntRect& parentRect) const
{
return m_scrollableArea.convertFromContainingViewToScrollbar(*this, parentRect);
}
IntPoint Scrollbar::convertToContainingView(const IntPoint& localPoint) const
{
return m_scrollableArea.convertFromScrollbarToContainingView(*this, localPoint);
}
IntPoint Scrollbar::convertFromContainingView(const IntPoint& parentPoint) const
{
return m_scrollableArea.convertFromContainingViewToScrollbar(*this, parentPoint);
}
bool Scrollbar::supportsUpdateOnSecondaryThread() const
{
// It's unfortunate that this needs to be done with an ifdef. Ideally there would be a way to feature-detect
// the necessary support within AppKit.
#if ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC)
return !m_scrollableArea.forceUpdateScrollbarsOnMainThreadForPerformanceTesting()
&& (m_scrollableArea.hasLayerForVerticalScrollbar() || m_scrollableArea.hasLayerForHorizontalScrollbar())
&& m_scrollableArea.usesAsyncScrolling();
#else
return false;
#endif
}
} // namespace WebCore