ScrollableArea.cpp [plain text]
#include "config.h"
#include "ScrollableArea.h"
#include "GraphicsContext.h"
#include "GraphicsLayer.h"
#include "FloatPoint.h"
#include "PlatformWheelEvent.h"
#include "ScrollAnimator.h"
#include "ScrollbarTheme.h"
#include <wtf/PassOwnPtr.h>
namespace WebCore {
struct SameSizeAsScrollableArea {
virtual ~SameSizeAsScrollableArea();
void* pointer;
unsigned bitfields : 16;
IntPoint origin;
};
COMPILE_ASSERT(sizeof(ScrollableArea) == sizeof(SameSizeAsScrollableArea), ScrollableArea_should_stay_small);
ScrollableArea::ScrollableArea()
: m_constrainsScrollingToContentEdge(true)
, m_inLiveResize(false)
, m_verticalScrollElasticity(ScrollElasticityNone)
, m_horizontalScrollElasticity(ScrollElasticityNone)
, m_scrollbarOverlayStyle(ScrollbarOverlayStyleDefault)
, m_scrollOriginChanged(false)
{
}
ScrollableArea::~ScrollableArea()
{
}
ScrollAnimator* ScrollableArea::scrollAnimator() const
{
if (!m_scrollAnimator)
m_scrollAnimator = ScrollAnimator::create(const_cast<ScrollableArea*>(this));
return m_scrollAnimator.get();
}
void ScrollableArea::setScrollOrigin(const IntPoint& origin)
{
if (m_scrollOrigin != origin) {
m_scrollOrigin = origin;
m_scrollOriginChanged = true;
}
}
bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
{
ScrollbarOrientation orientation;
Scrollbar* scrollbar;
if (direction == ScrollUp || direction == ScrollDown) {
orientation = VerticalScrollbar;
scrollbar = verticalScrollbar();
} else {
orientation = HorizontalScrollbar;
scrollbar = horizontalScrollbar();
}
if (!scrollbar)
return false;
float step = 0;
switch (granularity) {
case ScrollByLine:
step = scrollbar->lineStep();
break;
case ScrollByPage:
step = scrollbar->pageStep();
break;
case ScrollByDocument:
step = scrollbar->totalSize();
break;
case ScrollByPixel:
case ScrollByPrecisePixel:
step = scrollbar->pixelStep();
break;
}
if (direction == ScrollUp || direction == ScrollLeft)
multiplier = -multiplier;
return scrollAnimator()->scroll(orientation, granularity, step, multiplier);
}
void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
{
scrollAnimator()->scrollToOffsetWithoutAnimation(offset);
}
void ScrollableArea::scrollToOffsetWithoutAnimation(ScrollbarOrientation orientation, float offset)
{
if (orientation == HorizontalScrollbar)
scrollToOffsetWithoutAnimation(FloatPoint(offset, scrollAnimator()->currentPosition().y()));
else
scrollToOffsetWithoutAnimation(FloatPoint(scrollAnimator()->currentPosition().x(), offset));
}
void ScrollableArea::notifyScrollPositionChanged(const IntPoint& position)
{
scrollPositionChanged(position);
scrollAnimator()->setCurrentPosition(position);
}
void ScrollableArea::scrollPositionChanged(const IntPoint& position)
{
IntPoint oldPosition = scrollPosition();
setScrollOffset(position);
Scrollbar* verticalScrollbar = this->verticalScrollbar();
if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
horizontalScrollbar->offsetDidChange();
if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar()) {
if (!verticalScrollbar)
horizontalScrollbar->invalidate();
else {
IntRect boundsAndCorner = horizontalScrollbar->boundsRect();
boundsAndCorner.setWidth(boundsAndCorner.width() + verticalScrollbar->width());
horizontalScrollbar->invalidateRect(boundsAndCorner);
}
}
}
if (verticalScrollbar) {
verticalScrollbar->offsetDidChange();
if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar())
verticalScrollbar->invalidate();
}
if (scrollPosition() != oldPosition)
scrollAnimator()->notifyContentAreaScrolled(scrollPosition() - oldPosition);
}
bool ScrollableArea::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
{
return scrollAnimator()->handleWheelEvent(wheelEvent);
}
#if ENABLE(TOUCH_EVENTS) && PLATFORM(IOS)
bool ScrollableArea::handleTouchEvent(const PlatformTouchEvent& touchEvent)
{
return scrollAnimator()->handleTouchEvent(touchEvent);
}
#endif
void ScrollableArea::setScrollOffsetFromInternals(const IntPoint& offset)
{
setScrollOffsetFromAnimation(offset);
}
void ScrollableArea::setScrollOffsetFromAnimation(const IntPoint& offset)
{
if (requestScrollPositionUpdate(offset))
return;
scrollPositionChanged(offset);
}
void ScrollableArea::willStartLiveResize()
{
if (m_inLiveResize)
return;
m_inLiveResize = true;
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->willStartLiveResize();
}
void ScrollableArea::willEndLiveResize()
{
if (!m_inLiveResize)
return;
m_inLiveResize = false;
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->willEndLiveResize();
}
void ScrollableArea::contentAreaWillPaint() const
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->contentAreaWillPaint();
}
void ScrollableArea::mouseEnteredContentArea() const
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->mouseEnteredContentArea();
}
void ScrollableArea::mouseExitedContentArea() const
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->mouseEnteredContentArea();
}
void ScrollableArea::mouseMovedInContentArea() const
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->mouseMovedInContentArea();
}
void ScrollableArea::mouseEnteredScrollbar(Scrollbar* scrollbar) const
{
scrollAnimator()->mouseEnteredScrollbar(scrollbar);
}
void ScrollableArea::mouseExitedScrollbar(Scrollbar* scrollbar) const
{
scrollAnimator()->mouseExitedScrollbar(scrollbar);
}
void ScrollableArea::contentAreaDidShow() const
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->contentAreaDidShow();
}
void ScrollableArea::contentAreaDidHide() const
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->contentAreaDidHide();
}
void ScrollableArea::finishCurrentScrollAnimations() const
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->finishCurrentScrollAnimations();
}
void ScrollableArea::didAddScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation)
{
if (orientation == VerticalScrollbar)
scrollAnimator()->didAddVerticalScrollbar(scrollbar);
else
scrollAnimator()->didAddHorizontalScrollbar(scrollbar);
setScrollbarOverlayStyle(scrollbarOverlayStyle());
}
void ScrollableArea::willRemoveScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation)
{
if (orientation == VerticalScrollbar)
scrollAnimator()->willRemoveVerticalScrollbar(scrollbar);
else
scrollAnimator()->willRemoveHorizontalScrollbar(scrollbar);
}
void ScrollableArea::contentsResized()
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->contentsResized();
}
bool ScrollableArea::hasOverlayScrollbars() const
{
return (verticalScrollbar() && verticalScrollbar()->isOverlayScrollbar())
|| (horizontalScrollbar() && horizontalScrollbar()->isOverlayScrollbar());
}
void ScrollableArea::setScrollbarOverlayStyle(ScrollbarOverlayStyle overlayStyle)
{
m_scrollbarOverlayStyle = overlayStyle;
if (horizontalScrollbar()) {
ScrollbarTheme::theme()->updateScrollbarOverlayStyle(horizontalScrollbar());
horizontalScrollbar()->invalidate();
}
if (verticalScrollbar()) {
ScrollbarTheme::theme()->updateScrollbarOverlayStyle(verticalScrollbar());
verticalScrollbar()->invalidate();
}
}
void ScrollableArea::invalidateScrollbar(Scrollbar* scrollbar, const IntRect& rect)
{
#if USE(ACCELERATED_COMPOSITING)
if (scrollbar == horizontalScrollbar()) {
if (GraphicsLayer* graphicsLayer = layerForHorizontalScrollbar()) {
graphicsLayer->setNeedsDisplay();
graphicsLayer->setContentsNeedsDisplay();
return;
}
} else if (scrollbar == verticalScrollbar()) {
if (GraphicsLayer* graphicsLayer = layerForVerticalScrollbar()) {
graphicsLayer->setNeedsDisplay();
graphicsLayer->setContentsNeedsDisplay();
return;
}
}
#endif
invalidateScrollbarRect(scrollbar, rect);
}
void ScrollableArea::invalidateScrollCorner(const IntRect& rect)
{
#if USE(ACCELERATED_COMPOSITING)
if (GraphicsLayer* graphicsLayer = layerForScrollCorner()) {
graphicsLayer->setNeedsDisplay();
return;
}
#endif
invalidateScrollCornerRect(rect);
}
bool ScrollableArea::hasLayerForHorizontalScrollbar() const
{
#if USE(ACCELERATED_COMPOSITING)
return layerForHorizontalScrollbar();
#else
return false;
#endif
}
bool ScrollableArea::hasLayerForVerticalScrollbar() const
{
#if USE(ACCELERATED_COMPOSITING)
return layerForVerticalScrollbar();
#else
return false;
#endif
}
bool ScrollableArea::hasLayerForScrollCorner() const
{
#if USE(ACCELERATED_COMPOSITING)
return layerForScrollCorner();
#else
return false;
#endif
}
void ScrollableArea::serviceScrollAnimations()
{
if (ScrollAnimator* scrollAnimator = existingScrollAnimator())
scrollAnimator->serviceScrollAnimations();
}
#if PLATFORM(IOS)
bool ScrollableArea::isPinnedInBothDirections(const IntSize& scrollDelta) const
{
return isPinnedHorizontallyInDirection(scrollDelta.width()) && isPinnedVerticallyInDirection(scrollDelta.height());
}
bool ScrollableArea::isPinnedHorizontallyInDirection(int horizontalScrollDelta) const
{
if (horizontalScrollDelta < 0 && isHorizontalScrollerPinnedToMinimumPosition())
return true;
if (horizontalScrollDelta > 0 && isHorizontalScrollerPinnedToMaximumPosition())
return true;
return false;
}
bool ScrollableArea::isPinnedVerticallyInDirection(int verticalScrollDelta) const
{
if (verticalScrollDelta < 0 && isVerticalScrollerPinnedToMinimumPosition())
return true;
if (verticalScrollDelta > 0 && isVerticalScrollerPinnedToMaximumPosition())
return true;
return false;
}
#endif // PLATFORM(IOS)
IntPoint ScrollableArea::scrollPosition() const
{
int x = horizontalScrollbar() ? horizontalScrollbar()->value() : 0;
int y = verticalScrollbar() ? verticalScrollbar()->value() : 0;
return IntPoint(x, y);
}
IntPoint ScrollableArea::minimumScrollPosition() const
{
return IntPoint();
}
IntPoint ScrollableArea::maximumScrollPosition() const
{
return IntPoint(totalContentsSize().width() - visibleWidth(), totalContentsSize().height() - visibleHeight());
}
IntSize ScrollableArea::totalContentsSize() const
{
IntSize totalContentsSize = contentsSize();
totalContentsSize.setHeight(totalContentsSize.height() + headerHeight() + footerHeight());
return totalContentsSize;
}
IntRect ScrollableArea::visibleContentRect(VisibleContentRectIncludesScrollbars scrollbarInclusion) const
{
int verticalScrollbarWidth = 0;
int horizontalScrollbarHeight = 0;
if (scrollbarInclusion == IncludeScrollbars) {
if (Scrollbar* verticalBar = verticalScrollbar())
verticalScrollbarWidth = !verticalBar->isOverlayScrollbar() ? verticalBar->width() : 0;
if (Scrollbar* horizontalBar = horizontalScrollbar())
horizontalScrollbarHeight = !horizontalBar->isOverlayScrollbar() ? horizontalBar->height() : 0;
}
return IntRect(scrollPosition().x(),
scrollPosition().y(),
std::max(0, visibleWidth() + verticalScrollbarWidth),
std::max(0, visibleHeight() + horizontalScrollbarHeight));
}
IntPoint ScrollableArea::constrainScrollPositionForOverhang(const IntRect& visibleContentRect, const IntSize& totalContentsSize, const IntPoint& scrollPosition, const IntPoint& scrollOrigin, int headerHeight, int footerHeight)
{
IntSize idealScrollRectSize(std::min(visibleContentRect.width(), totalContentsSize.width()), std::min(visibleContentRect.height(), totalContentsSize.height()));
IntRect scrollRect(scrollPosition + scrollOrigin - IntSize(0, headerHeight), idealScrollRectSize);
IntRect documentRect(IntPoint(), IntSize(totalContentsSize.width(), totalContentsSize.height() - headerHeight - footerHeight));
scrollRect.intersect(documentRect);
if (scrollRect.size() != idealScrollRectSize) {
scrollRect.setSize(idealScrollRectSize);
scrollRect.intersect(documentRect);
if (scrollRect.width() < idealScrollRectSize.width())
scrollRect.move(-(idealScrollRectSize.width() - scrollRect.width()), 0);
if (scrollRect.height() < idealScrollRectSize.height())
scrollRect.move(0, -(idealScrollRectSize.height() - scrollRect.height()));
}
return scrollRect.location() - toIntSize(scrollOrigin);
}
IntPoint ScrollableArea::constrainScrollPositionForOverhang(const IntPoint& scrollPosition)
{
return constrainScrollPositionForOverhang(visibleContentRect(), totalContentsSize(), scrollPosition, scrollOrigin(), headerHeight(), footerHeight());
}
}