[Texmap] Implementation for pattern compositing
[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         , m_patternTransformDirty(false)
60     { }
61
62     virtual ~TextureMapperLayer();
63
64     void setID(uint32_t id) { m_id = id; }
65     uint32_t id() { return m_id; }
66
67     const Vector<TextureMapperLayer*>& children() const { return m_children; }
68     TextureMapperLayer* findScrollableContentsLayerAt(const FloatPoint& pos);
69
70     void setScrollClient(ScrollingClient* scrollClient) { m_scrollClient = scrollClient; }
71     void scrollBy(const WebCore::FloatSize&);
72
73     void didCommitScrollOffset(const IntSize&);
74     void setIsScrollable(bool isScrollable) { m_isScrollable = isScrollable; }
75     bool isScrollable() const { return m_isScrollable; }
76
77     TextureMapper* textureMapper() const;
78     void setTextureMapper(TextureMapper* texmap) { m_textureMapper = texmap; }
79
80     void setChildren(const Vector<TextureMapperLayer*>&);
81     void setMaskLayer(TextureMapperLayer*);
82     void setReplicaLayer(TextureMapperLayer*);
83     void setPosition(const FloatPoint&);
84     void setSize(const FloatSize&);
85     void setAnchorPoint(const FloatPoint3D&);
86     void setPreserves3D(bool);
87     void setTransform(const TransformationMatrix&);
88     void setChildrenTransform(const TransformationMatrix&);
89     void setContentsRect(const IntRect&);
90     void setMasksToBounds(bool);
91     void setDrawsContent(bool);
92     bool drawsContent() const { return m_state.drawsContent; }
93     bool contentsAreVisible() const { return m_state.contentsVisible; }
94     FloatSize size() const { return m_state.size; }
95     float opacity() const { return m_state.opacity; }
96     TransformationMatrix transform() const { return m_state.transform; }
97     void setContentsVisible(bool);
98     void setContentsOpaque(bool);
99     void setBackfaceVisibility(bool);
100     void setOpacity(float);
101     void setSolidColor(const Color&);
102     void setContentsTileSize(const IntSize&);
103     void setContentsTilePhase(const IntPoint&);
104 #if ENABLE(CSS_FILTERS)
105     void setFilters(const FilterOperations&);
106 #endif
107
108     bool hasFilters() const
109     {
110 #if ENABLE(CSS_FILTERS)
111         return !m_currentFilters.isEmpty();
112 #else
113         return false;
114 #endif
115     }
116
117     void setDebugVisuals(bool showDebugBorders, const Color& debugBorderColor, float debugBorderWidth, bool showRepaintCounter);
118     bool isShowingRepaintCounter() const { return m_state.showRepaintCounter; }
119     void setRepaintCount(int);
120     void setContentsLayer(TextureMapperPlatformLayer*);
121     void setAnimations(const GraphicsLayerAnimations&);
122     void setFixedToViewport(bool);
123     bool fixedToViewport() const { return m_fixedToViewport; }
124     void setBackingStore(PassRefPtr<TextureMapperBackingStore>);
125     void setShouldMapBackingStoreToContentsRect(bool m) { m_state.shouldMapBackingStoreToContentsRect = m; }
126
127     void syncAnimations();
128     bool descendantsOrSelfHaveRunningAnimations() const;
129
130     void paint();
131
132     void setScrollPositionDeltaIfNeeded(const FloatSize&);
133
134     void applyAnimationsRecursively();
135     void addChild(TextureMapperLayer*);
136
137 private:
138     const TextureMapperLayer* rootLayer() const;
139     void computeTransformsRecursive();
140
141     static int compareGraphicsLayersZValue(const void* a, const void* b);
142     static void sortByZOrder(Vector<TextureMapperLayer* >& array);
143
144     PassRefPtr<BitmapTexture> texture() { return m_backingStore ? m_backingStore->texture() : 0; }
145     FloatPoint adjustedPosition() const { return m_state.pos + m_scrollPositionDelta - m_userScrollOffset; }
146     bool isAncestorFixedToViewport() const;
147     TransformationMatrix replicaTransform();
148     void removeFromParent();
149     void removeAllChildren();
150
151     enum ResolveSelfOverlapMode {
152         ResolveSelfOverlapAlways = 0,
153         ResolveSelfOverlapIfNeeded
154     };
155     void computeOverlapRegions(Region& overlapRegion, Region& nonOverlapRegion, ResolveSelfOverlapMode);
156
157     void paintRecursive(const TextureMapperPaintOptions&);
158     void paintUsingOverlapRegions(const TextureMapperPaintOptions&);
159     PassRefPtr<BitmapTexture> paintIntoSurface(const TextureMapperPaintOptions&, const IntSize&);
160     void paintWithIntermediateSurface(const TextureMapperPaintOptions&, const IntRect&);
161     void paintSelf(const TextureMapperPaintOptions&);
162     void paintSelfAndChildren(const TextureMapperPaintOptions&);
163     void paintSelfAndChildrenWithReplica(const TextureMapperPaintOptions&);
164     void applyMask(const TextureMapperPaintOptions&);
165     void computePatternTransformIfNeeded();
166
167     // GraphicsLayerAnimation::Client
168     virtual void setAnimatedTransform(const TransformationMatrix&) OVERRIDE;
169     virtual void setAnimatedOpacity(float) OVERRIDE;
170 #if ENABLE(CSS_FILTERS)
171     virtual void setAnimatedFilters(const FilterOperations&) OVERRIDE;
172 #endif
173
174     bool isVisible() const;
175     enum ContentsLayerCount {
176         NoLayersWithContent,
177         SingleLayerWithContents,
178         MultipleLayersWithContents
179     };
180
181     bool shouldBlend() const;
182
183     inline FloatRect layerRect() const
184     {
185         return FloatRect(FloatPoint::zero(), m_state.size);
186     }
187
188     Vector<TextureMapperLayer*> m_children;
189     TextureMapperLayer* m_parent;
190     TextureMapperLayer* m_effectTarget;
191     RefPtr<TextureMapperBackingStore> m_backingStore;
192     TextureMapperPlatformLayer* m_contentsLayer;
193     GraphicsLayerTransform m_currentTransform;
194     float m_currentOpacity;
195 #if ENABLE(CSS_FILTERS)
196     FilterOperations m_currentFilters;
197 #endif
198     float m_centerZ;
199
200     template<class HitTestCondition> TextureMapperLayer* hitTest(const FloatPoint&, HitTestCondition);
201     static bool scrollableLayerHitTestCondition(TextureMapperLayer*, const FloatPoint&);
202
203     FloatSize mapScrollOffset(const FloatSize&);
204     void commitScrollOffset(const FloatSize&);
205
206     struct State {
207         FloatPoint pos;
208         FloatPoint3D anchorPoint;
209         FloatSize size;
210         TransformationMatrix transform;
211         TransformationMatrix childrenTransform;
212         float opacity;
213         FloatRect contentsRect;
214         IntSize contentsTileSize;
215         IntPoint contentsTilePhase;
216         TextureMapperLayer* maskLayer;
217         TextureMapperLayer* replicaLayer;
218         Color solidColor;
219 #if ENABLE(CSS_FILTERS)
220         FilterOperations filters;
221 #endif
222         Color debugBorderColor;
223         float debugBorderWidth;
224         int repaintCount;
225
226         bool preserves3D : 1;
227         bool masksToBounds : 1;
228         bool drawsContent : 1;
229         bool contentsVisible : 1;
230         bool contentsOpaque : 1;
231         bool backfaceVisibility : 1;
232         bool visible : 1;
233         bool showDebugBorders : 1;
234         bool showRepaintCounter : 1;
235         bool shouldMapBackingStoreToContentsRect : 1;
236
237         State()
238             : opacity(1)
239             , maskLayer(0)
240             , replicaLayer(0)
241             , debugBorderWidth(0)
242             , repaintCount(0)
243             , preserves3D(false)
244             , masksToBounds(false)
245             , drawsContent(false)
246             , contentsVisible(true)
247             , contentsOpaque(false)
248             , backfaceVisibility(true)
249             , visible(true)
250             , showDebugBorders(false)
251             , showRepaintCounter(false)
252             , shouldMapBackingStoreToContentsRect(false)
253         {
254         }
255     };
256
257     State m_state;
258     TextureMapper* m_textureMapper;
259     GraphicsLayerAnimations m_animations;
260     FloatSize m_scrollPositionDelta;
261     bool m_fixedToViewport;
262     uint32_t m_id;
263     ScrollingClient* m_scrollClient;
264     bool m_isScrollable;
265     FloatSize m_userScrollOffset;
266     FloatSize m_accumulatedScrollOffsetFractionalPart;
267     TransformationMatrix m_patternTransform;
268     bool m_patternTransformDirty;
269 };
270
271 }
272 #endif
273
274 #endif // TextureMapperLayer_h