isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-27 02:20:43 -05:00
Code Issues Packages Projects Releases Wiki Activity
eac167df1c
mutter/clutter/clutter-cairo-texture.c

833 lines
25 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 10:24:07 -05: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>
*
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 07:56:10 -05:00
* Copyright (C) 2008, 2009, 2010 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 10:24:07 -05: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 07:56:10 -05: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 10:24:07 -05: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.
*
* #ClutterCairoTexture will provide a #cairo_t context by using the
* clutter_cairo_texture_create() and clutter_cairo_texture_create_region()
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 10:51:24 -05:00
* functions; you can use the Cairo API to draw on the context and then
* call cairo_destroy() when done.
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 10:24:07 -05:00
*
* As soon as the context is destroyed with cairo_destroy(), the contents
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 10:51:24 -05:00
* of the surface will be uploaded into the #ClutterCairoTexture actor:
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 10:24:07 -05:00
*
* |[
* cairo_t *cr;
*
* cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (texture));
*
* /&ast; draw on the context &ast;/
*
* 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 09:28:12 -04:00
* Although a new #cairo_t is created each time you call
* clutter_cairo_texture_create() or
* clutter_cairo_texture_create_region(), it uses the same
* #cairo_surface_t each time. You can call
* clutter_cairo_texture_clear() to erase the contents between calls.
*
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 10:48:43 -05:00
* <warning><para>Note that you should never use the code above inside the
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 10:24:07 -05:00
* #ClutterActor::paint or #ClutterActor::pick virtual functions or
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 10:48:43 -05:00
* signal handlers because it will lead to performance
* degradation.</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 10:24:07 -05:00
*
* <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>
*
* #ClutterCairoTexture is available since Clutter 1.0.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.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 12:35:41 -04: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 10:24:07 -05: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 12:35:41 -04:00
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
#include "clutter-actor-private.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 10:24:07 -05: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 12:35:41 -04: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 10:24:07 -05:00
#include "clutter-private.h"
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 05:20:32 -04:00
PROP_SURFACE_HEIGHT,
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 10:24:07 -05: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 12:35:41 -04:00
enum
{
CREATE_SURFACE,
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 05:20:32 -04: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 10:48:43 -05: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 06:42:16 -05: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 11:10:46 -04: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 10:48:43 -05: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 06:42:16 -05: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 10:48:43 -05: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 10:24:07 -05:00
#define CLUTTER_CAIRO_TEXTURE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_CAIRO_TEXTURE, ClutterCairoTexturePrivate))
[ClutterCairoTexture] Use the right component ordering when uploading data Cairo stores the image data in ARGB native byte order so we need to upload this as BGRA on little endian architectures and ARGB on big endian. ClutterTexture doesn't currently expose any flags to describe ARGB format so until we can fix the Clutter API it now uses the Cogl API directly.
2009-06-15 07:41:13 -04:00
/* Cairo stores the data in native byte order as ARGB but Cogl's pixel
formats specify the actual byte order. Therefore we need to use a
different format depending on the architecture */
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
#define CLUTTER_CAIRO_TEXTURE_PIXEL_FORMAT COGL_PIXEL_FORMAT_BGRA_8888_PRE
#else
#define CLUTTER_CAIRO_TEXTURE_PIXEL_FORMAT COGL_PIXEL_FORMAT_ARGB_8888_PRE
#endif
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 10:24:07 -05:00
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 10:33:05 -04:00
cairo_surface_t *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 12:35:41 -04:00
gint surface_width;
gint 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 10:24:07 -05:00
guint width;
guint 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 12:35:41 -04: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 10:24:07 -05: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 12:35:41 -04:00
typedef struct {
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 10:24:07 -05:00
ClutterCairoTexture *cairo;
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 12:35:41 -04:00
cairo_rectangle_int_t rect;
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 10:24:07 -05:00
} ClutterCairoTextureContext;
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 10:33:05 -04:00
static const cairo_user_data_key_t clutter_cairo_texture_context_key;
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 10:24:07 -05: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:
priv->width = g_value_get_uint (value);
break;
case PROP_SURFACE_HEIGHT:
priv->height = g_value_get_uint (value);
break;
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:
g_value_set_uint (value, priv->width);
break;
case PROP_SURFACE_HEIGHT:
g_value_set_uint (value, priv->height);
break;
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 12:35:41 -04: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 10:24:07 -05: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 10:33:05 -04: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 12:35:41 -04: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 10:33:05 -04: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 12:35:41 -04: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 10:33:05 -04: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 12:35:41 -04:00
g_signal_emit (self, cairo_signals[CREATE_SURFACE], 0,
priv->width,
priv->height,
&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 10:24:07 -05: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 12:35:41 -04: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 10:24:07 -05: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 12:35:41 -04: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 10:24:07 -05: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 10:33:05 -04: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 12:35:41 -04: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);
if (priv->width == surface_width &&
priv->height == surface_height)
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 08:15:26 -05: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 10:33:05 -04:00
cairo_surface_finish (surface);
cairo_surface_destroy (surface);
priv->cr_surface = NULL;
}
[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 10:40:33 -05:00
if (priv->width == 0 || priv->height == 0)
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 12:35:41 -04:00
g_signal_emit (cairo, cairo_signals[CREATE_SURFACE], 0,
priv->width,
priv->height,
&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 10:24:07 -05: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 10:40:33 -05: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 08:15:26 -05: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 10:24:07 -05: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 08:15:26 -05: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: Clean up style
2010-06-16 07:53:02 -04:00
if (strcmp ("surface-width", pspec->name) == 0 ||
strcmp ("surface-height", pspec->name) == 0)
[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 08:15:26 -05: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 10:24:07 -05: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 08:15:26 -05: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 10:24:07 -05: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 08:15:26 -05: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 10:24:07 -05: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 11:44:47 -04: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 10:24:07 -05:00
{
ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (actor)->priv;
if (min_width)
*min_width = 0;
if (natural_width)
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 11:44:47 -04:00
*natural_width = (gfloat) priv->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 10:24:07 -05: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 11:44:47 -04: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 10:24:07 -05:00
{
ClutterCairoTexturePrivate *priv = CLUTTER_CAIRO_TEXTURE (actor)->priv;
if (min_height)
*min_height = 0;
if (natural_height)
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 11:44:47 -04:00
*natural_height = (gfloat) priv->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 10:24:07 -05: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 14:47:11 -04: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 07:30:29 -04: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 14:47:11 -04: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 07:30:29 -04: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 14:47:11 -04: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 12:35:41 -04: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);
self->priv->surface_width = width;
self->priv->surface_height = height;
/* create a backing Cogl texture */
cogl_texture = cogl_texture_new_from_data (width, height,
COGL_TEXTURE_NONE,
CLUTTER_CAIRO_TEXTURE_PIXEL_FORMAT,
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;
}
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 10:24:07 -05: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 08:15:26 -05: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 10:24:07 -05: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 14:47:11 -04: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 10:24:07 -05: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: 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 12:35:41 -04: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 10:24:07 -05: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 10:24:27 -04: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 10:24:07 -05: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 10:24:27 -04: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);
_clutter_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 12:35:41 -04:00
/**
* ClutterCairoTexture::create_surface:
* @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),
G_SIGNAL_RUN_LAST,
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);
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 10:24:07 -05: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 10:51:24 -05: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 12:35:41 -04: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 10:24:07 -05: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 08:58:41 -04: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 10:24:07 -05: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
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 10:33:05 -04:00
clutter_cairo_texture_context_destroy (void *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 10:24:07 -05:00
{
ClutterCairoTextureContext *ctxt = data;
[cairo-texture] Clean up and whitespace fixes Simple clean up of the CairoTexture to remove unneeded checks, redundant variables and white space.
2009-06-15 06:50:23 -04:00
ClutterCairoTexture *cairo = ctxt->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 12:35:41 -04:00
guint8 *cairo_data;
gint cairo_width, cairo_height, cairo_stride;
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 10:33:05 -04:00
gint surface_width, surface_height;
[ClutterCairoTexture] Use the right component ordering when uploading data Cairo stores the image data in ARGB native byte order so we need to upload this as BGRA on little endian architectures and ARGB on big endian. ClutterTexture doesn't currently expose any flags to describe ARGB format so until we can fix the Clutter API it now uses the Cogl API directly.
2009-06-15 07:41:13 -04:00
CoglHandle cogl_texture;
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 10:24:07 -05: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 12:35:41 -04: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 10:24:07 -05: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 12:35:41 -04:00
/* 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;
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 10:33:05 -04:00
surface_width = cairo_image_surface_get_width (priv->cr_surface);
surface_height = cairo_image_surface_get_height (priv->cr_surface);
[ClutterCairoTexture] Use the right component ordering when uploading data Cairo stores the image data in ARGB native byte order so we need to upload this as BGRA on little endian architectures and ARGB on big endian. ClutterTexture doesn't currently expose any flags to describe ARGB format so until we can fix the Clutter API it now uses the Cogl API directly.
2009-06-15 07:41:13 -04: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 10:33:05 -04:00
cairo_width = MIN (ctxt->rect.width, surface_width);
cairo_height = MIN (ctxt->rect.height, 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 10:24:07 -05: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 10:33:05 -04:00
cogl_texture = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (cairo));
if (!cairo_width || !cairo_height || cogl_texture == COGL_INVALID_HANDLE)
{
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 12:35:41 -04:00
g_slice_free (ClutterCairoTextureContext, ctxt);
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 10:33:05 -04: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 12:35:41 -04:00
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;
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 10:33:05 -04:00
cogl_texture_set_region (cogl_texture,
0, 0,
ctxt->rect.x, ctxt->rect.y,
cairo_width, cairo_height,
cairo_width, cairo_height,
CLUTTER_CAIRO_TEXTURE_PIXEL_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 12:35:41 -04:00
cairo_stride,
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 10:33:05 -04:00
cairo_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 10:24:07 -05: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 12:35:41 -04:00
out:
g_slice_free (ClutterCairoTextureContext, ctxt);
[cairo-texture] Clean up and whitespace fixes Simple clean up of the CairoTexture to remove unneeded checks, redundant variables and white space.
2009-06-15 06:50:23 -04:00
clutter_actor_queue_redraw (CLUTTER_ACTOR (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 10:24:07 -05:00
}
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 12:35:41 -04: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 10:24:07 -05: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;
}
}
/**
* clutter_cairo_texture_create_region:
[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 12:48:30 -05: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 10:24:07 -05:00
* @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.
*
[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 12:48:30 -05: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 10:24:07 -05: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 12:48:30 -05: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 10:24:07 -05:00
*
* Since: 1.0
*/
cairo_t *
clutter_cairo_texture_create_region (ClutterCairoTexture *self,
gint x_offset,
gint y_offset,
gint width,
gint height)
{
ClutterCairoTexturePrivate *priv;
ClutterCairoTextureContext *ctxt;
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 12:35:41 -04:00
cairo_rectangle_int_t region, area, inter;
cairo_surface_t *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 10:24:07 -05:00
cairo_t *cr;
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 06:42:16 -05: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 10:24:07 -05:00
priv = self->priv;
if (width < 0)
width = priv->width;
if (height < 0)
height = priv->height;
[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 10:40:33 -05: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 12:35:41 -04: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 10:40:33 -05: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 12:35:41 -04:00
ctxt = g_slice_new0 (ClutterCairoTextureContext);
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 10:24:07 -05:00
ctxt->cairo = self;
region.x = x_offset;
region.y = y_offset;
region.width = width;
region.height = height;
area.x = 0;
area.y = 0;
area.width = priv->width;
area.height = priv->height;
/* 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 12:35:41 -04: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 10:24:07 -05: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 12:35:41 -04: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 10:33:05 -04: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 12:35:41 -04: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 10:24:07 -05:00
return cr;
}
/**
* 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 12:48:30 -05: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 10:24:07 -05: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 12:48:30 -05: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 10:24:07 -05: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 12:48:30 -05: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 10:24:07 -05:00
*
* Since: 1.0
*/
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 06:42:16 -05: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 10:24:07 -05:00
return clutter_cairo_texture_create_region (self, 0, 0, -1, -1);
}
/**
* clutter_cairo_set_source_color:
* @cr: a Cairo context
* @color: a #ClutterColor
*
* Utility function for setting the source color of @cr using
* a #ClutterColor.
*
* 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 12:48:30 -05: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 10:24:07 -05: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.
*
* 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;
if (width == priv->width && height == priv->height)
return;
g_object_freeze_notify (G_OBJECT (self));
if (priv->width != width)
{
priv->width = 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 05:20:32 -04:00
_clutter_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 10:24:07 -05:00
}
if (priv->height != height)
{
priv->height = height;
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 05:20:32 -04:00
_clutter_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 10:24:07 -05: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 10:37:58 -04: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 10:24:07 -05: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)
*width = self->priv->width;
if (height)
*height = self->priv->height;
}
[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 09:28:12 -04: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.
*
* Since: 1.0
*/
void
clutter_cairo_texture_clear (ClutterCairoTexture *self)
{
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 12:35:41 -04:00
cairo_surface_t *surface;
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 09:28:12 -04:00
g_return_if_fail (CLUTTER_IS_CAIRO_TEXTURE (self));
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 12:35:41 -04:00
surface = get_surface (self);
[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 09:28:12 -04: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 12:35:41 -04:00
cr = cairo_create (surface);
cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
cairo_paint (cr);
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 09:28:12 -04:00
}
Reference in New Issue Copy Permalink