code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/platform/ScrollableArea.h

   1 /*
   2  * Copyright (C) 2008, 2011 Apple Inc. All Rights Reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef ScrollableArea_h
  27 #define ScrollableArea_h
  28
  29 #include "LayoutTypes.h"
  30 #include "Scrollbar.h"
  31 #include <wtf/Vector.h>
  32
  33 namespace WebCore {
  34
  35 class FloatPoint;
  36 class GraphicsContext;
  37 class PlatformGestureEvent;
  38 class PlatformWheelEvent;
  39 class ScrollAnimator;
  40 #if USE(ACCELERATED_COMPOSITING)
  41 class GraphicsLayer;
  42 #endif
  43
  44 class ScrollableArea {
  45 public:
  46     ScrollableArea();
  47     virtual ~ScrollableArea();
  48
  49     bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
  50     void scrollToOffsetWithoutAnimation(const FloatPoint&);
  51     void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
  52     void scrollToXOffsetWithoutAnimation(float x);
  53     void scrollToYOffsetWithoutAnimation(float x);
  54
  55     void handleWheelEvent(PlatformWheelEvent&);
  56 #if ENABLE(GESTURE_EVENTS)
  57     void handleGestureEvent(const PlatformGestureEvent&);
  58 #endif
  59
  60     // Functions for controlling if you can scroll past the end of the document.
  61     bool constrainsScrollingToContentEdge() const { return m_constrainsScrollingToContentEdge; }
  62     void setConstrainsScrollingToContentEdge(bool constrainsScrollingToContentEdge) { m_constrainsScrollingToContentEdge = constrainsScrollingToContentEdge; }
  63
  64     void setVerticalScrollElasticity(ScrollElasticity scrollElasticity) { m_verticalScrollElasticity = scrollElasticity; }
  65     ScrollElasticity verticalScrollElasticity() const { return m_verticalScrollElasticity; }
  66
  67     void setHorizontalScrollElasticity(ScrollElasticity scrollElasticity) { m_horizontalScrollElasticity = scrollElasticity; }
  68     ScrollElasticity horizontalScrollElasticity() const { return m_horizontalScrollElasticity; }
  69
  70     bool inLiveResize() const { return m_inLiveResize; }
  71     void willStartLiveResize();
  72     void willEndLiveResize();
  73
  74     void didAddVerticalScrollbar(Scrollbar*);
  75     void willRemoveVerticalScrollbar(Scrollbar*);
  76     virtual void didAddHorizontalScrollbar(Scrollbar*);
  77     virtual void willRemoveHorizontalScrollbar(Scrollbar*);
  78
  79     bool hasOverlayScrollbars() const;
  80     virtual void setScrollbarOverlayStyle(ScrollbarOverlayStyle);
  81     ScrollbarOverlayStyle scrollbarOverlayStyle() const { return m_scrollbarOverlayStyle; }
  82
  83     ScrollAnimator* scrollAnimator() const;
  84     const IntPoint& scrollOrigin() const { return m_scrollOrigin; }
  85
  86     virtual bool isActive() const = 0;
  87     virtual int scrollSize(ScrollbarOrientation) const = 0;
  88     virtual int scrollPosition(Scrollbar*) const = 0;
  89     void invalidateScrollbar(Scrollbar*, const IntRect&);
  90     virtual bool isScrollCornerVisible() const = 0;
  91     virtual IntRect scrollCornerRect() const = 0;
  92     void invalidateScrollCorner();
  93     virtual void getTickmarks(Vector<IntRect>&) const { }
  94
  95     // This function should be overriden by subclasses to perform the actual
  96     // scroll of the content.
  97     virtual void setScrollOffset(const IntPoint&) = 0;
  98
  99     // Convert points and rects between the scrollbar and its containing view.
 100     // The client needs to implement these in order to be aware of layout effects
 101     // like CSS transforms.
 102     virtual IntRect convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
 103     {
 104         return scrollbar->Widget::convertToContainingView(scrollbarRect);
 105     }
 106     virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
 107     {
 108         return scrollbar->Widget::convertFromContainingView(parentRect);
 109     }
 110     virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
 111     {
 112         return scrollbar->Widget::convertToContainingView(scrollbarPoint);
 113     }
 114     virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
 115     {
 116         return scrollbar->Widget::convertFromContainingView(parentPoint);
 117     }
 118
 119     virtual Scrollbar* horizontalScrollbar() const { return 0; }
 120     virtual Scrollbar* verticalScrollbar() const { return 0; }
 121
 122     virtual IntPoint scrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
 123     virtual IntPoint minimumScrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
 124     virtual IntPoint maximumScrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
 125     virtual IntRect visibleContentRect(bool /*includeScrollbars*/ = false) const { ASSERT_NOT_REACHED(); return IntRect(); }
 126     virtual LayoutUnit visibleHeight() const { ASSERT_NOT_REACHED(); return 0; }
 127     virtual LayoutUnit visibleWidth() const { ASSERT_NOT_REACHED(); return 0; }
 128     virtual IntSize contentsSize() const { ASSERT_NOT_REACHED(); return IntSize(); }
 129     virtual IntSize overhangAmount() const { ASSERT_NOT_REACHED(); return IntSize(); }
 130     virtual IntPoint currentMousePosition() const { return IntPoint(); }
 131
 132     virtual void didStartRubberBand(const IntSize&) const { ASSERT_NOT_REACHED(); }
 133     virtual void didCompleteRubberBand(const IntSize&) const { ASSERT_NOT_REACHED(); }
 134     virtual void didStartAnimatedScroll() const { }
 135     virtual void didCompleteAnimatedScroll() const { }
 136
 137     virtual bool shouldSuspendScrollAnimations() const { return true; }
 138     virtual void scrollbarStyleChanged() { }
 139     virtual void setVisibleScrollerThumbRect(const IntRect&) { }
 140
 141     virtual bool isOnActivePage() const { ASSERT_NOT_REACHED(); return true; }
 142
 143     bool isHorizontalScrollerPinnedToMinimumPosition() const { return !horizontalScrollbar() || scrollPosition(horizontalScrollbar()) <= minimumScrollPosition().x(); }
 144     bool isHorizontalScrollerPinnedToMaximumPosition() const { return !horizontalScrollbar() || scrollPosition(horizontalScrollbar()) >= maximumScrollPosition().x(); }
 145     bool isVerticalScrollerPinnedToMinimumPosition() const { return !verticalScrollbar() || scrollPosition(verticalScrollbar()) <= minimumScrollPosition().y(); }
 146     bool isVerticalScrollerPinnedToMaximumPosition() const { return !verticalScrollbar() || scrollPosition(verticalScrollbar()) >= maximumScrollPosition().y(); }
 147
 148     // Note that this only returns scrollable areas that can actually be scrolled.
 149     virtual ScrollableArea* enclosingScrollableArea() const = 0;
 150
 151     bool isPinnedInBothDirections(const IntSize&) const;
 152     bool isPinnedHorizontallyInDirection(int horizontalScrollDelta) const;
 153     bool isPinnedVerticallyInDirection(int verticalScrollDelta) const;
 154
 155     virtual bool shouldRubberBandInDirection(ScrollDirection) const { return true; }
 156
 157     virtual void disconnectFromPage() { }
 158
 159     virtual bool scrollAnimatorEnabled() const { return false; }
 160
 161     // NOTE: Only called from Internals for testing.
 162     void setScrollOffsetFromInternals(const IntPoint&);
 163
 164 private:
 165     // NOTE: Only called from the ScrollAnimator.
 166     friend class ScrollAnimator;
 167     void setScrollOffsetFromAnimation(const IntPoint&);
 168
 169     mutable OwnPtr<ScrollAnimator> m_scrollAnimator;
 170     bool m_constrainsScrollingToContentEdge;
 171
 172     bool m_inLiveResize;
 173
 174     ScrollElasticity m_verticalScrollElasticity;
 175     ScrollElasticity m_horizontalScrollElasticity;
 176
 177     ScrollbarOverlayStyle m_scrollbarOverlayStyle;
 178
 179 protected:
 180     virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) = 0;
 181     virtual void invalidateScrollCornerRect(const IntRect&) = 0;
 182
 183 #if USE(ACCELERATED_COMPOSITING)
 184     virtual GraphicsLayer* layerForHorizontalScrollbar() const { return 0; }
 185     virtual GraphicsLayer* layerForVerticalScrollbar() const { return 0; }
 186     virtual GraphicsLayer* layerForScrollCorner() const { return 0; }
 187 #if PLATFORM(CHROMIUM) && ENABLE(RUBBER_BANDING)
 188     virtual GraphicsLayer* layerForOverhangAreas() const { return 0; }
 189 #endif
 190 #endif
 191     bool hasLayerForHorizontalScrollbar() const;
 192     bool hasLayerForVerticalScrollbar() const;
 193     bool hasLayerForScrollCorner() const;
 194
 195     // There are 8 possible combinations of writing mode and direction. Scroll origin will be non-zero in the x or y axis
 196     // if there is any reversed direction or writing-mode. The combinations are:
 197     // writing-mode / direction     scrollOrigin.x() set    scrollOrigin.y() set
 198     // horizontal-tb / ltr          NO                      NO
 199     // horizontal-tb / rtl          YES                     NO
 200     // horizontal-bt / ltr          NO                      YES
 201     // horizontal-bt / rtl          YES                     YES
 202     // vertical-lr / ltr            NO                      NO
 203     // vertical-lr / rtl            NO                      YES
 204     // vertical-rl / ltr            YES                     NO
 205     // vertical-rl / rtl            YES                     YES
 206     IntPoint m_scrollOrigin;
 207 };
 208
 209 } // namespace WebCore
 210
 211 #endif // ScrollableArea_h