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