Remove "virtual" from all lines that have both "virtual" and "override".
[WebKit-https.git] / Source / WebCore / page / scrolling / ScrollingConstraints.h
1 /*
2  * Copyright (C) 2012 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. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef ScrollingConstraints_h
27 #define ScrollingConstraints_h
28
29 #include "FloatRect.h"
30
31 namespace WebCore {
32
33 // ViewportConstraints classes encapsulate data and logic required to reposition elements whose layout
34 // depends on the viewport rect (positions fixed and sticky), when scrolling and zooming.
35 class ViewportConstraints {
36     WTF_MAKE_FAST_ALLOCATED;
37 public:
38     enum ConstraintType {
39         FixedPositionConstraint,
40         StickyPositionConstraint
41     };
42
43     enum AnchorEdgeFlags {
44         AnchorEdgeLeft = 1 << 0,
45         AnchorEdgeRight = 1 << 1,
46         AnchorEdgeTop = 1 << 2,
47         AnchorEdgeBottom = 1 << 3
48     };
49     typedef unsigned AnchorEdges;
50
51     ViewportConstraints(const ViewportConstraints& other)
52         : m_alignmentOffset(other.m_alignmentOffset)
53         , m_anchorEdges(other.m_anchorEdges)
54     { }
55     
56     virtual ~ViewportConstraints() { }
57     
58     virtual ConstraintType constraintType() const = 0;
59     
60     AnchorEdges anchorEdges() const { return m_anchorEdges; }
61     bool hasAnchorEdge(AnchorEdgeFlags flag) const { return m_anchorEdges & flag; }
62     void addAnchorEdge(AnchorEdgeFlags edgeFlag) { m_anchorEdges |= edgeFlag; }
63     void setAnchorEdges(AnchorEdges edges) { m_anchorEdges = edges; }
64     
65     FloatSize alignmentOffset() const { return m_alignmentOffset; }
66     void setAlignmentOffset(const FloatSize& offset) { m_alignmentOffset = offset; }
67
68 protected:
69     ViewportConstraints()
70         : m_anchorEdges(0)
71     { }
72
73     FloatSize m_alignmentOffset;
74     AnchorEdges m_anchorEdges;
75 };
76
77 class FixedPositionViewportConstraints : public ViewportConstraints {
78 public:
79     FixedPositionViewportConstraints()
80         : ViewportConstraints()
81     { }
82
83     FixedPositionViewportConstraints(const FixedPositionViewportConstraints& other)
84         : ViewportConstraints(other)
85         , m_viewportRectAtLastLayout(other.m_viewportRectAtLastLayout)
86         , m_layerPositionAtLastLayout(other.m_layerPositionAtLastLayout)
87     { }
88     
89     WEBCORE_EXPORT FloatPoint layerPositionForViewportRect(const FloatRect& viewportRect) const;
90
91     const FloatRect& viewportRectAtLastLayout() const { return m_viewportRectAtLastLayout; }
92     void setViewportRectAtLastLayout(const FloatRect& rect) { m_viewportRectAtLastLayout = rect; }
93
94     const FloatPoint& layerPositionAtLastLayout() const { return m_layerPositionAtLastLayout; }
95     void setLayerPositionAtLastLayout(const FloatPoint& point) { m_layerPositionAtLastLayout = point; }
96
97     bool operator==(const FixedPositionViewportConstraints& other) const
98     {
99         return m_alignmentOffset == other.m_alignmentOffset
100             && m_anchorEdges == other.m_anchorEdges
101             && m_viewportRectAtLastLayout == other.m_viewportRectAtLastLayout
102             && m_layerPositionAtLastLayout == other.m_layerPositionAtLastLayout;
103     }
104
105     bool operator!=(const FixedPositionViewportConstraints& other) const { return !(*this == other); }
106
107 private:
108     ConstraintType constraintType() const override { return FixedPositionConstraint; };
109
110     FloatRect m_viewportRectAtLastLayout;
111     FloatPoint m_layerPositionAtLastLayout;
112 };
113
114 class StickyPositionViewportConstraints : public ViewportConstraints {
115 public:
116     StickyPositionViewportConstraints()
117         : m_leftOffset(0)
118         , m_rightOffset(0)
119         , m_topOffset(0)
120         , m_bottomOffset(0)
121     { }
122
123     StickyPositionViewportConstraints(const StickyPositionViewportConstraints& other)
124         : ViewportConstraints(other)
125         , m_leftOffset(other.m_leftOffset)
126         , m_rightOffset(other.m_rightOffset)
127         , m_topOffset(other.m_topOffset)
128         , m_bottomOffset(other.m_bottomOffset)
129         , m_constrainingRectAtLastLayout(other.m_constrainingRectAtLastLayout)
130         , m_containingBlockRect(other.m_containingBlockRect)
131         , m_stickyBoxRect(other.m_stickyBoxRect)
132         , m_stickyOffsetAtLastLayout(other.m_stickyOffsetAtLastLayout)
133         , m_layerPositionAtLastLayout(other.m_layerPositionAtLastLayout)
134     { }
135
136     FloatSize computeStickyOffset(const FloatRect& constrainingRect) const;
137
138     const FloatSize stickyOffsetAtLastLayout() const { return m_stickyOffsetAtLastLayout; }
139     void setStickyOffsetAtLastLayout(const FloatSize& offset) { m_stickyOffsetAtLastLayout = offset; }
140
141     WEBCORE_EXPORT FloatPoint layerPositionForConstrainingRect(const FloatRect& constrainingRect) const;
142
143     const FloatPoint& layerPositionAtLastLayout() const { return m_layerPositionAtLastLayout; }
144     void setLayerPositionAtLastLayout(const FloatPoint& point) { m_layerPositionAtLastLayout = point; }
145
146     float leftOffset() const { return m_leftOffset; }
147     float rightOffset() const { return m_rightOffset; }
148     float topOffset() const { return m_topOffset; }
149     float bottomOffset() const { return m_bottomOffset; }
150
151     void setLeftOffset(float offset) { m_leftOffset = offset; }
152     void setRightOffset(float offset) { m_rightOffset = offset; }
153     void setTopOffset(float offset) { m_topOffset = offset; }
154     void setBottomOffset(float offset) { m_bottomOffset = offset; }
155
156     // constrainingRectAtLastLayout() is the viewport rect if this sticky object sticks to the viewport, and
157     // it is the overflow area's scrolled clip rect if this sticky object sticks inside an overflow area.
158     FloatRect constrainingRectAtLastLayout() const { return m_constrainingRectAtLastLayout; }
159     void setConstrainingRectAtLastLayout(const FloatRect& rect) { m_constrainingRectAtLastLayout = rect; }
160
161     // containingBlockRect() is in the scrolling ancestor's coordinate space.
162     FloatRect containingBlockRect() const { return m_containingBlockRect; }
163     void setContainingBlockRect(const FloatRect& rect) { m_containingBlockRect = rect; }
164
165     // stickyBoxRect() is in the scrolling ancestor's coordinate space.
166     FloatRect stickyBoxRect() const { return m_stickyBoxRect; }
167     void setStickyBoxRect(const FloatRect& rect) { m_stickyBoxRect = rect; }
168
169     bool operator==(const StickyPositionViewportConstraints& other) const
170     {
171         return m_alignmentOffset == other.m_alignmentOffset
172             && m_anchorEdges == other.m_anchorEdges
173             && m_leftOffset == other.m_leftOffset
174             && m_rightOffset == other.m_rightOffset
175             && m_topOffset == other.m_topOffset
176             && m_bottomOffset == other.m_bottomOffset
177             && m_containingBlockRect == other.m_containingBlockRect
178             && m_stickyBoxRect == other.m_stickyBoxRect
179             && m_stickyOffsetAtLastLayout == other.m_stickyOffsetAtLastLayout
180             && m_layerPositionAtLastLayout == other.m_layerPositionAtLastLayout;
181     }
182
183     bool operator!=(const StickyPositionViewportConstraints& other) const { return !(*this == other); }
184
185 private:
186     ConstraintType constraintType() const override { return StickyPositionConstraint; };
187
188     float m_leftOffset;
189     float m_rightOffset;
190     float m_topOffset;
191     float m_bottomOffset;
192     FloatRect m_constrainingRectAtLastLayout;
193     FloatRect m_containingBlockRect;
194     FloatRect m_stickyBoxRect;
195     FloatSize m_stickyOffsetAtLastLayout;
196     FloatPoint m_layerPositionAtLastLayout;
197 };
198
199 WEBCORE_EXPORT TextStream& operator<<(TextStream&, const FixedPositionViewportConstraints&);
200 WEBCORE_EXPORT TextStream& operator<<(TextStream&, const StickyPositionViewportConstraints&);
201
202 } // namespace WebCore
203
204 #endif // ScrollingConstraints_h