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