Accelerated overflow scrolling for Coordinated Graphics.
[WebKit-https.git] / Source / WebCore / platform / graphics / texmap / TextureMapperLayer.h
1 /*
2  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
3
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License as published by the Free Software Foundation; either
7  version 2 of the License, or (at your option) any later version.
8
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  Library General Public License for more details.
13
14  You should have received a copy of the GNU Library General Public License
15  along with this library; see the file COPYING.LIB.  If not, write to
16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  Boston, MA 02110-1301, USA.
18  */
19
20 #ifndef TextureMapperLayer_h
21 #define TextureMapperLayer_h
22
23 #if USE(ACCELERATED_COMPOSITING)
24
25 #include "FilterOperations.h"
26 #include "FloatRect.h"
27 #include "GraphicsLayerAnimation.h"
28 #include "GraphicsLayerTransform.h"
29 #include "TextureMapper.h"
30 #include "TextureMapperBackingStore.h"
31
32 namespace WebCore {
33
34 class Region;
35 class TextureMapperPaintOptions;
36 class TextureMapperPlatformLayer;
37
38 class TextureMapperLayer : public GraphicsLayerAnimation::Client {
39     WTF_MAKE_NONCOPYABLE(TextureMapperLayer);
40     WTF_MAKE_FAST_ALLOCATED;
41 public:
42
43     class ScrollingClient {
44     public:
45         virtual void commitScrollOffset(uint32_t layerID, const IntSize& offset) = 0;
46     };
47
48     TextureMapperLayer()
49         : m_parent(0)
50         , m_effectTarget(0)
51         , m_contentsLayer(0)
52         , m_currentOpacity(1)
53         , m_centerZ(0)
54         , m_textureMapper(0)
55         , m_fixedToViewport(false)
56         , m_id(0)
57         , m_scrollClient(0)
58         , m_isScrollable(false)
59     { }
60
61     virtual ~TextureMapperLayer();
62
63     void setID(uint32_t id) { m_id = id; }
64     uint32_t id() { return m_id; }
65
66     TextureMapperLayer* findScrollableContentsLayerAt(const FloatPoint& pos);
67
68     void setScrollClient(ScrollingClient* scrollClient) { m_scrollClient = scrollClient; }
69     void scrollBy(const WebCore::FloatSize&);
70
71     void didCommitScrollOffset(const IntSize&);
72     void setIsScrollable(bool isScrollable) { m_isScrollable = isScrollable; }
73     bool isScrollable() const { return m_isScrollable; }
74
75     TextureMapper* textureMapper() const;
76     void setTextureMapper(TextureMapper* texmap) { m_textureMapper = texmap; }
77
78     void setChildren(const Vector<TextureMapperLayer*>&);
79     void setMaskLayer(TextureMapperLayer*);
80     void setReplicaLayer(TextureMapperLayer*);
81     void setPosition(const FloatPoint&);
82     void setSize(const FloatSize&);
83     void setAnchorPoint(const FloatPoint3D&);
84     void setPreserves3D(bool);
85     void setTransform(const TransformationMatrix&);
86     void setChildrenTransform(const TransformationMatrix&);
87     void setContentsRect(const IntRect&);
88     void setMasksToBounds(bool);
89     void setDrawsContent(bool);
90     void setContentsVisible(bool);
91     void setContentsOpaque(bool);
92     void setBackfaceVisibility(bool);
93     void setOpacity(float);
94     void setSolidColor(const Color&);
95 #if ENABLE(CSS_FILTERS)
96     void setFilters(const FilterOperations&);
97 #endif
98
99     bool hasFilters() const
100     {
101 #if ENABLE(CSS_FILTERS)
102         return !m_currentFilters.isEmpty();
103 #else
104         return false;
105 #endif
106     }
107
108     void setDebugVisuals(bool showDebugBorders, const Color& debugBorderColor, float debugBorderWidth, bool showRepaintCounter);
109     void setRepaintCount(int);
110     void setContentsLayer(TextureMapperPlatformLayer*);
111     void setAnimations(const GraphicsLayerAnimations&);
112     void setFixedToViewport(bool);
113     void setBackingStore(PassRefPtr<TextureMapperBackingStore>);
114
115     void syncAnimations();
116     bool descendantsOrSelfHaveRunningAnimations() const;
117
118     void paint();
119
120     void setScrollPositionDeltaIfNeeded(const FloatSize&);
121
122     void applyAnimationsRecursively();
123
124 private:
125     const TextureMapperLayer* rootLayer() const;
126     void computeTransformsRecursive();
127
128     static int compareGraphicsLayersZValue(const void* a, const void* b);
129     static void sortByZOrder(Vector<TextureMapperLayer* >& array, int first, int last);
130
131     PassRefPtr<BitmapTexture> texture() { return m_backingStore ? m_backingStore->texture() : 0; }
132     FloatPoint adjustedPosition() const { return m_state.pos + m_scrollPositionDelta - m_userScrollOffset; }
133     bool isAncestorFixedToViewport() const;
134     TransformationMatrix replicaTransform();
135     void addChild(TextureMapperLayer*);
136     void removeFromParent();
137     void removeAllChildren();
138
139     void computeOverlapRegions(Region& overlapRegion, Region& nonOverlapRegion, bool alwaysResolveSelfOverlap = true);
140
141     void paintRecursive(const TextureMapperPaintOptions&);
142     void paintUsingOverlapRegions(const TextureMapperPaintOptions&);
143     PassRefPtr<BitmapTexture> paintIntoSurface(const TextureMapperPaintOptions&, const IntSize&);
144     void paintWithIntermediateSurface(const TextureMapperPaintOptions&, const IntRect&);
145     void paintSelf(const TextureMapperPaintOptions&);
146     void paintSelfAndChildren(const TextureMapperPaintOptions&);
147     void paintSelfAndChildrenWithReplica(const TextureMapperPaintOptions&);
148     void applyMask(const TextureMapperPaintOptions&);
149
150     // GraphicsLayerAnimation::Client
151     virtual void setAnimatedTransform(const TransformationMatrix&) OVERRIDE;
152     virtual void setAnimatedOpacity(float) OVERRIDE;
153 #if ENABLE(CSS_FILTERS)
154     virtual void setAnimatedFilters(const FilterOperations&) OVERRIDE;
155 #endif
156
157     bool isVisible() const;
158     enum ContentsLayerCount {
159         NoLayersWithContent,
160         SingleLayerWithContents,
161         MultipleLayersWithContents
162     };
163
164     bool shouldBlend() const;
165
166     inline FloatRect layerRect() const
167     {
168         return FloatRect(FloatPoint::zero(), m_state.size);
169     }
170
171     Vector<TextureMapperLayer*> m_children;
172     TextureMapperLayer* m_parent;
173     TextureMapperLayer* m_effectTarget;
174     RefPtr<TextureMapperBackingStore> m_backingStore;
175     TextureMapperPlatformLayer* m_contentsLayer;
176     GraphicsLayerTransform m_currentTransform;
177     float m_currentOpacity;
178 #if ENABLE(CSS_FILTERS)
179     FilterOperations m_currentFilters;
180 #endif
181     float m_centerZ;
182
183     template<class HitTestCondition> TextureMapperLayer* hitTest(const FloatPoint&, HitTestCondition);
184     static bool scrollableLayerHitTestCondition(TextureMapperLayer*, const FloatPoint&);
185
186     FloatSize mapScrollOffset(const FloatSize&);
187     void commitScrollOffset(const FloatSize&);
188
189     struct State {
190         FloatPoint pos;
191         FloatPoint3D anchorPoint;
192         FloatSize size;
193         TransformationMatrix transform;
194         TransformationMatrix childrenTransform;
195         float opacity;
196         FloatRect contentsRect;
197         TextureMapperLayer* maskLayer;
198         TextureMapperLayer* replicaLayer;
199         Color solidColor;
200 #if ENABLE(CSS_FILTERS)
201         FilterOperations filters;
202 #endif
203         Color debugBorderColor;
204         float debugBorderWidth;
205         int repaintCount;
206
207         bool preserves3D : 1;
208         bool masksToBounds : 1;
209         bool drawsContent : 1;
210         bool contentsVisible : 1;
211         bool contentsOpaque : 1;
212         bool backfaceVisibility : 1;
213         bool visible : 1;
214         bool showDebugBorders : 1;
215         bool showRepaintCounter : 1;
216
217         State()
218             : opacity(1)
219             , maskLayer(0)
220             , replicaLayer(0)
221             , debugBorderWidth(0)
222             , repaintCount(0)
223             , preserves3D(false)
224             , masksToBounds(false)
225             , drawsContent(false)
226             , contentsVisible(true)
227             , contentsOpaque(false)
228             , backfaceVisibility(true)
229             , visible(true)
230             , showDebugBorders(false)
231             , showRepaintCounter(false)
232         {
233         }
234     };
235
236     State m_state;
237     TextureMapper* m_textureMapper;
238     GraphicsLayerAnimations m_animations;
239     FloatSize m_scrollPositionDelta;
240     bool m_fixedToViewport;
241     uint32_t m_id;
242     ScrollingClient* m_scrollClient;
243     bool m_isScrollable;
244     FloatSize m_userScrollOffset;
245     FloatSize m_accumulatedScrollOffsetFractionalPart;
246 };
247
248 }
249 #endif
250
251 #endif // TextureMapperLayer_h