sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/clutter/clutter-cairo-texture.c

1192 lines
35 KiB
C
Raw Normal View History

Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
/*
* Clutter
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
* Matthew Allum <mallum@o-hand.com>
* Chris Lord <chris@o-hand.com>
* Iain Holmes <iain@o-hand.com>
* Neil Roberts <neil@linux.intel.com>
*
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
* Copyright (C) 2008, 2009, 2010, 2011 Intel Corporation.
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that 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
Remove mentions of the FSF address Since using addresses that might change is something that finally the FSF acknowledge as a plausible scenario (after changing address twice), the license blurb in the source files should use the URI for getting the license in case the library did not come with it. Not that URIs cannot possibly change, but at least it's easier to set up a redirection at the same place. As a side note: this commit closes the oldes bug in Clutter's bug report tool. http://bugzilla.openedhand.com/show_bug.cgi?id=521
2010-03-01 12:56:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*/
/**
* SECTION:clutter-cairo-texture
* @short_description: Texture with Cairo integration
*
* #ClutterCairoTexture is a #ClutterTexture that displays the contents
* of a Cairo context. The #ClutterCairoTexture actor will create a
* Cairo image surface which will then be uploaded to a GL texture when
* needed.
*
* <note><para>Since #ClutterCairoTexture uses a Cairo image surface
* internally all the drawing operations will be performed in
* software and not using hardware acceleration. This can lead to
* performance degradation if the contents of the texture change
* frequently.</para></note>
*
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
* In order to use a #ClutterCairoTexture you should connect to the
* #ClutterCairoTexture::draw signal; the signal is emitted each time
* the #ClutterCairoTexture has been told to invalidate its contents,
* by using clutter_cairo_texture_invalidate_rectangle() or its
* sister function, clutter_cairo_texture_invalidate().
*
* Each callback to the #ClutterCairoTexture::draw signal will receive
* a #cairo_t context which can be used for drawing; the Cairo context
* is owned by the #ClutterCairoTexture and should not be destroyed
* explicitly.
*
* <example id="cairo-texture-example">
* <title>A simple ClutterCairoTexture canvas</title>
* <programlisting>
* <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../tests/interactive/test-cairo-clock.c">
* <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
* </xi:include>
* </programlisting>
* </example>
*
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
* #ClutterCairoTexture is available since Clutter 1.0.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
#include <math.h>
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
#include <cairo-gobject.h>
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
#include "clutter-cairo-texture.h"
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 11:16:05 +00:00
#include "clutter-actor-private.h"
Clean up the included headers Especially inside ClutterStage.
2012-02-23 17:21:57 +00:00
#include "clutter-color.h"
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
#include "clutter-debug.h"
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
#include "clutter-marshal.h"
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
#include "clutter-private.h"
Fix missing/redundant declarations
2012-03-07 12:34:06 +00:00
#include "deprecated/clutter-cairo-texture.h"
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
G_DEFINE_TYPE (ClutterCairoTexture,
clutter_cairo_texture,
CLUTTER_TYPE_TEXTURE);
enum
{
PROP_0,
PROP_SURFACE_WIDTH,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
PROP_SURFACE_HEIGHT,
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
PROP_AUTO_RESIZE,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
PROP_LAST
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
};
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
enum
{
CREATE_SURFACE,
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
DRAW,
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
LAST_SIGNAL
};
static GParamSpec *obj_props[PROP_LAST] = { NULL, };
static guint cairo_signals[LAST_SIGNAL] = { 0, };
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 09:20:32 +00:00
Print a warning when creating a cairo_t while painting If you create a Cairo context in the middle of a paint run and then you destroy it, the CairoTexture will have to upload the contents of the image surface to the GL pipeline. This usually leads to slow downs and general performance degradation. ClutterCairoTexture will warn to the console if Clutter has been compiled with the debug messages and if create() or create_region() are called while an actor is in the middle of a paint.
2008-12-11 15:48:43 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
Warn instead of returning in the IN_PAINT check It's conceivable that a warning should be deemed enough, instead of just returning a NULL cairo_t when creating a context for the CairoTexture actor.
2008-12-12 11:42:16 +00:00
#define clutter_warn_if_paint_fail(obj) G_STMT_START { \
Clean up the private flags for ClutterActor Provide macros to quickly query a flag, and remove all namespacing except the initial 'CLUTTER'.
2010-07-21 15:10:46 +00:00
if (CLUTTER_ACTOR_IN_PAINT (obj)) { \
Print a warning when creating a cairo_t while painting If you create a Cairo context in the middle of a paint run and then you destroy it, the CairoTexture will have to upload the contents of the image surface to the GL pipeline. This usually leads to slow downs and general performance degradation. ClutterCairoTexture will warn to the console if Clutter has been compiled with the debug messages and if create() or create_region() are called while an actor is in the middle of a paint.
2008-12-11 15:48:43 +00:00
g_warning ("%s should not be called during the paint sequence " \
"of a ClutterCairoTexture as it will likely cause " \
"performance issues.", G_STRFUNC); \
} } G_STMT_END
#else
Warn instead of returning in the IN_PAINT check It's conceivable that a warning should be deemed enough, instead of just returning a NULL cairo_t when creating a context for the CairoTexture actor.
2008-12-12 11:42:16 +00:00
#define clutter_warn_if_paint_fail(obj) /* void */
Print a warning when creating a cairo_t while painting If you create a Cairo context in the middle of a paint run and then you destroy it, the CairoTexture will have to upload the contents of the image surface to the GL pipeline. This usually leads to slow downs and general performance degradation. ClutterCairoTexture will warn to the console if Clutter has been compiled with the debug messages and if create() or create_region() are called while an actor is in the middle of a paint.
2008-12-11 15:48:43 +00:00
#endif /* CLUTTER_ENABLE_DEBUG */
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
#define CLUTTER_CAIRO_TEXTURE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_CAIRO_TEXTURE, ClutterCairoTexturePrivate))
struct _ClutterCairoTexturePrivate
{
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
cairo_surface_t *cr_surface;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
guint surface_width;
guint surface_height;
cairo_t *cr_context;
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
guint auto_resize : 1;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
};
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
typedef struct {
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
ClutterCairoTexture *texture;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
cairo_rectangle_int_t rect;
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
guint is_clipped : 1;
} DrawContext;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
static const cairo_user_data_key_t clutter_cairo_texture_context_key;
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
static DrawContext *
draw_context_create (ClutterCairoTexture *texture)
{
DrawContext *context = g_slice_new0 (DrawContext);
context->texture = g_object_ref (texture);
return context;
}
static void
draw_context_destroy (gpointer data)
{
if (G_LIKELY (data != NULL))
{
DrawContext *context = data;
g_object_unref (context->texture);
g_slice_free (DrawContext, data);
}
}
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
static void
clutter_cairo_texture_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterCairoTexturePrivate *priv;
priv = CLUTTER_CAIRO_TEXTURE (object)->priv;
switch (prop_id)
{
case PROP_SURFACE_WIDTH:
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
/* we perform the resize on notify to coalesce separate
* surface-width/surface-height property set
*/
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
priv->surface_width = g_value_get_uint (value);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
break;
case PROP_SURFACE_HEIGHT:
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
priv->surface_height = g_value_get_uint (value);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
break;
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
case PROP_AUTO_RESIZE:
clutter_cairo_texture_set_auto_resize (CLUTTER_CAIRO_TEXTURE (object),
g_value_get_boolean (value));
break;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
clutter_cairo_texture_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterCairoTexturePrivate *priv;
priv = CLUTTER_CAIRO_TEXTURE (object)->priv;
switch (prop_id)
{
case PROP_SURFACE_WIDTH:
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
g_value_set_uint (value, priv->surface_width);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
break;
case PROP_SURFACE_HEIGHT:
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
g_value_set_uint (value, priv->surface_height);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
break;
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
case PROP_AUTO_RESIZE:
g_value_set_boolean (value, priv->auto_resize);
break;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
clutter_cairo_texture_finalize (GObject *object)
{
ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (object)->priv;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
if (priv->cr_surface != NULL)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
cairo_surface_t *surface = priv->cr_surface;
priv->cr_surface = NULL;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
cairo_surface_finish (surface);
cairo_surface_destroy (surface);
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
}
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
G_OBJECT_CLASS (clutter_cairo_texture_parent_class)->finalize (object);
}
static cairo_surface_t *
get_surface (ClutterCairoTexture *self)
{
ClutterCairoTexturePrivate *priv = self->priv;
if (priv->cr_surface == NULL)
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
{
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
g_signal_emit (self, cairo_signals[CREATE_SURFACE], 0,
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
priv->surface_width,
priv->surface_height,
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
&priv->cr_surface);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
return priv->cr_surface;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
static void
clutter_cairo_texture_context_destroy (void *data)
{
DrawContext *ctxt = data;
ClutterCairoTexture *cairo = ctxt->texture;
ClutterCairoTexturePrivate *priv = cairo->priv;
guint8 *cairo_data;
gint cairo_width, cairo_height, cairo_stride;
gint surface_width, surface_height;
CoglHandle cogl_texture;
if (priv->cr_surface == NULL)
{
/* the surface went away before we could use it */
draw_context_destroy (ctxt);
return;
}
/* for any other surface type, we presume that there exists a native
* communication between Cairo and GL that is triggered by cairo_destroy().
*
* for instance, cairo-drm will flush the outstanding modifications to the
* surface upon context destruction and so the texture is automatically
* updated.
*/
if (cairo_surface_get_type (priv->cr_surface) != CAIRO_SURFACE_TYPE_IMAGE)
goto out;
surface_width = cairo_image_surface_get_width (priv->cr_surface);
surface_height = cairo_image_surface_get_height (priv->cr_surface);
cairo_width = MIN (ctxt->rect.width, surface_width);
cairo_height = MIN (ctxt->rect.height, surface_height);
cogl_texture = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (cairo));
if (cairo_width == 0 ||
cairo_height == 0 ||
cogl_texture == COGL_INVALID_HANDLE)
{
draw_context_destroy (ctxt);
return;
}
cairo_stride = cairo_image_surface_get_stride (priv->cr_surface);
cairo_data = cairo_image_surface_get_data (priv->cr_surface);
cairo_data += cairo_stride * ctxt->rect.y;
cairo_data += 4 * ctxt->rect.x;
cogl_texture_set_region (cogl_texture,
0, 0,
ctxt->rect.x, ctxt->rect.y,
cairo_width, cairo_height,
cairo_width, cairo_height,
CLUTTER_CAIRO_FORMAT_ARGB32,
cairo_stride,
cairo_data);
out:
draw_context_destroy (ctxt);
clutter_actor_queue_redraw (CLUTTER_ACTOR (cairo));
}
static inline void
clutter_cairo_texture_emit_draw (ClutterCairoTexture *self,
DrawContext *ctxt)
{
gboolean result;
cairo_t *cr;
cairo-texture: Skip ::draw emission for 0x0 surfaces This also avoids an assertion failure.
2011-11-18 17:22:12 +00:00
/* 0x0 surfaces don't need a ::draw */
if (self->priv->surface_width == 0 ||
self->priv->surface_height == 0)
return;
/* if the size is !0 then we must have a surface */
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
g_assert (self->priv->cr_surface != NULL);
cr = cairo_create (self->priv->cr_surface);
cairo_set_user_data (cr, &clutter_cairo_texture_context_key,
ctxt,
clutter_cairo_texture_context_destroy);
if (ctxt->is_clipped)
{
cairo_rectangle (cr,
ctxt->rect.x,
ctxt->rect.y,
ctxt->rect.width,
ctxt->rect.height);
cairo_clip (cr);
}
/* store the cairo_t as a guard */
self->priv->cr_context = cr;
g_signal_emit (self, cairo_signals[DRAW], 0, cr, &result);
self->priv->cr_context = NULL;
cairo_destroy (cr);
}
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
static inline void
clutter_cairo_texture_surface_resize_internal (ClutterCairoTexture *cairo)
{
ClutterCairoTexturePrivate *priv = cairo->priv;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
if (priv->cr_surface != NULL)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
cairo_surface_t *surface = priv->cr_surface;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
/* if the surface is an image one, and the size is already the
* same, then we don't need to do anything
*/
if (cairo_surface_get_type (surface) != CAIRO_SURFACE_TYPE_IMAGE)
{
gint surface_width = cairo_image_surface_get_width (surface);
gint surface_height = cairo_image_surface_get_height (surface);
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
if (priv->surface_width == surface_width &&
priv->surface_height == surface_height)
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
return;
}
[cairo-texture] Remove the construct only restriction on surface size It is possible to change the surface size after construction with clutter_cairo_texture_set_surface_size so it doesn't seem right to restrict changing the properties. clutter_cairo_texture_resize_surface_internal is called in a handler for the notify signal. It is called there rather than directly in the set_property handler so that changing both properties in a single g_object_set will only cause one resize. The constructed override is no longer needed. resize_surface_internal will now bail out if the size of the surface is already the right size.
2008-12-19 13:15:26 +00:00
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
cairo_surface_finish (surface);
cairo_surface_destroy (surface);
priv->cr_surface = NULL;
}
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
if (priv->surface_width == 0 ||
priv->surface_height == 0)
[cairo-texture] Silently discard 0x0 surfaces The current CairoTexture can be created with a surface size of 0 by 0 pixels, but a warning will be printed. Worse, the surface can be resized to be 0 by 0 pixels without a warning. The :surface-width and :surface-height properties accept a minimum value of 0, and not check is performed on either the constructor or set_surface_size() parameters to enforce the "greater than zero" rule. The correct and consistent behaviour is to allow a 0 by 0 pixels surface size everywhere; inside surface_resize_internal(), the current surface will be destroyed and if either :surface-width or :surface-height are set to 0, the resizing terminates. Attempting to create a Cairo context from a CairoTexture with either :surface-width or :surface-height set to 0 will result in a warning. This allows: - creating a CairoTexture with :surface-width or :surface-height set to zero and delaying the surface resize at a later point; - resizing the surface to 0 by 0 pixels to destroy the image surface used internally; - increase the consistency in the usage of CairoTexture.
2008-12-17 15:40:33 +00:00
return;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
g_signal_emit (cairo, cairo_signals[CREATE_SURFACE], 0,
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
priv->surface_width,
priv->surface_height,
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
&priv->cr_surface);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
[cairo-texture] Silently discard 0x0 surfaces The current CairoTexture can be created with a surface size of 0 by 0 pixels, but a warning will be printed. Worse, the surface can be resized to be 0 by 0 pixels without a warning. The :surface-width and :surface-height properties accept a minimum value of 0, and not check is performed on either the constructor or set_surface_size() parameters to enforce the "greater than zero" rule. The correct and consistent behaviour is to allow a 0 by 0 pixels surface size everywhere; inside surface_resize_internal(), the current surface will be destroyed and if either :surface-width or :surface-height are set to 0, the resizing terminates. Attempting to create a Cairo context from a CairoTexture with either :surface-width or :surface-height set to 0 will result in a warning. This allows: - creating a CairoTexture with :surface-width or :surface-height set to zero and delaying the surface resize at a later point; - resizing the surface to 0 by 0 pixels to destroy the image surface used internally; - increase the consistency in the usage of CairoTexture.
2008-12-17 15:40:33 +00:00
static void
[cairo-texture] Remove the construct only restriction on surface size It is possible to change the surface size after construction with clutter_cairo_texture_set_surface_size so it doesn't seem right to restrict changing the properties. clutter_cairo_texture_resize_surface_internal is called in a handler for the notify signal. It is called there rather than directly in the set_property handler so that changing both properties in a single g_object_set will only cause one resize. The constructed override is no longer needed. resize_surface_internal will now bail out if the size of the surface is already the right size.
2008-12-19 13:15:26 +00:00
clutter_cairo_texture_notify (GObject *object,
GParamSpec *pspec)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
[cairo-texture] Remove the construct only restriction on surface size It is possible to change the surface size after construction with clutter_cairo_texture_set_surface_size so it doesn't seem right to restrict changing the properties. clutter_cairo_texture_resize_surface_internal is called in a handler for the notify signal. It is called there rather than directly in the set_property handler so that changing both properties in a single g_object_set will only cause one resize. The constructed override is no longer needed. resize_surface_internal will now bail out if the size of the surface is already the right size.
2008-12-19 13:15:26 +00:00
/* When the surface width or height changes then resize the cairo
surface. This is done here instead of directly in set_property so
that if both the width and height properties are set using a
single call to g_object_set then the surface will only be resized
once because the notifications will be frozen in between */
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
if (obj_props[PROP_SURFACE_WIDTH]->name == pspec->name ||
obj_props[PROP_SURFACE_HEIGHT]->name == pspec->name)
[cairo-texture] Remove the construct only restriction on surface size It is possible to change the surface size after construction with clutter_cairo_texture_set_surface_size so it doesn't seem right to restrict changing the properties. clutter_cairo_texture_resize_surface_internal is called in a handler for the notify signal. It is called there rather than directly in the set_property handler so that changing both properties in a single g_object_set will only cause one resize. The constructed override is no longer needed. resize_surface_internal will now bail out if the size of the surface is already the right size.
2008-12-19 13:15:26 +00:00
{
ClutterCairoTexture *cairo = CLUTTER_CAIRO_TEXTURE (object);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
[cairo-texture] Remove the construct only restriction on surface size It is possible to change the surface size after construction with clutter_cairo_texture_set_surface_size so it doesn't seem right to restrict changing the properties. clutter_cairo_texture_resize_surface_internal is called in a handler for the notify signal. It is called there rather than directly in the set_property handler so that changing both properties in a single g_object_set will only cause one resize. The constructed override is no longer needed. resize_surface_internal will now bail out if the size of the surface is already the right size.
2008-12-19 13:15:26 +00:00
clutter_cairo_texture_surface_resize_internal (cairo);
}
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
[cairo-texture] Remove the construct only restriction on surface size It is possible to change the surface size after construction with clutter_cairo_texture_set_surface_size so it doesn't seem right to restrict changing the properties. clutter_cairo_texture_resize_surface_internal is called in a handler for the notify signal. It is called there rather than directly in the set_property handler so that changing both properties in a single g_object_set will only cause one resize. The constructed override is no longer needed. resize_surface_internal will now bail out if the size of the surface is already the right size.
2008-12-19 13:15:26 +00:00
if (G_OBJECT_CLASS (clutter_cairo_texture_parent_class)->notify)
G_OBJECT_CLASS (clutter_cairo_texture_parent_class)->notify (object, pspec);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
static void
clutter_cairo_texture_get_preferred_width (ClutterActor *actor,
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
gfloat for_height,
gfloat *min_width,
gfloat *natural_width)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (actor)->priv;
if (min_width)
*min_width = 0;
if (natural_width)
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
*natural_width = (gfloat) priv->surface_width;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
static void
clutter_cairo_texture_get_preferred_height (ClutterActor *actor,
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
gfloat for_width,
gfloat *min_height,
gfloat *natural_height)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (actor)->priv;
if (min_height)
*min_height = 0;
if (natural_height)
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
*natural_height = (gfloat) priv->surface_height;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
static void
clutter_cairo_texture_allocate (ClutterActor *self,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags)
{
ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (self)->priv;
ClutterActorClass *parent_class;
parent_class = CLUTTER_ACTOR_CLASS (clutter_cairo_texture_parent_class);
parent_class->allocate (self, allocation, flags);
if (priv->auto_resize)
{
ClutterCairoTexture *texture = CLUTTER_CAIRO_TEXTURE (self);
gfloat width, height;
clutter_actor_box_get_size (allocation, &width, &height);
cairo-texture: Drop the half pixel rounding Calling ceilf() should be enough. https://bugzilla.gnome.org/show_bug.cgi?id=661887
2011-10-24 10:58:23 +00:00
priv->surface_width = ceilf (width);
priv->surface_height = ceilf (height);
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
clutter_cairo_texture_surface_resize_internal (texture);
clutter_cairo_texture_invalidate (texture);
}
}
actor: make default get_paint_volume more conservative There are too many examples where the default assumption that an actor paints inside its allocation isn't true, so we now return FALSE in the base implementation instead. This means that by default we are saying "we don't know the paint volume of the actor", so developers need to implement the get_paint_volume virtual to take advantage of culling and clipped redraws with their actors. This patch provides very conservative get_paint_volume implementations for ClutterTexture, ClutterCairoTexture, ClutterRectangle and ClutterText which all explicitly check the actor's object type to avoid making any assumptions about subclasses.
2010-09-08 18:47:11 +00:00
static gboolean
Move default paint volume computation into a function This should reduce the amount of copy and paste for actor sub-classes that use the default paint volume from the allocation.
2010-09-09 11:30:29 +00:00
clutter_cairo_texture_get_paint_volume (ClutterActor *self,
actor: make default get_paint_volume more conservative There are too many examples where the default assumption that an actor paints inside its allocation isn't true, so we now return FALSE in the base implementation instead. This means that by default we are saying "we don't know the paint volume of the actor", so developers need to implement the get_paint_volume virtual to take advantage of culling and clipped redraws with their actors. This patch provides very conservative get_paint_volume implementations for ClutterTexture, ClutterCairoTexture, ClutterRectangle and ClutterText which all explicitly check the actor's object type to avoid making any assumptions about subclasses.
2010-09-08 18:47:11 +00:00
ClutterPaintVolume *volume)
{
Move default paint volume computation into a function This should reduce the amount of copy and paste for actor sub-classes that use the default paint volume from the allocation.
2010-09-09 11:30:29 +00:00
return _clutter_actor_set_default_paint_volume (self,
CLUTTER_TYPE_CAIRO_TEXTURE,
volume);
actor: make default get_paint_volume more conservative There are too many examples where the default assumption that an actor paints inside its allocation isn't true, so we now return FALSE in the base implementation instead. This means that by default we are saying "we don't know the paint volume of the actor", so developers need to implement the get_paint_volume virtual to take advantage of culling and clipped redraws with their actors. This patch provides very conservative get_paint_volume implementations for ClutterTexture, ClutterCairoTexture, ClutterRectangle and ClutterText which all explicitly check the actor's object type to avoid making any assumptions about subclasses.
2010-09-08 18:47:11 +00:00
}
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
static cairo_surface_t *
clutter_cairo_texture_create_surface (ClutterCairoTexture *self,
guint width,
guint height)
{
cairo_surface_t *surface;
guint cairo_stride;
guint8 *cairo_data;
CoglHandle cogl_texture;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
width,
height);
cairo_stride = cairo_image_surface_get_stride (surface);
cairo_data = cairo_image_surface_get_data (surface);
/* create a backing Cogl texture */
cogl_texture = cogl_texture_new_from_data (width, height,
COGL_TEXTURE_NONE,
cairo-texture: Make the pixel order macro public It stands to reason that any piece of code using Cairo and Cogl at the same time, and dealing with texture data, will want to use the same logic Clutter uses to determine the compatible pixel format between the two. https://bugzilla.gnome.org/show_bug.cgi?id=647875
2011-04-12 16:00:46 +00:00
CLUTTER_CAIRO_FORMAT_ARGB32,
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
COGL_PIXEL_FORMAT_ANY,
cairo_stride,
cairo_data);
clutter_texture_set_cogl_texture (CLUTTER_TEXTURE (self), cogl_texture);
cogl_handle_unref (cogl_texture);
return surface;
}
static gboolean
create_surface_accum (GSignalInvocationHint *ihint,
GValue *return_accu,
const GValue *handler_return,
gpointer data)
{
g_value_copy (handler_return, return_accu);
/* stop on the first non-NULL return value */
return g_value_get_boxed (handler_return) == NULL;
}
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
static void
clutter_cairo_texture_draw_marshaller (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data)
{
cairo_t *cr = g_value_get_boxed (&param_values[1]);
cairo_save (cr);
_clutter_marshal_BOOLEAN__BOXED (closure,
return_value,
n_param_values,
param_values,
invocation_hint,
marshal_data);
cairo_restore (cr);
}
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
static void
clutter_cairo_texture_class_init (ClutterCairoTextureClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
gobject_class->finalize = clutter_cairo_texture_finalize;
gobject_class->set_property = clutter_cairo_texture_set_property;
gobject_class->get_property = clutter_cairo_texture_get_property;
[cairo-texture] Remove the construct only restriction on surface size It is possible to change the surface size after construction with clutter_cairo_texture_set_surface_size so it doesn't seem right to restrict changing the properties. clutter_cairo_texture_resize_surface_internal is called in a handler for the notify signal. It is called there rather than directly in the set_property handler so that changing both properties in a single g_object_set will only cause one resize. The constructed override is no longer needed. resize_surface_internal will now bail out if the size of the surface is already the right size.
2008-12-19 13:15:26 +00:00
gobject_class->notify = clutter_cairo_texture_notify;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
actor: make default get_paint_volume more conservative There are too many examples where the default assumption that an actor paints inside its allocation isn't true, so we now return FALSE in the base implementation instead. This means that by default we are saying "we don't know the paint volume of the actor", so developers need to implement the get_paint_volume virtual to take advantage of culling and clipped redraws with their actors. This patch provides very conservative get_paint_volume implementations for ClutterTexture, ClutterCairoTexture, ClutterRectangle and ClutterText which all explicitly check the actor's object type to avoid making any assumptions about subclasses.
2010-09-08 18:47:11 +00:00
actor_class->get_paint_volume =
clutter_cairo_texture_get_paint_volume;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
actor_class->get_preferred_width =
clutter_cairo_texture_get_preferred_width;
actor_class->get_preferred_height =
clutter_cairo_texture_get_preferred_height;
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
actor_class->allocate =
clutter_cairo_texture_allocate;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
klass->create_surface = clutter_cairo_texture_create_surface;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
g_type_class_add_private (gobject_class, sizeof (ClutterCairoTexturePrivate));
/**
* ClutterCairoTexture:surface-width:
*
* The width of the Cairo surface used by the #ClutterCairoTexture
* actor, in pixels.
*
* Since: 1.0
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
obj_props[PROP_SURFACE_WIDTH] =
g_param_spec_uint ("surface-width",
P_("Surface Width"),
P_("The width of the Cairo surface"),
0, G_MAXUINT,
0,
CLUTTER_PARAM_READWRITE);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
/**
* ClutterCairoTexture:surface-height:
*
* The height of the Cairo surface used by the #ClutterCairoTexture
* actor, in pixels.
*
* Since: 1.0
*/
Move more classes to install_properties()
2010-10-15 14:24:27 +00:00
obj_props[PROP_SURFACE_HEIGHT] =
g_param_spec_uint ("surface-height",
P_("Surface Height"),
P_("The height of the Cairo surface"),
0, G_MAXUINT,
0,
CLUTTER_PARAM_READWRITE);
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
/**
* ClutterCairoTexture:auto-resize:
*
* Controls whether the #ClutterCairoTexture should automatically
* resize the Cairo surface whenever the actor's allocation changes.
* If :auto-resize is set to %TRUE the surface contents will also
* be invalidated automatically.
*
* Since: 1.8
*/
obj_props[PROP_AUTO_RESIZE] =
g_param_spec_boolean ("auto-resize",
P_("Auto Resize"),
P_("Whether the surface should match the allocation"),
FALSE,
CLUTTER_PARAM_READWRITE);
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
/**
gtk-doc: Fixes for the API references
2010-11-08 16:01:19 +00:00
* ClutterCairoTexture::create-surface:
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
* @texture: the #ClutterCairoTexture that emitted the signal
* @width: the width of the surface to create
* @height: the height of the surface to create
*
* The ::create-surface signal is emitted when a #ClutterCairoTexture
* news its surface (re)created, which happens either when the Cairo
* context is created with clutter_cairo_texture_create() or
* clutter_cairo_texture_create_region(), or when the surface is resized
* through clutter_cairo_texture_set_surface_size().
*
* The first signal handler that returns a non-%NULL, valid surface will
* stop any further signal emission, and the returned surface will be
* the one used.
*
* Return value: the newly created #cairo_surface_t for the texture
*
* Since: 1.6
*/
cairo_signals[CREATE_SURFACE] =
g_signal_new (I_("create-surface"),
G_TYPE_FROM_CLASS (klass),
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
G_STRUCT_OFFSET (ClutterCairoTextureClass, create_surface),
create_surface_accum, NULL,
_clutter_marshal_BOXED__UINT_UINT,
CAIRO_GOBJECT_TYPE_SURFACE, 2,
G_TYPE_UINT,
G_TYPE_UINT);
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
/**
* ClutterCairoTexture::draw:
docs: Fixes for building the API reference
2011-07-26 12:43:37 +00:00
* @texture: the #ClutterCairoTexture that emitted the signal
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
* @cr: the Cairo context to use to draw
*
* The ::draw signal is emitted each time a #ClutterCairoTexture has
* been invalidated.
*
* The passed Cairo context passed will be clipped to the invalidated
* area.
*
* It is safe to connect multiple callbacks to this signals; the state
* of the Cairo context passed to each callback is automatically saved
* and restored, so it's not necessary to call cairo_save() and
* cairo_restore().
*
* Return value: %TRUE if the signal emission should stop, and %FALSE
* to continue
*
* Since: 1.8
*/
cairo_signals[DRAW] =
g_signal_new (I_("draw"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
G_STRUCT_OFFSET (ClutterCairoTextureClass, draw),
_clutter_boolean_handled_accumulator, NULL,
clutter_cairo_texture_draw_marshaller,
G_TYPE_BOOLEAN, 1,
CAIRO_GOBJECT_TYPE_CONTEXT);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
static void
clutter_cairo_texture_init (ClutterCairoTexture *self)
{
ClutterCairoTexturePrivate *priv;
self->priv = priv = CLUTTER_CAIRO_TEXTURE_GET_PRIVATE (self);
/* FIXME - we are hardcoding the format; it would be good to have
* a :surface-format construct-only property for creating
Small documentation fixes Fix the CairoTexture description, and some of the comments inside the code, especially with regards to the alpha channel unpremultiplication that we have to perform each time we upload the image surface to GL.
2008-12-11 15:51:24 +00:00
* textures with a different format and have the cairo surface
* match that format
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
*
* priv->format = CAIRO_FORMAT_ARGB32;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*/
cairo-texture: Disable :sync-size The :sync-size property of ClutterTexture should be set to FALSE by default by ClutterCairoTexture. The preferred size of the ClutterCairoTexture is already the size of the internal Cairo surface, and we override the preferred width/height getters to that effect. The :sync-size property is also responsible of changing the size of the Texture actor when changing the texture handle - but since we encourage that to happen during the CairoTexture allocation, we get a queue_relayout() invocation (and a warning) when we change the size of the Cairo image surface. Since GObject doesn't make it easy to override the default value of the :sync-size property in sub-classes, we should simply call the setter function during the ClutterCairoTexture instance initialization. We should also change one of the interactive tests using a CairoTexture to rebuild the contents of the actor in response to an allocation.
2010-06-16 12:58:41 +00:00
/* the Cairo surface is responsible for driving the size of
* the texture; if we let sync_size to its default of TRUE,
* the Texture will try to queue a relayout every time we
* change the size of the Cairo surface - which is not what
* we want
*/
clutter_texture_set_sync_size (CLUTTER_TEXTURE (self), FALSE);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
/**
* clutter_cairo_texture_new:
* @width: the width of the surface
* @height: the height of the surface
*
* Creates a new #ClutterCairoTexture actor, with a surface of @width by
* @height pixels.
*
* Return value: the newly created #ClutterCairoTexture actor
*
* Since: 1.0
*/
ClutterActor*
clutter_cairo_texture_new (guint width,
guint height)
{
return g_object_new (CLUTTER_TYPE_CAIRO_TEXTURE,
"surface-width", width,
"surface-height", height,
NULL);
}
static void
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
intersect_rectangles (cairo_rectangle_int_t *a,
cairo_rectangle_int_t *b,
cairo_rectangle_int_t *inter)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
gint dest_x, dest_y;
gint dest_width, dest_height;
dest_x = MAX (a->x, b->x);
dest_y = MAX (a->y, b->y);
dest_width = MIN (a->x + a->width, b->x + b->width) - dest_x;
dest_height = MIN (a->y + a->height, b->y + b->height) - dest_y;
if (dest_width > 0 && dest_height > 0)
{
inter->x = dest_x;
inter->y = dest_y;
inter->width = dest_width;
inter->height = dest_height;
}
else
{
inter->x = 0;
inter->y = 0;
inter->width = 0;
inter->height = 0;
}
}
cairo-texture: Use an internal function for create_region() Avoid double argument checking, and a deprecation warning when implementing create() as a wrapper around create_region(), by using a simple internal function.
2011-11-02 12:48:31 +00:00
static cairo_t *
clutter_cairo_texture_create_region_internal (ClutterCairoTexture *self,
gint x_offset,
gint y_offset,
gint width,
gint height)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
cairo-texture: Use an internal function for create_region() Avoid double argument checking, and a deprecation warning when implementing create() as a wrapper around create_region(), by using a simple internal function.
2011-11-02 12:48:31 +00:00
ClutterCairoTexturePrivate *priv = self->priv;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
cairo_rectangle_int_t region, area, inter;
cairo_surface_t *surface;
cairo-texture: Use an internal function for create_region() Avoid double argument checking, and a deprecation warning when implementing create() as a wrapper around create_region(), by using a simple internal function.
2011-11-02 12:48:31 +00:00
DrawContext *ctxt;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
cairo_t *cr;
if (width < 0)
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
width = priv->surface_width;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
if (height < 0)
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
height = priv->surface_height;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
[cairo-texture] Silently discard 0x0 surfaces The current CairoTexture can be created with a surface size of 0 by 0 pixels, but a warning will be printed. Worse, the surface can be resized to be 0 by 0 pixels without a warning. The :surface-width and :surface-height properties accept a minimum value of 0, and not check is performed on either the constructor or set_surface_size() parameters to enforce the "greater than zero" rule. The correct and consistent behaviour is to allow a 0 by 0 pixels surface size everywhere; inside surface_resize_internal(), the current surface will be destroyed and if either :surface-width or :surface-height are set to 0, the resizing terminates. Attempting to create a Cairo context from a CairoTexture with either :surface-width or :surface-height set to 0 will result in a warning. This allows: - creating a CairoTexture with :surface-width or :surface-height set to zero and delaying the surface resize at a later point; - resizing the surface to 0 by 0 pixels to destroy the image surface used internally; - increase the consistency in the usage of CairoTexture.
2008-12-17 15:40:33 +00:00
if (width == 0 || height == 0)
{
g_warning ("Unable to create a context for an image surface of "
"width %d and height %d. Set the surface size to be "
"at least 1 pixel by 1 pixel.",
width, height);
return NULL;
}
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
surface = get_surface (self);
[cairo-texture] Silently discard 0x0 surfaces The current CairoTexture can be created with a surface size of 0 by 0 pixels, but a warning will be printed. Worse, the surface can be resized to be 0 by 0 pixels without a warning. The :surface-width and :surface-height properties accept a minimum value of 0, and not check is performed on either the constructor or set_surface_size() parameters to enforce the "greater than zero" rule. The correct and consistent behaviour is to allow a 0 by 0 pixels surface size everywhere; inside surface_resize_internal(), the current surface will be destroyed and if either :surface-width or :surface-height are set to 0, the resizing terminates. Attempting to create a Cairo context from a CairoTexture with either :surface-width or :surface-height set to 0 will result in a warning. This allows: - creating a CairoTexture with :surface-width or :surface-height set to zero and delaying the surface resize at a later point; - resizing the surface to 0 by 0 pixels to destroy the image surface used internally; - increase the consistency in the usage of CairoTexture.
2008-12-17 15:40:33 +00:00
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
ctxt = draw_context_create (self);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
region.x = x_offset;
region.y = y_offset;
region.width = width;
region.height = height;
area.x = 0;
area.y = 0;
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
area.width = priv->surface_width;
area.height = priv->surface_height;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
/* Limit the region to the visible rectangle */
intersect_rectangles (&area, &region, &inter);
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
ctxt->rect = inter;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
cr = cairo_create (surface);
Revert "clutter-cairo-texture: Use the new cogl_pixel_buffer API" This reverts commit 716ec82db8bec57e35d51e8dee5468435fc9e59e. The Cogl pixel buffer API currently has problems if an atlas texture is created or the format needs to be converted. The atlas problem doesn't currently show because the atlas rejects BGR textures anyway but we may want to change this soon. The problem with format conversion would happen under GLES because that does not support BGR textures at all so Cogl has to do the conversion. However it doesn't currently show either because GLES has no support for buffer objects anyway. It's also questionable whether the patch would give any performance benefit because Cairo needs read/write access which implies the buffer can't be put in write-optimised memory. Conflicts: clutter/clutter-cairo-texture.c http://bugzilla.openedhand.com/show_bug.cgi?id=1982
2010-05-10 14:33:05 +00:00
cairo_set_user_data (cr, &clutter_cairo_texture_context_key,
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
ctxt,
clutter_cairo_texture_context_destroy);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
return cr;
}
cairo-texture: Use an internal function for create_region() Avoid double argument checking, and a deprecation warning when implementing create() as a wrapper around create_region(), by using a simple internal function.
2011-11-02 12:48:31 +00:00
/**
* clutter_cairo_texture_create_region:
* @self: a #ClutterCairoTexture
* @x_offset: offset of the region on the X axis
* @y_offset: offset of the region on the Y axis
* @width: width of the region, or -1 for the full surface width
* @height: height of the region, or -1 for the full surface height
*
* Creates a new Cairo context that will updat the region defined
* by @x_offset, @y_offset, @width and @height.
*
* <warning><para>Do not call this function within the paint virtual
* function or from a callback to the #ClutterActor::paint
* signal.</para></warning>
*
* Return value: a newly created Cairo context. Use cairo_destroy()
* to upload the contents of the context when done drawing
*
* Since: 1.0
*
* Deprecated: 1.8: Use the #ClutterCairoTexture::draw signal and
* clutter_cairo_texture_invalidate_rectangle() to obtain a
* clipped Cairo context for 2D drawing.
*/
cairo_t *
clutter_cairo_texture_create_region (ClutterCairoTexture *self,
gint x_offset,
gint y_offset,
gint width,
gint height)
{
g_return_val_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self), NULL);
clutter_warn_if_paint_fail (self);
return clutter_cairo_texture_create_region_internal (self,
x_offset, y_offset,
width, height);
}
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
/**
* clutter_cairo_texture_invalidate_rectangle:
* @self: a #ClutterCairoTexture
* @rect: (allow-none): a rectangle with the area to invalida,
* or %NULL to perform an unbounded invalidation
*
* Invalidates a rectangular region of a #ClutterCairoTexture.
*
* The invalidation will cause the #ClutterCairoTexture::draw signal
* to be emitted.
*
* See also: clutter_cairo_texture_invalidate()
*
* Since: 1.8
*/
void
clutter_cairo_texture_invalidate_rectangle (ClutterCairoTexture *self,
cairo_rectangle_int_t *rect)
{
DrawContext *ctxt = NULL;
g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));
if (self->priv->cr_context != NULL)
{
g_warning ("It is not possible to invalidate a Cairo texture"
"while drawing into it.");
return;
}
ctxt = draw_context_create (self);
if (rect != NULL)
{
cairo_rectangle_int_t area, inter;
area.x = 0;
area.y = 0;
area.width = self->priv->surface_width;
area.height = self->priv->surface_height;
/* Limit the region to the visible rectangle */
intersect_rectangles (&area, rect, &inter);
ctxt->is_clipped = TRUE;
ctxt->rect = inter;
}
else
{
ctxt->is_clipped = FALSE;
ctxt->rect.x = ctxt->rect.y = 0;
ctxt->rect.width = self->priv->surface_width;
ctxt->rect.height = self->priv->surface_height;
}
/* XXX - it might be good to move the emission inside the paint cycle
* using a repaint function, to avoid blocking inside this function
*/
clutter_cairo_texture_emit_draw (self, ctxt);
}
/**
* clutter_cairo_texture_invalidate:
* @self: a #ClutterCairoTexture
*
* Invalidates the whole surface of a #ClutterCairoTexture.
*
* This function will cause the #ClutterCairoTexture::draw signal
* to be emitted.
*
* See also: clutter_cairo_texture_invalidate_rectangle()
*
* Since: 1.8
*/
void
clutter_cairo_texture_invalidate (ClutterCairoTexture *self)
{
g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));
clutter_cairo_texture_invalidate_rectangle (self, NULL);
}
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
/**
* clutter_cairo_texture_create:
[docs] Documentation fixes for CairoTexture Sync up the arguments name inside the gtk-doc annotations with their name inside the function declaration in the header file.
2008-12-19 17:48:30 +00:00
* @self: a #ClutterCairoTexture
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*
* Creates a new Cairo context for the @cairo texture. It is
* similar to using clutter_cairo_texture_create_region() with @x_offset
* and @y_offset of 0, @width equal to the @cairo texture surface width
* and @height equal to the @cairo texture surface height.
*
[docs] Documentation fixes for CairoTexture Sync up the arguments name inside the gtk-doc annotations with their name inside the function declaration in the header file.
2008-12-19 17:48:30 +00:00
* <warning><para>Do not call this function within the paint virtual
* function or from a callback to the #ClutterActor::paint
* signal.</para></warning>
*
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
* Return value: a newly created Cairo context. Use cairo_destroy()
[docs] Documentation fixes for CairoTexture Sync up the arguments name inside the gtk-doc annotations with their name inside the function declaration in the header file.
2008-12-19 17:48:30 +00:00
* to upload the contents of the context when done drawing
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*
* Since: 1.0
cairo-texture: Deprecate create()/create_region() The recommended way of drawing on a ClutterCairoTexture is the ::draw signal.
2011-07-26 11:53:22 +00:00
*
* Deprecated: 1.8: Use the #ClutterCairoTexture::draw signal and
* the clutter_cairo_texture_invalidate() function to obtain a
* Cairo context for 2D drawing.
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*/
cairo_t *
clutter_cairo_texture_create (ClutterCairoTexture *self)
{
g_return_val_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self), NULL);
Warn instead of returning in the IN_PAINT check It's conceivable that a warning should be deemed enough, instead of just returning a NULL cairo_t when creating a context for the CairoTexture actor.
2008-12-12 11:42:16 +00:00
clutter_warn_if_paint_fail (self);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
cairo-texture: Use an internal function for create_region() Avoid double argument checking, and a deprecation warning when implementing create() as a wrapper around create_region(), by using a simple internal function.
2011-11-02 12:48:31 +00:00
return clutter_cairo_texture_create_region_internal (self, 0, 0, -1, -1);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
/**
* clutter_cairo_set_source_color:
* @cr: a Cairo context
* @color: a #ClutterColor
*
* Utility function for setting the source color of @cr using
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
* a #ClutterColor. This function is the equivalent of:
*
* |[
* cairo_set_source_rgba (cr,
* color->red / 255.0,
* color->green / 255.0,
* color->blue / 255.0,
* color->alpha / 255.0);
* ]|
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*
* Since: 1.0
*/
void
clutter_cairo_set_source_color (cairo_t *cr,
const ClutterColor *color)
{
g_return_if_fail (cr != NULL);
g_return_if_fail (color != NULL);
if (color->alpha == 0xff)
cairo_set_source_rgb (cr,
color->red / 255.0,
color->green / 255.0,
color->blue / 255.0);
else
cairo_set_source_rgba (cr,
color->red / 255.0,
color->green / 255.0,
color->blue / 255.0,
color->alpha / 255.0);
}
/**
[docs] Documentation fixes for CairoTexture Sync up the arguments name inside the gtk-doc annotations with their name inside the function declaration in the header file.
2008-12-19 17:48:30 +00:00
* clutter_cairo_texture_set_surface_size:
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
* @self: a #ClutterCairoTexture
* @width: the new width of the surface
* @height: the new height of the surface
*
* Resizes the Cairo surface used by @self to @width and @height.
*
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
* This function will not invalidate the contents of the Cairo
* texture: you will have to explicitly call either
* clutter_cairo_texture_invalidate_rectangle() or
* clutter_cairo_texture_invalidate().
*
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
* Since: 1.0
*/
void
clutter_cairo_texture_set_surface_size (ClutterCairoTexture *self,
guint width,
guint height)
{
ClutterCairoTexturePrivate *priv;
g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));
priv = self->priv;
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
if (width == priv->surface_width &&
height == priv->surface_height)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
return;
g_object_freeze_notify (G_OBJECT (self));
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
if (priv->surface_width != width)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
priv->surface_width = width;
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_SURFACE_WIDTH]);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
if (priv->surface_height != height)
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
{
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
priv->surface_height = height;
Remove private helper #define's Finish off the second half of 09a830d294. http://bugzilla.clutter-project.org/show_bug.cgi?id=2596
2011-03-03 11:35:46 +00:00
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_SURFACE_HEIGHT]);
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
clutter_cairo_texture_surface_resize_internal (self);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_cairo_texture_get_surface_size:
* @self: a #ClutterCairoTexture
introspection: Add missing (out) annotations Comprehensively add (out) annotations to functions parameters returning int/float/double. Not handled here: structure out returns like ClutterColor or ClutterPerspective or GValue that should get (out caller-allocates). Not handled here: Cogl http://bugzilla.clutter-project.org/show_bug.cgi?id=2302
2010-09-08 14:37:58 +00:00
* @width: (out): return location for the surface width, or %NULL
* @height: (out): return location for the surface height, or %NULL
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
*
* Retrieves the surface width and height for @self.
*
* Since: 1.0
*/
void
clutter_cairo_texture_get_surface_size (ClutterCairoTexture *self,
guint *width,
guint *height)
{
g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));
if (width)
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
*width = self->priv->surface_width;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
if (height)
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
*height = self->priv->surface_height;
Add ClutterCairoTexture Move the ClutterCairo actor from a separate library to an in-tree actor. ClutterCairoTexture is a simple texture subclass that allows you to retrieve a Cairo context for a private image surface. When the Cairo context is destroyed it will cause the image surface contents to be uploaded to a GL texture. The image surface used is not hardware accelerated.
2008-12-11 15:24:07 +00:00
}
[cairo-texture] Document redrawing behavior Document that repeated calls to clutter_cairo_texture_create() continue drawing on the same cairo_surface_t. Add clutter_cairo_texture_clear() for when you don't want that behavior. http://bugzilla.openedhand.com/show_bug.cgi?id=1599 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-14 13:28:12 +00:00
/**
* clutter_cairo_texture_clear:
* @self: a #ClutterCairoTexture
*
* Clears @self's internal drawing surface, so that the next upload
* will replace the previous contents of the #ClutterCairoTexture
* rather than adding to it.
*
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
* Calling this function from within a #ClutterCairoTexture::draw
* signal handler will clear the invalidated area.
*
[cairo-texture] Document redrawing behavior Document that repeated calls to clutter_cairo_texture_create() continue drawing on the same cairo_surface_t. Add clutter_cairo_texture_clear() for when you don't want that behavior. http://bugzilla.openedhand.com/show_bug.cgi?id=1599 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-14 13:28:12 +00:00
* Since: 1.0
*/
void
clutter_cairo_texture_clear (ClutterCairoTexture *self)
{
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
ClutterCairoTexturePrivate *priv;
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
cairo_t *cr;
[cairo-texture] Document redrawing behavior Document that repeated calls to clutter_cairo_texture_create() continue drawing on the same cairo_surface_t. Add clutter_cairo_texture_clear() for when you don't want that behavior. http://bugzilla.openedhand.com/show_bug.cgi?id=1599 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-14 13:28:12 +00:00
g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
priv = self->priv;
/* if we got called outside of a ::draw signal handler
* then we clear the whole surface by creating a temporary
* cairo_t; otherwise, we clear the current cairo_t, which
* will take into account the clip region.
*/
if (priv->cr_context == NULL)
{
cairo_surface_t *surface;
surface = get_surface (self);
cr = cairo_create (surface);
}
else
cr = priv->cr_context;
cairo_save (cr);
[cairo-texture] Document redrawing behavior Document that repeated calls to clutter_cairo_texture_create() continue drawing on the same cairo_surface_t. Add clutter_cairo_texture_clear() for when you don't want that behavior. http://bugzilla.openedhand.com/show_bug.cgi?id=1599 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-14 13:28:12 +00:00
cairo-texture: Allow overriding the surface creation By using a new signal, ::create-surface (width, height), it should be possible for third party code and sub-classes to override the default surface creation code in CairoSurface. This commit takes a bit of the patch from: http://bugzilla.clutter-project.org/show_bug.cgi?id=1878 which cleans up CairoTexture; the idea, mutuated from that bug, is that the CairoTexture actor checks whether the surface it has it's an image one, and in that case it uses a Cogl texture as the backing store. In case the surface is not an image one we assume that the surface itself has some way of updating the GL state and flush the surface.
2010-10-15 16:35:41 +00:00
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
cairo-texture: Use signal-based drawing The current "create context/draw/destroy context" pattern presents various problems. The first issue is that it defers memory management to the caller of the create() or create_region() methods, which makes bookkeeping of the cairo_t* harder for language bindings and third party libraries. The second issue is that, while it's easier for draw-and-forget texturs, this API is needlessly complicated for contents that have to change programmatically - and it introduces constraints like calling the drawing code explicitly after a surface resize (e.g. inside an allocate() implementation). By using a signal-based approach we can make the CairoTexture actor behave like other actors, and like other libraries using Cairo as their 2D drawing API. The semantics of the newly-introduced ::draw signal are the same as the one used by GTK+: - the signal is emitted on invalidation; - the cairo_t* context is owned by the actor; - it is safe to have multiple callbacks attached to the same signal, to allow composition; - the cairo_t* is already clipped to the invalidated area, so that Cairo can discard geometry immediately before we upload the texture data. There are possible future improvements, like coalescing multiple invalidations inside regions, and performing clipped draws during the paint cycle; we could even perform clipped redraws if we know the extent of the invalidated area.
2011-07-26 11:40:52 +00:00
cairo_restore (cr);
if (priv->cr_context == NULL)
cairo_destroy (cr);
[cairo-texture] Document redrawing behavior Document that repeated calls to clutter_cairo_texture_create() continue drawing on the same cairo_surface_t. Add clutter_cairo_texture_clear() for when you don't want that behavior. http://bugzilla.openedhand.com/show_bug.cgi?id=1599 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-14 13:28:12 +00:00
}
cairo-texture: Add the :auto-resize property Keeping the backing Cairo surface of a CairoTexture canvas in sync with the actor's allocation is tedious and prone to mistakes. We can definitely do better by simply exposing a property that does the surface resize and invalidation automagically on ::allocate.
2011-07-26 13:53:26 +00:00
/**
* clutter_cairo_texture_set_auto_resize:
* @self: a #ClutterCairoTexture
* @value: %TRUE if the #ClutterCairoTexture should bind the surface
* size to the allocation
*
* Sets whether the #ClutterCairoTexture should ensure that the
* backing Cairo surface used matches the allocation assigned to
* the actor. If the allocation changes, the contents of the
* #ClutterCairoTexture will also be invalidated automatically.
*
* Since: 1.8
*/
void
clutter_cairo_texture_set_auto_resize (ClutterCairoTexture *self,
gboolean value)
{
ClutterCairoTexturePrivate *priv;
g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));
value = !!value;
priv = self->priv;
if (priv->auto_resize == value)
return;
priv->auto_resize = value;
clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_AUTO_RESIZE]);
}
/**
* clutter_cairo_texture_get_auto_resize:
* @self: a #ClutterCairoTexture
*
* Retrieves the value set using clutter_cairo_texture_set_auto_resize().
*
* Return value: %TRUE if the #ClutterCairoTexture should track the
* allocation, and %FALSE otherwise
*
* Since: 1.8
*/
gboolean
clutter_cairo_texture_get_auto_resize (ClutterCairoTexture *self)
{
g_return_val_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self), FALSE);
return self->priv->auto_resize;
}
Copy permalink