#ifndef ScrollableArea_h
#define ScrollableArea_h
#include "Scrollbar.h"
#include <wtf/Vector.h>
namespace WebCore {
class FloatPoint;
class GraphicsContext;
class PlatformGestureEvent;
class PlatformWheelEvent;
class ScrollAnimator;
#if USE(ACCELERATED_COMPOSITING)
class GraphicsLayer;
class TiledBacking;
#endif
class PlatformTouchEvent;
class ScrollableArea {
public:
bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
void scrollToOffsetWithoutAnimation(const FloatPoint&);
void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
void notifyScrollPositionChanged(const IntPoint&);
virtual bool requestScrollPositionUpdate(const IntPoint&) { return false; }
bool handleWheelEvent(const PlatformWheelEvent&);
virtual bool isTouchScrollable() const { return false; }
virtual bool handleTouchEvent(const PlatformTouchEvent&);
virtual bool isOverflowScroll() const { return false; }
virtual void didStartScroll() { }
virtual void didEndScroll() { }
virtual void didUpdateScroll() { }
virtual void setIsUserScroll(bool) { }
bool constrainsScrollingToContentEdge() const { return m_constrainsScrollingToContentEdge; }
void setConstrainsScrollingToContentEdge(bool constrainsScrollingToContentEdge) { m_constrainsScrollingToContentEdge = constrainsScrollingToContentEdge; }
void setVerticalScrollElasticity(ScrollElasticity scrollElasticity) { m_verticalScrollElasticity = scrollElasticity; }
ScrollElasticity verticalScrollElasticity() const { return static_cast<ScrollElasticity>(m_verticalScrollElasticity); }
void setHorizontalScrollElasticity(ScrollElasticity scrollElasticity) { m_horizontalScrollElasticity = scrollElasticity; }
ScrollElasticity horizontalScrollElasticity() const { return static_cast<ScrollElasticity>(m_horizontalScrollElasticity); }
bool inLiveResize() const { return m_inLiveResize; }
void willStartLiveResize();
void willEndLiveResize();
void contentAreaWillPaint() const;
void mouseEnteredContentArea() const;
void mouseExitedContentArea() const;
void mouseMovedInContentArea() const;
void mouseEnteredScrollbar(Scrollbar*) const;
void mouseExitedScrollbar(Scrollbar*) const;
void contentAreaDidShow() const;
void contentAreaDidHide() const;
void didAddVerticalScrollbar(Scrollbar*);
void willRemoveVerticalScrollbar(Scrollbar*);
virtual void didAddHorizontalScrollbar(Scrollbar*);
virtual void willRemoveHorizontalScrollbar(Scrollbar*);
virtual void contentsResized();
bool hasOverlayScrollbars() const;
virtual void setScrollbarOverlayStyle(ScrollbarOverlayStyle);
ScrollbarOverlayStyle scrollbarOverlayStyle() const { return static_cast<ScrollbarOverlayStyle>(m_scrollbarOverlayStyle); }
ScrollAnimator* scrollAnimator() const;
ScrollAnimator* existingScrollAnimator() const { return m_scrollAnimator.get(); }
const IntPoint& scrollOrigin() const { return m_scrollOrigin; }
bool scrollOriginChanged() const { return m_scrollOriginChanged; }
virtual bool isActive() const = 0;
virtual int scrollSize(ScrollbarOrientation) const = 0;
virtual int scrollPosition(Scrollbar*) const = 0;
void invalidateScrollbar(Scrollbar*, const IntRect&);
virtual bool isScrollCornerVisible() const = 0;
virtual IntRect scrollCornerRect() const = 0;
void invalidateScrollCorner(const IntRect&);
virtual void getTickmarks(Vector<IntRect>&) const { }
virtual IntRect convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
{
return scrollbar->Widget::convertToContainingView(scrollbarRect);
}
virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
{
return scrollbar->Widget::convertFromContainingView(parentRect);
}
virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
{
return scrollbar->Widget::convertToContainingView(scrollbarPoint);
}
virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
{
return scrollbar->Widget::convertFromContainingView(parentPoint);
}
virtual Scrollbar* horizontalScrollbar() const { return 0; }
virtual Scrollbar* verticalScrollbar() const { return 0; }
virtual IntPoint scrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
virtual IntPoint minimumScrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
virtual IntPoint maximumScrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
virtual IntRect visibleContentRect(bool = false) const { ASSERT_NOT_REACHED(); return IntRect(); }
virtual int visibleHeight() const { ASSERT_NOT_REACHED(); return 0; }
virtual int visibleWidth() const { ASSERT_NOT_REACHED(); return 0; }
virtual IntSize contentsSize() const { ASSERT_NOT_REACHED(); return IntSize(); }
virtual IntSize overhangAmount() const { ASSERT_NOT_REACHED(); return IntSize(); }
virtual IntPoint currentMousePosition() const { return IntPoint(); }
virtual bool shouldSuspendScrollAnimations() const { return true; }
virtual void scrollbarStyleChanged(int , bool ) { }
virtual void setVisibleScrollerThumbRect(const IntRect&) { }
virtual bool isOnActivePage() const { ASSERT_NOT_REACHED(); return true; }
virtual ScrollableArea* enclosingScrollableArea() const = 0;
virtual IntRect scrollableAreaBoundingBox() const { ASSERT_NOT_REACHED(); return IntRect(); }
virtual bool shouldRubberBandInDirection(ScrollDirection) const { return true; }
virtual bool scrollAnimatorEnabled() const { return false; }
void setScrollOffsetFromInternals(const IntPoint&);
virtual bool scheduleAnimation() { return false; }
void serviceScrollAnimations();
bool isHorizontalScrollerPinnedToMinimumPosition() const { return !horizontalScrollbar() || scrollPosition(horizontalScrollbar()) <= minimumScrollPosition().x(); }
bool isHorizontalScrollerPinnedToMaximumPosition() const { return !horizontalScrollbar() || scrollPosition(horizontalScrollbar()) >= maximumScrollPosition().x(); }
bool isVerticalScrollerPinnedToMinimumPosition() const { return !verticalScrollbar() || scrollPosition(verticalScrollbar()) <= minimumScrollPosition().y(); }
bool isVerticalScrollerPinnedToMaximumPosition() const { return !verticalScrollbar() || scrollPosition(verticalScrollbar()) >= maximumScrollPosition().y(); }
bool isPinnedInBothDirections(const IntSize&) const;
bool isPinnedHorizontallyInDirection(int horizontalScrollDelta) const;
bool isPinnedVerticallyInDirection(int verticalScrollDelta) const;
#if USE(ACCELERATED_COMPOSITING)
virtual TiledBacking* tiledBacking() { return 0; }
#endif
protected:
ScrollableArea();
virtual ~ScrollableArea();
void setScrollOrigin(const IntPoint&);
void resetScrollOriginChanged() { m_scrollOriginChanged = false; }
virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) = 0;
virtual void invalidateScrollCornerRect(const IntRect&) = 0;
#if USE(ACCELERATED_COMPOSITING)
virtual GraphicsLayer* layerForHorizontalScrollbar() const { return 0; }
virtual GraphicsLayer* layerForVerticalScrollbar() const { return 0; }
virtual GraphicsLayer* layerForScrollCorner() const { return 0; }
#if ENABLE(RUBBER_BANDING)
virtual GraphicsLayer* layerForOverhangAreas() const { return 0; }
#endif
#endif
bool hasLayerForHorizontalScrollbar() const;
bool hasLayerForVerticalScrollbar() const;
bool hasLayerForScrollCorner() const;
private:
void scrollPositionChanged(const IntPoint&);
friend class ScrollAnimator;
void setScrollOffsetFromAnimation(const IntPoint&);
virtual void setScrollOffset(const IntPoint&) = 0;
mutable OwnPtr<ScrollAnimator> m_scrollAnimator;
unsigned m_constrainsScrollingToContentEdge : 1;
unsigned m_inLiveResize : 1;
unsigned m_verticalScrollElasticity : 2; unsigned m_horizontalScrollElasticity : 2;
unsigned m_scrollbarOverlayStyle : 2;
unsigned m_scrollOriginChanged : 1;
IntPoint m_scrollOrigin;
};
}
#endif // ScrollableArea_h