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