2010-09-08 Dean Jackson <dino@apple.com>
[WebKit-https.git] / WebCore / platform / graphics / GraphicsLayer.h
1 /*
2  * Copyright (C) 2009 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 COMPUTER, 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 GraphicsLayer_h
27 #define GraphicsLayer_h
28
29 #if USE(ACCELERATED_COMPOSITING)
30
31 #include "Animation.h"
32 #include "Color.h"
33 #include "FloatPoint.h"
34 #include "FloatPoint3D.h"
35 #include "FloatSize.h"
36 #include "GraphicsLayerClient.h"
37 #include "IntRect.h"
38 #include "TransformationMatrix.h"
39 #include "TransformOperations.h"
40 #include <wtf/OwnPtr.h>
41 #include <wtf/PassOwnPtr.h>
42
43 #if PLATFORM(MAC)
44 #ifdef __OBJC__
45 @class WebLayer;
46 @class CALayer;
47 typedef CALayer PlatformLayer;
48 typedef CALayer* NativeLayer;
49 #else
50 typedef void* PlatformLayer;
51 typedef void* NativeLayer;
52 #endif
53 #elif PLATFORM(WIN)
54 namespace WebCore {
55 class WKCACFLayer;
56 typedef WKCACFLayer PlatformLayer;
57 typedef void* NativeLayer;
58 }
59 #elif PLATFORM(QT)
60 QT_BEGIN_NAMESPACE
61 class QGraphicsItem;
62 QT_END_NAMESPACE
63 typedef QGraphicsItem PlatformLayer;
64 typedef QGraphicsItem* NativeLayer;
65 #elif PLATFORM(CHROMIUM)
66 namespace WebCore {
67 class LayerChromium;
68 typedef LayerChromium PlatformLayer;
69 typedef void* NativeLayer;
70 }
71 #else
72 typedef void* PlatformLayer;
73 typedef void* NativeLayer;
74 #endif
75
76 enum LayerTreeAsTextBehaviorFlags {
77     LayerTreeAsTextBehaviorNormal = 0,
78     LayerTreeAsTextDebug = 1 << 0, // Dump extra debugging info like layer addresses.
79 };
80 typedef unsigned LayerTreeAsTextBehavior;
81
82 namespace WebCore {
83
84 class FloatPoint3D;
85 class GraphicsContext;
86 class Image;
87 class TextStream;
88 class TimingFunction;
89
90 // Base class for animation values (also used for transitions). Here to
91 // represent values for properties being animated via the GraphicsLayer,
92 // without pulling in style-related data from outside of the platform directory.
93 class AnimationValue : public Noncopyable {
94 public:
95     AnimationValue(float keyTime, PassRefPtr<TimingFunction> timingFunction = 0)
96         : m_keyTime(keyTime)
97     {
98         if (timingFunction)
99             m_timingFunction = timingFunction;
100     }
101     
102     virtual ~AnimationValue() { }
103
104     float keyTime() const { return m_keyTime; }
105     const TimingFunction* timingFunction() const { return m_timingFunction.get(); }
106
107 private:
108     float m_keyTime;
109     RefPtr<TimingFunction> m_timingFunction;
110 };
111
112 // Used to store one float value of an animation.
113 class FloatAnimationValue : public AnimationValue {
114 public:
115     FloatAnimationValue(float keyTime, float value, PassRefPtr<TimingFunction> timingFunction = 0)
116         : AnimationValue(keyTime, timingFunction)
117         , m_value(value)
118     {
119     }
120
121     float value() const { return m_value; }
122
123 private:
124     float m_value;
125 };
126
127 // Used to store one transform value in a keyframe list.
128 class TransformAnimationValue : public AnimationValue {
129 public:
130     TransformAnimationValue(float keyTime, const TransformOperations* value = 0, PassRefPtr<TimingFunction> timingFunction = 0)
131         : AnimationValue(keyTime, timingFunction)
132     {
133         if (value)
134             m_value = adoptPtr(new TransformOperations(*value));
135     }
136
137     const TransformOperations* value() const { return m_value.get(); }
138
139 private:
140     OwnPtr<TransformOperations> m_value;
141 };
142
143 // Used to store a series of values in a keyframe list. Values will all be of the same type,
144 // which can be inferred from the property.
145 class KeyframeValueList : public Noncopyable {
146 public:
147
148     KeyframeValueList(AnimatedPropertyID property)
149         : m_property(property)
150     {
151     }
152     
153     ~KeyframeValueList()
154     {
155         deleteAllValues(m_values);
156     }
157     
158     AnimatedPropertyID property() const { return m_property; }
159
160     size_t size() const { return m_values.size(); }
161     const AnimationValue* at(size_t i) const { return m_values.at(i); }
162     
163     // Insert, sorted by keyTime. Takes ownership of the pointer.
164     void insert(const AnimationValue*);
165     
166 protected:
167     Vector<const AnimationValue*> m_values;
168     AnimatedPropertyID m_property;
169 };
170
171
172
173 // GraphicsLayer is an abstraction for a rendering surface with backing store,
174 // which may have associated transformation and animations.
175
176 class GraphicsLayer {
177 public:
178
179     static PassOwnPtr<GraphicsLayer> create(GraphicsLayerClient*);
180     
181     virtual ~GraphicsLayer();
182
183     GraphicsLayerClient* client() const { return m_client; }
184
185     // Layer name. Only used to identify layers in debug output
186     const String& name() const { return m_name; }
187     virtual void setName(const String& name) { m_name = name; }
188
189     // For hosting this GraphicsLayer in a native layer hierarchy.
190     virtual NativeLayer nativeLayer() const { return 0; }
191
192     GraphicsLayer* parent() const { return m_parent; };
193     void setParent(GraphicsLayer* layer) { m_parent = layer; } // Internal use only.
194     
195     // Returns true if the layer has the given layer as an ancestor (excluding self).
196     bool hasAncestor(GraphicsLayer*) const;
197     
198     const Vector<GraphicsLayer*>& children() const { return m_children; }
199     // Returns true if the child list changed.
200     virtual bool setChildren(const Vector<GraphicsLayer*>&);
201
202     // Add child layers. If the child is already parented, it will be removed from its old parent.
203     virtual void addChild(GraphicsLayer*);
204     virtual void addChildAtIndex(GraphicsLayer*, int index);
205     virtual void addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling);
206     virtual void addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling);
207     virtual bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild);
208
209     void removeAllChildren();
210     virtual void removeFromParent();
211
212     GraphicsLayer* maskLayer() const { return m_maskLayer; }
213     virtual void setMaskLayer(GraphicsLayer* layer) { m_maskLayer = layer; }
214     
215     // The given layer will replicate this layer and its children; the replica renders behind this layer.
216     virtual void setReplicatedByLayer(GraphicsLayer*);
217     // Whether this layer is being replicated by another layer.
218     bool isReplicated() const { return m_replicaLayer; }
219     // The layer that replicates this layer (if any).
220     GraphicsLayer* replicaLayer() const { return m_replicaLayer; }
221
222     const FloatPoint& replicatedLayerPosition() const { return m_replicatedLayerPosition; }
223     void setReplicatedLayerPosition(const FloatPoint& p) { m_replicatedLayerPosition = p; }
224
225     // Offset is origin of the renderer minus origin of the graphics layer (so either zero or negative).
226     IntSize offsetFromRenderer() const { return m_offsetFromRenderer; }
227     void setOffsetFromRenderer(const IntSize& offset) { m_offsetFromRenderer = offset; }
228
229     // The position of the layer (the location of its top-left corner in its parent)
230     const FloatPoint& position() const { return m_position; }
231     virtual void setPosition(const FloatPoint& p) { m_position = p; }
232     
233     // Anchor point: (0, 0) is top left, (1, 1) is bottom right. The anchor point
234     // affects the origin of the transforms.
235     const FloatPoint3D& anchorPoint() const { return m_anchorPoint; }
236     virtual void setAnchorPoint(const FloatPoint3D& p) { m_anchorPoint = p; }
237
238     // The bounds of the layer
239     const FloatSize& size() const { return m_size; }
240     virtual void setSize(const FloatSize& size) { m_size = size; }
241
242     const TransformationMatrix& transform() const { return m_transform; }
243     virtual void setTransform(const TransformationMatrix& t) { m_transform = t; }
244
245     const TransformationMatrix& childrenTransform() const { return m_childrenTransform; }
246     virtual void setChildrenTransform(const TransformationMatrix& t) { m_childrenTransform = t; }
247
248     bool preserves3D() const { return m_preserves3D; }
249     virtual void setPreserves3D(bool b) { m_preserves3D = b; }
250     
251     bool masksToBounds() const { return m_masksToBounds; }
252     virtual void setMasksToBounds(bool b) { m_masksToBounds = b; }
253     
254     bool drawsContent() const { return m_drawsContent; }
255     virtual void setDrawsContent(bool b) { m_drawsContent = b; }
256
257     // The color used to paint the layer backgrounds
258     const Color& backgroundColor() const { return m_backgroundColor; }
259     virtual void setBackgroundColor(const Color&);
260     virtual void clearBackgroundColor();
261     bool backgroundColorSet() const { return m_backgroundColorSet; }
262
263     // opaque means that we know the layer contents have no alpha
264     bool contentsOpaque() const { return m_contentsOpaque; }
265     virtual void setContentsOpaque(bool b) { m_contentsOpaque = b; }
266
267     bool backfaceVisibility() const { return m_backfaceVisibility; }
268     virtual void setBackfaceVisibility(bool b) { m_backfaceVisibility = b; }
269
270     float opacity() const { return m_opacity; }
271     virtual void setOpacity(float opacity) { m_opacity = opacity; }
272
273     // Some GraphicsLayers paint only the foreground or the background content
274     GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; }
275     void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
276
277     virtual void setNeedsDisplay() = 0;
278     // mark the given rect (in layer coords) as needing dispay. Never goes deep.
279     virtual void setNeedsDisplayInRect(const FloatRect&) = 0;
280     
281     virtual void setContentsNeedsDisplay() { };
282
283     // Set that the position/size of the contents (image or video).
284     IntRect contentsRect() const { return m_contentsRect; }
285     virtual void setContentsRect(const IntRect& r) { m_contentsRect = r; }
286     
287     // Return true if the animation is handled by the compositing system. If this returns
288     // false, the animation will be run by AnimationController.
289     virtual bool addAnimation(const KeyframeValueList&, const IntSize& /*boxSize*/, const Animation*, const String& /*keyframesName*/, double /*timeOffset*/) { return false; }
290     virtual void removeAnimationsForProperty(AnimatedPropertyID) { }
291     virtual void removeAnimationsForKeyframes(const String& /* keyframesName */) { }
292     virtual void pauseAnimation(const String& /* keyframesName */, double /*timeOffset*/) { }
293     
294     virtual void suspendAnimations(double time);
295     virtual void resumeAnimations();
296     
297     // Layer contents
298     virtual void setContentsToImage(Image*) { }
299     virtual void setContentsToMedia(PlatformLayer*) { } // video or plug-in
300     virtual void setContentsBackgroundColor(const Color&) { }
301     virtual void setContentsToCanvas(PlatformLayer*) { }
302     virtual bool hasContentsLayer() const { return false; }
303
304     // Callback from the underlying graphics system to draw layer contents.
305     void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip);
306     // Callback from the underlying graphics system when the layer has been displayed
307     virtual void didDisplay(PlatformLayer*) { }
308     
309     virtual PlatformLayer* platformLayer() const { return 0; }
310     
311     void dumpLayer(TextStream&, int indent = 0, LayerTreeAsTextBehavior = LayerTreeAsTextBehaviorNormal) const;
312
313     int repaintCount() const { return m_repaintCount; }
314     int incrementRepaintCount() { return ++m_repaintCount; }
315
316     // Report whether the underlying compositing system uses a top-down
317     // or a bottom-up coordinate system.
318     enum CompositingCoordinatesOrientation { CompositingCoordinatesTopDown, CompositingCoordinatesBottomUp };
319     static CompositingCoordinatesOrientation compositingCoordinatesOrientation();
320
321     // Set the geometry orientation (top-down, or bottom-up) for this layer, which also controls sublayer geometry.
322     virtual void setGeometryOrientation(CompositingCoordinatesOrientation orientation) { m_geometryOrientation = orientation; }
323     CompositingCoordinatesOrientation geometryOrientation() const { return m_geometryOrientation; }
324
325     // Flippedness of the contents of this layer. Does not affect sublayer geometry.
326     virtual void setContentsOrientation(CompositingCoordinatesOrientation orientation) { m_contentsOrientation = orientation; }
327     CompositingCoordinatesOrientation contentsOrientation() const { return m_contentsOrientation; }
328
329     bool showDebugBorders() { return m_client ? m_client->showDebugBorders() : false; }
330     bool showRepaintCounter() { return m_client ? m_client->showRepaintCounter() : false; }
331     
332     void updateDebugIndicators();
333     
334     virtual void setDebugBackgroundColor(const Color&) { }
335     virtual void setDebugBorder(const Color&, float /*borderWidth*/) { }
336     // z-position is the z-equivalent of position(). It's only used for debugging purposes.
337     virtual float zPosition() const { return m_zPosition; }
338     virtual void setZPosition(float);
339
340     virtual void distributeOpacity(float);
341     virtual float accumulatedOpacity() const;
342
343     // Some compositing systems may do internal batching to synchronize compositing updates
344     // with updates drawn into the window. These methods flush internal batched state on this layer
345     // and descendant layers, and this layer only.
346     virtual void syncCompositingState() { }
347     virtual void syncCompositingStateForThisLayerOnly() { }
348     
349     // Return a string with a human readable form of the layer tree, If debug is true 
350     // pointers for the layers and timing data will be included in the returned string.
351     String layerTreeAsText(LayerTreeAsTextBehavior = LayerTreeAsTextBehaviorNormal) const;
352
353     bool usingTiledLayer() const { return m_usingTiledLayer; }
354
355 protected:
356
357     typedef Vector<TransformOperation::OperationType> TransformOperationList;
358     // Given a list of TransformAnimationValues, return an array of transform operations.
359     // On return, if hasBigRotation is true, functions contain rotations of >= 180 degrees
360     static void fetchTransformOperationList(const KeyframeValueList&, TransformOperationList&, bool& isValid, bool& hasBigRotation);
361
362     virtual void setOpacityInternal(float) { }
363     
364     // The layer being replicated.
365     GraphicsLayer* replicatedLayer() const { return m_replicatedLayer; }
366     virtual void setReplicatedLayer(GraphicsLayer* layer) { m_replicatedLayer = layer; }
367
368     GraphicsLayer(GraphicsLayerClient*);
369
370     void dumpProperties(TextStream&, int indent, LayerTreeAsTextBehavior) const;
371
372     GraphicsLayerClient* m_client;
373     String m_name;
374     
375     // Offset from the owning renderer
376     IntSize m_offsetFromRenderer;
377     
378     // Position is relative to the parent GraphicsLayer
379     FloatPoint m_position;
380     FloatPoint3D m_anchorPoint;
381     FloatSize m_size;
382     TransformationMatrix m_transform;
383     TransformationMatrix m_childrenTransform;
384
385     Color m_backgroundColor;
386     float m_opacity;
387     float m_zPosition;
388
389     bool m_backgroundColorSet : 1;
390     bool m_contentsOpaque : 1;
391     bool m_preserves3D: 1;
392     bool m_backfaceVisibility : 1;
393     bool m_usingTiledLayer : 1;
394     bool m_masksToBounds : 1;
395     bool m_drawsContent : 1;
396
397     GraphicsLayerPaintingPhase m_paintingPhase;
398     CompositingCoordinatesOrientation m_geometryOrientation;    // affects geometry of layer positions
399     CompositingCoordinatesOrientation m_contentsOrientation;    // affects orientation of layer contents
400
401     Vector<GraphicsLayer*> m_children;
402     GraphicsLayer* m_parent;
403
404     GraphicsLayer* m_maskLayer; // Reference to mask layer. We don't own this.
405
406     GraphicsLayer* m_replicaLayer; // A layer that replicates this layer. We only allow one, for now.
407                                    // The replica is not parented; this is the primary reference to it.
408     GraphicsLayer* m_replicatedLayer; // For a replica layer, a reference to the original layer.
409     FloatPoint m_replicatedLayerPosition; // For a replica layer, the position of the replica.
410
411     IntRect m_contentsRect;
412
413     int m_repaintCount;
414 };
415
416
417 } // namespace WebCore
418
419 #ifndef NDEBUG
420 // Outside the WebCore namespace for ease of invocation from gdb.
421 void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer);
422 #endif
423
424 #endif // USE(ACCELERATED_COMPOSITING)
425
426 #endif // GraphicsLayer_h
427