#ifndef GraphicsLayer_h
#define GraphicsLayer_h
#if USE(ACCELERATED_COMPOSITING)
#include "Animation.h"
#include "Color.h"
#include "FloatPoint.h"
#include "FloatPoint3D.h"
#include "FloatSize.h"
#include "GraphicsLayerClient.h"
#include "IntRect.h"
#include "TransformationMatrix.h"
#include "TransformOperations.h"
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#if PLATFORM(MAC)
#ifdef __OBJC__
@class WebLayer;
@class CALayer;
typedef CALayer PlatformLayer;
typedef CALayer* NativeLayer;
#else
typedef void* PlatformLayer;
typedef void* NativeLayer;
#endif
#else
typedef void* PlatformLayer;
typedef void* NativeLayer;
#endif
namespace WebCore {
class FloatPoint3D;
class GraphicsContext;
class Image;
class TextStream;
class TimingFunction;
class AnimationValue : public Noncopyable {
public:
AnimationValue(float keyTime, const TimingFunction* timingFunction = 0)
: m_keyTime(keyTime)
, m_timingFunction(0)
{
if (timingFunction)
m_timingFunction.set(new TimingFunction(*timingFunction));
}
virtual ~AnimationValue() { }
float keyTime() const { return m_keyTime; }
const TimingFunction* timingFunction() const { return m_timingFunction.get(); }
private:
float m_keyTime;
OwnPtr<TimingFunction> m_timingFunction;
};
class FloatAnimationValue : public AnimationValue {
public:
FloatAnimationValue(float keyTime, float value, const TimingFunction* timingFunction = 0)
: AnimationValue(keyTime, timingFunction)
, m_value(value)
{
}
float value() const { return m_value; }
private:
float m_value;
};
class TransformAnimationValue : public AnimationValue {
public:
TransformAnimationValue(float keyTime, const TransformOperations* value = 0, const TimingFunction* timingFunction = 0)
: AnimationValue(keyTime, timingFunction)
{
if (value)
m_value.set(new TransformOperations(*value));
}
const TransformOperations* value() const { return m_value.get(); }
private:
OwnPtr<TransformOperations> m_value;
};
class KeyframeValueList : public Noncopyable {
public:
KeyframeValueList(AnimatedPropertyID property)
: m_property(property)
{
}
~KeyframeValueList()
{
deleteAllValues(m_values);
}
AnimatedPropertyID property() const { return m_property; }
size_t size() const { return m_values.size(); }
const AnimationValue* at(size_t i) const { return m_values.at(i); }
void insert(const AnimationValue*);
protected:
Vector<const AnimationValue*> m_values;
AnimatedPropertyID m_property;
};
class GraphicsLayer {
public:
static PassOwnPtr<GraphicsLayer> create(GraphicsLayerClient*);
virtual ~GraphicsLayer();
GraphicsLayerClient* client() const { return m_client; }
const String& name() const { return m_name; }
virtual void setName(const String& name) { m_name = name; }
virtual NativeLayer nativeLayer() const { return 0; }
GraphicsLayer* parent() const { return m_parent; };
void setParent(GraphicsLayer* layer) { m_parent = layer; }
const Vector<GraphicsLayer*>& children() const { return m_children; }
virtual bool setChildren(const Vector<GraphicsLayer*>&);
virtual void addChild(GraphicsLayer*);
virtual void addChildAtIndex(GraphicsLayer*, int index);
virtual void addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling);
virtual void addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling);
virtual bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild);
void removeAllChildren();
virtual void removeFromParent();
GraphicsLayer* maskLayer() const { return m_maskLayer; }
virtual void setMaskLayer(GraphicsLayer* layer) { m_maskLayer = layer; }
IntSize offsetFromRenderer() const { return m_offsetFromRenderer; }
void setOffsetFromRenderer(const IntSize& offset) { m_offsetFromRenderer = offset; }
const FloatPoint& position() const { return m_position; }
virtual void setPosition(const FloatPoint& p) { m_position = p; }
const FloatPoint3D& anchorPoint() const { return m_anchorPoint; }
virtual void setAnchorPoint(const FloatPoint3D& p) { m_anchorPoint = p; }
const FloatSize& size() const { return m_size; }
virtual void setSize(const FloatSize& size) { m_size = size; }
const TransformationMatrix& transform() const { return m_transform; }
virtual void setTransform(const TransformationMatrix& t) { m_transform = t; }
const TransformationMatrix& childrenTransform() const { return m_childrenTransform; }
virtual void setChildrenTransform(const TransformationMatrix& t) { m_childrenTransform = t; }
bool preserves3D() const { return m_preserves3D; }
virtual void setPreserves3D(bool b) { m_preserves3D = b; }
bool masksToBounds() const { return m_masksToBounds; }
virtual void setMasksToBounds(bool b) { m_masksToBounds = b; }
bool drawsContent() const { return m_drawsContent; }
virtual void setDrawsContent(bool b) { m_drawsContent = b; }
const Color& backgroundColor() const { return m_backgroundColor; }
virtual void setBackgroundColor(const Color&);
virtual void clearBackgroundColor();
bool backgroundColorSet() const { return m_backgroundColorSet; }
bool contentsOpaque() const { return m_contentsOpaque; }
virtual void setContentsOpaque(bool b) { m_contentsOpaque = b; }
bool backfaceVisibility() const { return m_backfaceVisibility; }
virtual void setBackfaceVisibility(bool b) { m_backfaceVisibility = b; }
float opacity() const { return m_opacity; }
virtual void setOpacity(float opacity) { m_opacity = opacity; }
GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; }
void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
virtual void setNeedsDisplay() = 0;
virtual void setNeedsDisplayInRect(const FloatRect&) = 0;
IntRect contentsRect() const { return m_contentsRect; }
virtual void setContentsRect(const IntRect& r) { m_contentsRect = r; }
virtual bool addAnimation(const KeyframeValueList&, const IntSize& , const Animation*, const String& , double ) { return false; }
virtual void removeAnimationsForProperty(AnimatedPropertyID) { }
virtual void removeAnimationsForKeyframes(const String& ) { }
virtual void pauseAnimation(const String& , double ) { }
virtual void suspendAnimations(double time);
virtual void resumeAnimations();
virtual void setContentsToImage(Image*) { }
virtual void setContentsToMedia(PlatformLayer*) { } virtual PlatformLayer* contentsLayerForMedia() const { return 0; }
virtual void setContentsBackgroundColor(const Color&) { }
void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip);
virtual PlatformLayer* platformLayer() const { return 0; }
float contentsScale() const { return m_contentsScale; }
virtual void setContentsScale(float);
void dumpLayer(TextStream&, int indent = 0) const;
int repaintCount() const { return m_repaintCount; }
int incrementRepaintCount() { return ++m_repaintCount; }
enum CompositingCoordinatesOrientation { CompositingCoordinatesTopDown, CompositingCoordinatesBottomUp };
static CompositingCoordinatesOrientation compositingCoordinatesOrientation();
virtual void setGeometryOrientation(CompositingCoordinatesOrientation orientation) { m_geometryOrientation = orientation; }
CompositingCoordinatesOrientation geometryOrientation() const { return m_geometryOrientation; }
virtual void setContentsOrientation(CompositingCoordinatesOrientation orientation) { m_contentsOrientation = orientation; }
CompositingCoordinatesOrientation contentsOrientation() const { return m_contentsOrientation; }
static bool showDebugBorders();
static bool showRepaintCounter();
void updateDebugIndicators();
virtual void setDebugBackgroundColor(const Color&) { }
virtual void setDebugBorder(const Color&, float ) { }
virtual float zPosition() const { return m_zPosition; }
virtual void setZPosition(float);
virtual void distributeOpacity(float);
virtual float accumulatedOpacity() const;
virtual void syncCompositingState() { }
protected:
typedef Vector<TransformOperation::OperationType> TransformOperationList;
static void fetchTransformOperationList(const KeyframeValueList&, TransformOperationList&, bool& isValid, bool& hasBigRotation);
virtual void setOpacityInternal(float) { }
GraphicsLayer(GraphicsLayerClient*);
void dumpProperties(TextStream&, int indent) const;
float clampedContentsScaleForScale(float scale) const;
GraphicsLayerClient* m_client;
String m_name;
IntSize m_offsetFromRenderer;
FloatPoint m_position;
FloatPoint3D m_anchorPoint;
FloatSize m_size;
TransformationMatrix m_transform;
TransformationMatrix m_childrenTransform;
Color m_backgroundColor;
float m_opacity;
float m_zPosition;
float m_contentsScale;
bool m_backgroundColorSet : 1;
bool m_contentsOpaque : 1;
bool m_preserves3D: 1;
bool m_backfaceVisibility : 1;
bool m_usingTiledLayer : 1;
bool m_masksToBounds : 1;
bool m_drawsContent : 1;
GraphicsLayerPaintingPhase m_paintingPhase;
CompositingCoordinatesOrientation m_geometryOrientation; CompositingCoordinatesOrientation m_contentsOrientation;
Vector<GraphicsLayer*> m_children;
GraphicsLayer* m_parent;
GraphicsLayer* m_maskLayer;
IntRect m_contentsRect;
int m_repaintCount;
};
}
#endif // USE(ACCELERATED_COMPOSITING)
#endif // GraphicsLayer_h