| 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)
|
|
|