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 {
ScrollableArea::ScrollableArea()
: m_constrainsScrollingToContentEdge(true)
, m_inLiveResize(false)
, m_verticalScrollElasticity(ScrollElasticityNone)
, m_horizontalScrollElasticity(ScrollElasticityNone)
, m_scrollbarOverlayStyle(ScrollbarOverlayStyleDefault)
{
}
ScrollableArea::~ScrollableArea()
{
}
ScrollAnimator* ScrollableArea::scrollAnimator() const
{
if (!m_scrollAnimator)
m_scrollAnimator = ScrollAnimator::create(const_cast<ScrollableArea*>(this));
return m_scrollAnimator.get();
}
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;
}
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)
scrollToXOffsetWithoutAnimation(offset);
else
scrollToYOffsetWithoutAnimation(offset);
}
void ScrollableArea::scrollToXOffsetWithoutAnimation(float x)
{
scrollToOffsetWithoutAnimation(FloatPoint(x, scrollAnimator()->currentPosition().y()));
}
void ScrollableArea::scrollToYOffsetWithoutAnimation(float y)
{
scrollToOffsetWithoutAnimation(FloatPoint(scrollAnimator()->currentPosition().x(), y));
}
void ScrollableArea::handleWheelEvent(PlatformWheelEvent& wheelEvent)
{
scrollAnimator()->handleWheelEvent(wheelEvent);
}
#if ENABLE(GESTURE_EVENTS)
void ScrollableArea::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
{
scrollAnimator()->handleGestureEvent(gestureEvent);
}
#endif
void ScrollableArea::setScrollOffsetFromAnimation(const IntPoint& offset)
{
setScrollOffset(offset);
Scrollbar* verticalScrollbar = this->verticalScrollbar();
if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
horizontalScrollbar->offsetDidChange();
if (horizontalScrollbar->isOverlayScrollbar()) {
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())
verticalScrollbar->invalidate();
}
}
void ScrollableArea::willStartLiveResize()
{
if (m_inLiveResize)
return;
m_inLiveResize = true;
scrollAnimator()->willStartLiveResize();
}
void ScrollableArea::willEndLiveResize()
{
if (!m_inLiveResize)
return;
m_inLiveResize = false;
scrollAnimator()->willEndLiveResize();
}
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);
}
bool ScrollableArea::hasOverlayScrollbars() const
{
return (verticalScrollbar() && verticalScrollbar()->isOverlayScrollbar())
|| (horizontalScrollbar() && horizontalScrollbar()->isOverlayScrollbar());
}
void ScrollableArea::setScrollbarOverlayStyle(ScrollbarOverlayStyle overlayStyle)
{
m_scrollbarOverlayStyle = overlayStyle;
if (horizontalScrollbar()) {
ScrollbarTheme::nativeTheme()->updateScrollbarOverlayStyle(horizontalScrollbar());
horizontalScrollbar()->invalidate();
}
if (verticalScrollbar()) {
ScrollbarTheme::nativeTheme()->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();
return;
}
} else if (scrollbar == verticalScrollbar()) {
if (GraphicsLayer* graphicsLayer = layerForVerticalScrollbar()) {
graphicsLayer->setNeedsDisplay();
return;
}
}
#endif
invalidateScrollbarRect(scrollbar, rect);
}
void ScrollableArea::invalidateScrollCorner()
{
#if USE(ACCELERATED_COMPOSITING)
if (GraphicsLayer* graphicsLayer = layerForScrollCorner()) {
graphicsLayer->setNeedsDisplay();
return;
}
#endif
invalidateScrollCornerRect(scrollCornerRect());
}
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
}
}