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:
step = scrollbar->pixelStep();
break;
case ScrollByPixelVelocity:
break;
}
if (granularity != ScrollByPixelVelocity && (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)
{
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();
}
scrollAnimator()->notifyContentAreaScrolled();
}
bool ScrollableArea::handleWheelEvent(const PlatformWheelEvent& wheelEvent)
{
return scrollAnimator()->handleWheelEvent(wheelEvent);
}
bool ScrollableArea::handleTouchEvent(const PlatformTouchEvent& touchEvent)
{
return scrollAnimator()->handleTouchEvent(touchEvent);
}
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::didAddVerticalScrollbar(Scrollbar* scrollbar)
{
scrollAnimator()->didAddVerticalScrollbar(scrollbar);
setScrollbarOverlayStyle(scrollbarOverlayStyle());
}
void ScrollableArea::willRemoveVerticalScrollbar(Scrollbar* scrollbar)
{
scrollAnimator()->willRemoveVerticalScrollbar(scrollbar);
}
void ScrollableArea::didAddHorizontalScrollbar(Scrollbar* scrollbar)
{
scrollAnimator()->didAddHorizontalScrollbar(scrollbar);
setScrollbarOverlayStyle(scrollbarOverlayStyle());
}
void ScrollableArea::willRemoveHorizontalScrollbar(Scrollbar* scrollbar)
{
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();
}
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;
}
}