#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 "TransformationMatrix.h"
#include "TransformOperations.h"
#include <wtf/OwnPtr.h>
#if PLATFORM(MAC)
#ifdef __OBJC__
@class WebLayer;
@class CALayer;
typedef WebLayer 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 GraphicsLayer {
public:
class FloatValue {
public:
FloatValue(float key, float value, const TimingFunction* timingFunction = 0)
: m_key(key), m_value(value), m_timingFunction(0)
{
if (timingFunction)
m_timingFunction.set(new TimingFunction(*timingFunction));
}
FloatValue(const FloatValue& other)
: m_key(other.key()), m_value(other.value()), m_timingFunction(0)
{
if (other.timingFunction())
m_timingFunction.set(new TimingFunction(*other.timingFunction()));
}
const FloatValue& operator=(const FloatValue& other)
{
if (&other != this)
set(other.key(), other.value(), other.timingFunction());
return *this;
}
void set(float key, float value, const TimingFunction*);
float key() const { return m_key; }
float value() const { return m_value; }
const TimingFunction* timingFunction() const { return m_timingFunction.get(); }
private:
float m_key;
float m_value;
OwnPtr<TimingFunction> m_timingFunction;
};
class FloatValueList {
public:
void insert(float key, float value, const TimingFunction* timingFunction);
size_t size() const { return m_values.size(); }
const FloatValue& at(size_t i) const { return m_values.at(i); }
const Vector<FloatValue>& values() const { return m_values; }
private:
Vector<FloatValue> m_values;
};
class TransformValue {
public:
TransformValue(float key = NAN, const TransformOperations* value = 0, const TimingFunction* timingFunction = 0)
: m_key(key)
{
if (value)
m_value.set(new TransformOperations(*value));
if (timingFunction)
m_timingFunction.set(new TimingFunction(*timingFunction));
}
TransformValue(const TransformValue& other)
: m_key(other.key())
{
if (other.value())
m_value.set(new TransformOperations(*other.value()));
if (other.timingFunction())
m_timingFunction.set(new TimingFunction(*other.timingFunction()));
}
const TransformValue& operator=(const TransformValue& other)
{
if (&other != this)
set(other.key(), other.value(), other.timingFunction());
return *this;
}
void set(float key, const TransformOperations* value, const TimingFunction* timingFunction);
float key() const { return m_key; }
const TransformOperations* value() const { return m_value.get(); }
const TimingFunction* timingFunction() const { return m_timingFunction.get(); }
private:
float m_key;
OwnPtr<TransformOperations> m_value;
OwnPtr<TimingFunction> m_timingFunction;
};
class TransformValueList {
public:
typedef Vector<TransformOperation::OperationType> FunctionList;
size_t size() const { return m_values.size(); }
const TransformValue& at(size_t i) const { return m_values.at(i); }
const Vector<TransformValue>& values() const { return m_values; }
void insert(float key, const TransformOperations* value, const TimingFunction* timingFunction);
void makeFunctionList(FunctionList& list, bool& isValid, bool& hasBigRotation) const;
private:
Vector<TransformValue> m_values;
};
static GraphicsLayer* createGraphicsLayer(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 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();
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&, const Animation* = 0, double beginTime = 0);
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 bool setOpacity(float o, const Animation* = 0, double beginTime = 0);
GraphicsLayerPaintingPhase drawingPhase() const { return m_paintingPhase; }
void setDrawingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
virtual void setNeedsDisplay() = 0;
virtual void setNeedsDisplayInRect(const FloatRect&) = 0;
virtual bool animateTransform(const TransformValueList&, const IntSize&, const Animation*, double beginTime, bool isTransition) = 0;
virtual bool animateFloat(AnimatedPropertyID, const FloatValueList&, const Animation*, double beginTime) = 0;
void removeFinishedAnimations(const String& name, int index, bool reset);
void removeFinishedTransitions(AnimatedPropertyID);
void removeAllAnimations();
virtual void suspendAnimations();
virtual void resumeAnimations();
virtual void setContentsToImage(Image*) { }
virtual void setContentsToVideo(PlatformLayer*) { }
virtual void setContentsBackgroundColor(const Color&) { }
virtual void clearContents() { }
virtual void updateContentsRect() { }
void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip);
virtual PlatformLayer* platformLayer() const { return 0; }
void dumpLayer(TextStream&, int indent = 0) const;
#ifndef NDEBUG
int repaintCount() const { return m_repaintCount; }
int incrementRepaintCount() { return ++m_repaintCount; }
#endif
enum CompositingCoordinatesOrientation { CompositingCoordinatesTopDown, CompositingCoordinatesBottomUp };
static CompositingCoordinatesOrientation compositingCoordinatesOrientation();
#ifndef NDEBUG
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);
#endif
static String propertyIdToString(AnimatedPropertyID);
protected:
GraphicsLayer(GraphicsLayerClient*);
void dumpProperties(TextStream&, int indent) const;
int findAnimationEntry(AnimatedPropertyID, short index) const;
void addAnimationEntry(AnimatedPropertyID, short index, bool isTransition, const Animation*);
virtual void removeAnimation(int , bool ) {}
void removeAllAnimationsForProperty(AnimatedPropertyID);
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;
#ifndef NDEBUG
float m_zPosition;
#endif
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;
Vector<GraphicsLayer*> m_children;
GraphicsLayer* m_parent;
class AnimationEntry {
public:
AnimationEntry(const Animation* animation, AnimatedPropertyID property, short index, bool isTransition)
: m_animation(const_cast<Animation*>(animation))
, m_property(property)
, m_index(index)
, m_isCurrent(true)
, m_isTransition(isTransition)
{
}
const Animation* animation() const { return m_animation.get(); }
AnimatedPropertyID property() const { return m_property; }
int index() const { return m_index; }
bool isCurrent() const { return m_isCurrent; }
void setIsCurrent(bool b = true) { m_isCurrent = b; }
bool isTransition() const { return m_isTransition; }
bool matches(AnimatedPropertyID property, short index) const
{
return m_property == property && m_index == index;
}
void reset(const Animation* animation, bool isTransition)
{
m_animation = const_cast<Animation*>(animation);
m_isTransition = isTransition;
m_isCurrent = true;
}
private:
RefPtr<Animation> m_animation;
AnimatedPropertyID m_property : 14;
short m_index : 16;
bool m_isCurrent : 1;
bool m_isTransition : 1;
};
Vector<AnimationEntry> m_animations;
#ifndef NDEBUG
int m_repaintCount;
#endif
};
}
#endif // USE(ACCELERATED_COMPOSITING)
#endif // GraphicsLayer_h