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