Index: Source/WebCore/platform/graphics/clutter/GraphicsLayerActor.cpp |
diff --git a/Source/WebCore/platform/graphics/clutter/GraphicsLayerActor.cpp b/Source/WebCore/platform/graphics/clutter/GraphicsLayerActor.cpp |
deleted file mode 100644 |
index e7203c5c3302401fb1c0c20ddfb2dc3499e5144d..0000000000000000000000000000000000000000 |
--- a/Source/WebCore/platform/graphics/clutter/GraphicsLayerActor.cpp |
+++ /dev/null |
@@ -1,531 +0,0 @@ |
-/* |
- * Copyright 2011, 2012, 2013 Collabora Limited |
- * Copyright (C) 2012 Intel Corporation. All rights reserved. |
- * |
- * This program is free software; you can redistribute it and/or modify it |
- * under the terms and conditions of the GNU Lesser General Public License, |
- * version 2.1, as published by the Free Software Foundation. |
- * |
- * This program is distributed in the hope it will be useful, but WITHOUT ANY |
- * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
- * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for |
- * more details. |
- * |
- * You should have received a copy of the GNU Lesser General Public License |
- * along with this program; if not, write to the Free Software Foundation, |
- * Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. |
- * |
- */ |
- |
-#include "config.h" |
- |
-#if USE(ACCELERATED_COMPOSITING) |
- |
-#include "GraphicsLayerActor.h" |
- |
-#include "GraphicsContext.h" |
-#include "GraphicsLayerClutter.h" |
-#include "PlatformClutterLayerClient.h" |
-#include "PlatformContextCairo.h" |
-#include "RefPtrCairo.h" |
-#include "TransformationMatrix.h" |
-#include <wtf/text/CString.h> |
- |
-using namespace WebCore; |
- |
-G_DEFINE_TYPE(GraphicsLayerActor, graphics_layer_actor, CLUTTER_TYPE_ACTOR) |
- |
-#define GRAPHICS_LAYER_ACTOR_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), GRAPHICS_LAYER_TYPE_ACTOR, GraphicsLayerActorPrivate)) |
- |
-struct _GraphicsLayerActorPrivate { |
- GraphicsLayerClutter::LayerType layerType; |
- gboolean allocating; |
- |
- RefPtr<cairo_surface_t> surface; |
- |
- PlatformClutterLayerClient* layerClient; |
- |
- bool flatten; |
- bool drawsContent; |
- |
- float scrollX; |
- float scrollY; |
- |
- float translateX; |
- float translateY; |
-}; |
- |
-enum { |
- Property0, |
- |
- PropertyTranslateX, |
- PropertyTranslateY, |
- |
- PropertyLast |
-}; |
- |
-static void graphicsLayerActorAllocate(ClutterActor*, const ClutterActorBox*, ClutterAllocationFlags); |
-static void graphicsLayerActorApplyTransform(ClutterActor*, CoglMatrix*); |
-static void graphicsLayerActorDispose(GObject*); |
-static void graphicsLayerActorGetProperty(GObject*, guint propID, GValue*, GParamSpec*); |
-static void graphicsLayerActorSetProperty(GObject*, guint propID, const GValue*, GParamSpec*); |
-static void graphicsLayerActorPaint(ClutterActor*); |
- |
-static void graphicsLayerActorAdded(ClutterContainer*, ClutterActor*, gpointer data); |
-static void graphicsLayerActorRemoved(ClutterContainer*, ClutterActor*, gpointer data); |
-static gboolean graphicsLayerActorDraw(ClutterCanvas*, cairo_t*, gint width, gint height, GraphicsLayerActor*); |
-static void graphicsLayerActorUpdateTexture(GraphicsLayerActor*); |
-static void drawLayerContents(ClutterActor*, GraphicsContext&); |
- |
-static void graphics_layer_actor_class_init(GraphicsLayerActorClass* klass) |
-{ |
- GObjectClass* objectClass = G_OBJECT_CLASS(klass); |
- ClutterActorClass* actorClass = CLUTTER_ACTOR_CLASS(klass); |
- |
- objectClass->get_property = graphicsLayerActorGetProperty; |
- objectClass->set_property = graphicsLayerActorSetProperty; |
- objectClass->dispose = graphicsLayerActorDispose; |
- actorClass->apply_transform = graphicsLayerActorApplyTransform; |
- actorClass->allocate = graphicsLayerActorAllocate; |
- actorClass->paint = graphicsLayerActorPaint; |
- |
- g_type_class_add_private(klass, sizeof(GraphicsLayerActorPrivate)); |
- |
- GParamSpec* pspec = g_param_spec_float("translate-x", "Translate X", "Translation value for the X axis", -G_MAXFLOAT, G_MAXFLOAT, 0.0, static_cast<GParamFlags>(G_PARAM_READWRITE)); |
- g_object_class_install_property(objectClass, PropertyTranslateX, pspec); |
- |
- pspec = g_param_spec_float("translate-y", "Translate Y", "Translation value for the Y ayis", -G_MAXFLOAT, G_MAXFLOAT, 0.0, static_cast<GParamFlags>(G_PARAM_READWRITE)); |
- g_object_class_install_property(objectClass, PropertyTranslateY, pspec); |
-} |
- |
-static void graphics_layer_actor_init(GraphicsLayerActor* self) |
-{ |
- self->priv = GRAPHICS_LAYER_ACTOR_GET_PRIVATE(self); |
- |
- clutter_actor_set_reactive(CLUTTER_ACTOR(self), FALSE); |
- |
- self->priv->flatten = true; |
- |
- // Default used by GraphicsLayer. |
- graphicsLayerActorSetAnchorPoint(self, 0.5, 0.5, 0.0); |
- |
- g_signal_connect(self, "actor-added", G_CALLBACK(graphicsLayerActorAdded), 0); |
- g_signal_connect(self, "actor-removed", G_CALLBACK(graphicsLayerActorRemoved), 0); |
-} |
- |
-static void graphicsLayerActorSetProperty(GObject* object, guint propID, const GValue* value, GParamSpec* pspec) |
-{ |
- GraphicsLayerActor* layer = GRAPHICS_LAYER_ACTOR(object); |
- |
- switch (propID) { |
- case PropertyTranslateX: |
- graphicsLayerActorSetTranslateX(layer, g_value_get_float(value)); |
- break; |
- case PropertyTranslateY: |
- graphicsLayerActorSetTranslateY(layer, g_value_get_float(value)); |
- break; |
- default: |
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, pspec); |
- } |
-} |
- |
-static void graphicsLayerActorGetProperty(GObject* object, guint propID, GValue* value, GParamSpec* pspec) |
-{ |
- GraphicsLayerActor* layer = GRAPHICS_LAYER_ACTOR(object); |
- |
- switch (propID) { |
- case PropertyTranslateX: |
- g_value_set_float(value, graphicsLayerActorGetTranslateX(layer)); |
- break; |
- case PropertyTranslateY: |
- g_value_set_float(value, graphicsLayerActorGetTranslateY(layer)); |
- break; |
- default: |
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, pspec); |
- } |
-} |
- |
- |
-static void graphicsLayerActorDispose(GObject* object) |
-{ |
- GraphicsLayerActor* layer = GRAPHICS_LAYER_ACTOR(object); |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- |
- priv->surface.clear(); |
- |
- G_OBJECT_CLASS(graphics_layer_actor_parent_class)->dispose(object); |
-} |
- |
-// Copied from cairo. |
-#define MAX_IMAGE_SIZE 32767 |
- |
-static void graphicsLayerActorAllocate(ClutterActor* self, const ClutterActorBox* box, ClutterAllocationFlags flags) |
-{ |
- GraphicsLayerActor* layer = GRAPHICS_LAYER_ACTOR(self); |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- |
- priv->allocating = TRUE; |
- |
- CLUTTER_ACTOR_CLASS(graphics_layer_actor_parent_class)->allocate(self, box, flags); |
- |
- ClutterContent* canvas = clutter_actor_get_content(self); |
- if (canvas) |
- clutter_canvas_set_size(CLUTTER_CANVAS(canvas), clutter_actor_get_width(self), clutter_actor_get_height(self)); |
- |
- // FIXME: maybe we can cache children allocation and not call |
- // allocate on them this often? |
- for (GList* list = layer->children; list; list = list->next) { |
- ClutterActor* child = CLUTTER_ACTOR(list->data); |
- |
- float childWidth = clutter_actor_get_width(child); |
- float childHeight = clutter_actor_get_height(child); |
- |
- ClutterActorBox childBox; |
- childBox.x1 = clutter_actor_get_x(child); |
- childBox.y1 = clutter_actor_get_y(child); |
- childBox.x2 = childBox.x1 + childWidth; |
- childBox.y2 = childBox.y1 + childHeight; |
- |
- clutter_actor_allocate(child, &childBox, flags); |
- } |
- |
- priv->allocating = FALSE; |
-} |
- |
-static void graphicsLayerActorApplyTransform(ClutterActor* actor, CoglMatrix* matrix) |
-{ |
- GraphicsLayerActorPrivate* priv = GRAPHICS_LAYER_ACTOR(actor)->priv; |
- |
- // Apply translation and scrolling as a single translation. These |
- // need to come before anything else, otherwise they'll be |
- // affected by other operations such as scaling, which is not what |
- // we want. |
- float translateX = priv->scrollX + priv->translateX; |
- float translateY = priv->scrollY + priv->translateY; |
- |
- if (translateX || translateY) |
- cogl_matrix_translate(matrix, translateX, translateY, 0); |
- |
- CoglMatrix modelViewTransform = TransformationMatrix(); |
- CLUTTER_ACTOR_CLASS(graphics_layer_actor_parent_class)->apply_transform(actor, &modelViewTransform); |
- |
- if (priv->flatten) |
- modelViewTransform = TransformationMatrix(&modelViewTransform).to2dTransform(); |
- cogl_matrix_multiply(matrix, matrix, &modelViewTransform); |
-} |
- |
-static void graphicsLayerActorPaint(ClutterActor* actor) |
-{ |
- GraphicsLayerActor* graphicsLayer = GRAPHICS_LAYER_ACTOR(actor); |
- |
- for (GList* list = graphicsLayer->children; list; list = list->next) { |
- ClutterActor* child = CLUTTER_ACTOR(list->data); |
- clutter_actor_paint(child); |
- } |
-} |
- |
-static gboolean graphicsLayerActorDraw(ClutterCanvas* texture, cairo_t* cr, gint width, gint height, GraphicsLayerActor* layer) |
-{ |
- if (!width || !height) |
- return FALSE; |
- |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- GraphicsContext context(cr); |
- context.clearRect(FloatRect(0, 0, width, height)); |
- |
- if (priv->surface) { |
- gint surfaceWidth = cairo_image_surface_get_width(priv->surface.get()); |
- gint surfaceHeight = cairo_image_surface_get_height(priv->surface.get()); |
- |
- FloatRect srcRect(0.0, 0.0, static_cast<float>(surfaceWidth), static_cast<float>(surfaceHeight)); |
- FloatRect destRect(0.0, 0.0, width, height); |
- context.platformContext()->drawSurfaceToContext(priv->surface.get(), destRect, srcRect, &context); |
- } |
- |
- if (priv->layerType == GraphicsLayerClutter::LayerTypeWebLayer) |
- drawLayerContents(CLUTTER_ACTOR(layer), context); |
- |
- return TRUE; |
-} |
- |
-static void graphicsLayerActorAdded(ClutterContainer* container, ClutterActor* actor, gpointer data) |
-{ |
- GraphicsLayerActor* graphicsLayer = GRAPHICS_LAYER_ACTOR(container); |
- graphicsLayer->children = g_list_append(graphicsLayer->children, actor); |
-} |
- |
-static void graphicsLayerActorRemoved(ClutterContainer* container, ClutterActor* actor, gpointer data) |
-{ |
- GraphicsLayerActor* graphicsLayer = GRAPHICS_LAYER_ACTOR(container); |
- graphicsLayer->children = g_list_remove(graphicsLayer->children, actor); |
-} |
- |
-static void graphicsLayerActorUpdateTexture(GraphicsLayerActor* layer) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- ASSERT(priv->layerType != GraphicsLayerClutter::LayerTypeVideoLayer); |
- |
- ClutterActor* actor = CLUTTER_ACTOR(layer); |
- ClutterContent* canvas = clutter_actor_get_content(actor); |
- if (canvas) { |
- // Nothing needs a texture, remove the one we have, if any. |
- if (!priv->drawsContent && !priv->surface) { |
- g_signal_handlers_disconnect_by_func(canvas, reinterpret_cast<void*>(graphicsLayerActorDraw), layer); |
- g_object_unref(canvas); |
- } |
- return; |
- } |
- |
- // We should have a texture, so create one. |
- int width = ceilf(clutter_actor_get_width(actor)); |
- int height = ceilf(clutter_actor_get_height(actor)); |
- |
- canvas = clutter_canvas_new(); |
- clutter_actor_set_content(actor, canvas); |
- clutter_canvas_set_size(CLUTTER_CANVAS(canvas), width > 0 ? width : 1, height > 0 ? height : 1); |
- g_object_unref(canvas); |
- |
- g_signal_connect(canvas, "draw", G_CALLBACK(graphicsLayerActorDraw), layer); |
-} |
- |
-// Draw content into the layer. |
-static void drawLayerContents(ClutterActor* actor, GraphicsContext& context) |
-{ |
- GraphicsLayerActorPrivate* priv = GRAPHICS_LAYER_ACTOR(actor)->priv; |
- |
- if (!priv->drawsContent || !priv->layerClient) |
- return; |
- |
- int width = static_cast<int>(clutter_actor_get_width(actor)); |
- int height = static_cast<int>(clutter_actor_get_height(actor)); |
- IntRect clip(0, 0, width, height); |
- |
- // Apply the painted content to the layer. |
- priv->layerClient->platformClutterLayerPaintContents(context, clip); |
-} |
- |
- |
-GraphicsLayerActor* graphicsLayerActorNew(GraphicsLayerClutter::LayerType type) |
-{ |
- GraphicsLayerActor* layer = GRAPHICS_LAYER_ACTOR(g_object_new(GRAPHICS_LAYER_TYPE_ACTOR, 0)); |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- |
- priv->layerType = type; |
- if (priv->layerType == GraphicsLayerClutter::LayerTypeTransformLayer) |
- priv->flatten = false; |
- |
- return layer; |
-} |
- |
-GraphicsLayerActor* graphicsLayerActorNewWithClient(GraphicsLayerClutter::LayerType type, PlatformClutterLayerClient* layerClient) |
-{ |
- GraphicsLayerActor* layer = graphicsLayerActorNew(type); |
- graphicsLayerActorSetClient(layer, layerClient); |
- |
- return layer; |
-} |
- |
-void graphicsLayerActorSetClient(GraphicsLayerActor* layer, PlatformClutterLayerClient* client) |
-{ |
- layer->priv->layerClient = client; |
-} |
- |
-PlatformClutterLayerClient* graphicsLayerActorGetClient(GraphicsLayerActor* layer) |
-{ |
- return layer->priv->layerClient; |
-} |
- |
-void graphicsLayerActorRemoveAll(GraphicsLayerActor* layer) |
-{ |
- g_return_if_fail(GRAPHICS_LAYER_IS_ACTOR(layer)); |
- |
- GList* children = clutter_actor_get_children(CLUTTER_ACTOR(layer)); |
- for (; children; children = children->next) |
- clutter_actor_remove_child(CLUTTER_ACTOR(layer), CLUTTER_ACTOR(children->data)); |
-} |
- |
-cairo_surface_t* graphicsLayerActorGetSurface(GraphicsLayerActor* layer) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- ASSERT(priv->surface); |
- return priv->surface.get(); |
-} |
- |
-void graphicsLayerActorSetSurface(GraphicsLayerActor* layer, cairo_surface_t* surface) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- priv->surface = surface; |
- graphicsLayerActorUpdateTexture(layer); |
-} |
- |
-void graphicsLayerActorInvalidateRectangle(GraphicsLayerActor* layer, const FloatRect& dirtyRect) |
-{ |
- ClutterContent* canvas = clutter_actor_get_content(CLUTTER_ACTOR(layer)); |
- if (!canvas) |
- return; |
- |
- // FIXME: Need to invalidate a specific area? |
- clutter_content_invalidate(canvas); |
-} |
- |
-void graphicsLayerActorSetAnchorPoint(GraphicsLayerActor* layer, float x, float y, float z) |
-{ |
- ClutterActor* actor = CLUTTER_ACTOR(layer); |
- clutter_actor_set_pivot_point(actor, x, y); |
- clutter_actor_set_pivot_point_z(actor, z); |
-} |
- |
-void graphicsLayerActorGetAnchorPoint(GraphicsLayerActor* layer, float* x, float* y, float* z) |
-{ |
- ASSERT(x && y); |
- |
- ClutterActor* actor = CLUTTER_ACTOR(layer); |
- clutter_actor_get_pivot_point(actor, x, y); |
- if (z) |
- *z = clutter_actor_get_pivot_point_z(actor); |
-} |
- |
-void graphicsLayerActorSetScrollPosition(GraphicsLayerActor* layer, float x, float y) |
-{ |
- if (x > 0 || y > 0) |
- return; |
- |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- priv->scrollX = x; |
- priv->scrollY = y; |
- |
- clutter_actor_queue_redraw(CLUTTER_ACTOR(layer)); |
-} |
- |
-gint graphicsLayerActorGetnChildren(GraphicsLayerActor* layer) |
-{ |
- ASSERT(GRAPHICS_LAYER_IS_ACTOR(layer)); |
- |
- return g_list_length(layer->children); |
-} |
- |
-void graphicsLayerActorReplaceSublayer(GraphicsLayerActor* layer, ClutterActor* oldChildLayer, ClutterActor* newChildLayer) |
-{ |
- ASSERT(GRAPHICS_LAYER_IS_ACTOR(layer)); |
- ASSERT(CLUTTER_IS_ACTOR(oldChildLayer)); |
- ASSERT(CLUTTER_IS_ACTOR(newChildLayer)); |
- |
- clutter_actor_remove_child(CLUTTER_ACTOR(layer), oldChildLayer); |
- clutter_actor_add_child(CLUTTER_ACTOR(layer), newChildLayer); |
-} |
- |
-void graphicsLayerActorInsertSublayer(GraphicsLayerActor* layer, ClutterActor* childLayer, gint index) |
-{ |
- ASSERT(GRAPHICS_LAYER_IS_ACTOR(layer)); |
- ASSERT(CLUTTER_IS_ACTOR(childLayer)); |
- |
- g_object_ref(childLayer); |
- |
- layer->children = g_list_insert(layer->children, childLayer, index); |
- ASSERT(!clutter_actor_get_parent(childLayer)); |
- clutter_actor_add_child(CLUTTER_ACTOR(layer), childLayer); |
- clutter_actor_queue_relayout(CLUTTER_ACTOR(layer)); |
- |
- g_object_unref(childLayer); |
-} |
- |
-void graphicsLayerActorSetSublayers(GraphicsLayerActor* layer, GraphicsLayerActorList& subLayers) |
-{ |
- if (!subLayers.size()) { |
- graphicsLayerActorRemoveAll(layer); |
- return; |
- } |
- |
- ClutterActor* newParentActor = CLUTTER_ACTOR(layer); |
- for (size_t i = 0; i < subLayers.size(); ++i) { |
- ClutterActor* childActor = CLUTTER_ACTOR(subLayers[i].get()); |
- ClutterActor* oldParentActor = clutter_actor_get_parent(childActor); |
- if (oldParentActor) { |
- if (oldParentActor == newParentActor) |
- continue; |
- clutter_actor_remove_child(oldParentActor, childActor); |
- } |
- clutter_actor_add_child(newParentActor, childActor); |
- } |
-} |
- |
-void graphicsLayerActorRemoveFromSuperLayer(GraphicsLayerActor* layer) |
-{ |
- ClutterActor* actor = CLUTTER_ACTOR(layer); |
- ClutterActor* parentActor = clutter_actor_get_parent(actor); |
- if (!parentActor) |
- return; |
- |
- clutter_actor_remove_child(parentActor, actor); |
-} |
- |
-GraphicsLayerClutter::LayerType graphicsLayerActorGetLayerType(GraphicsLayerActor* layer) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- return priv->layerType; |
-} |
- |
-void graphicsLayerActorSetLayerType(GraphicsLayerActor* layer, GraphicsLayerClutter::LayerType layerType) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- priv->layerType = layerType; |
-} |
- |
-void graphicsLayerActorSetTranslateX(GraphicsLayerActor* layer, float value) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- priv->translateX = value; |
- clutter_actor_queue_redraw(CLUTTER_ACTOR(layer)); |
-} |
- |
-float graphicsLayerActorGetTranslateX(GraphicsLayerActor* layer) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- return priv->translateX; |
-} |
- |
-void graphicsLayerActorSetTranslateY(GraphicsLayerActor* layer, float value) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- priv->translateY = value; |
- clutter_actor_queue_redraw(CLUTTER_ACTOR(layer)); |
-} |
- |
-float graphicsLayerActorGetTranslateY(GraphicsLayerActor* layer) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- return priv->translateY; |
-} |
- |
-void graphicsLayerActorSetDrawsContent(GraphicsLayerActor* layer, bool drawsContent) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- |
- if (drawsContent == priv->drawsContent) |
- return; |
- |
- priv->drawsContent = drawsContent; |
- |
- graphicsLayerActorUpdateTexture(layer); |
-} |
- |
-gboolean graphicsLayerActorGetDrawsContent(GraphicsLayerActor* layer) |
-{ |
- return layer->priv->drawsContent; |
-} |
- |
-void graphicsLayerActorSetFlatten(GraphicsLayerActor* layer, bool flatten) |
-{ |
- GraphicsLayerActorPrivate* priv = layer->priv; |
- if (flatten == priv->flatten) |
- return; |
- |
- priv->flatten = flatten; |
-} |
- |
-WebCore::PlatformClutterAnimation* graphicsLayerActorGetAnimationForKey(GraphicsLayerActor* layer, const String key) |
-{ |
- return static_cast<WebCore::PlatformClutterAnimation*>(g_object_get_data(G_OBJECT(layer), key.utf8().data())); |
-} |
- |
-#endif // USE(ACCELERATED_COMPOSITING) |