brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Port TextureFrame to the new materials and Clone API

Browse Source 
Update TidyTextureFrame using clutter-0-9 branch of NbtkTextureFrame
This commit is contained in:
Thomas Wood 2009-01-29 13:43:42 +00:00
parent 4589d1246d
commit e1cc242b52
2 changed files with 470 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

622
src/compositor/mutter/tidy/tidy-texture-frame.c
View File

@ -41,68 +41,161 @@
enum enum
{ {
PROP_0, PROP_0,
PROP_PARENT_TEXTURE,
PROP_LEFT, PROP_LEFT,
PROP_TOP, PROP_TOP,
PROP_RIGHT, PROP_RIGHT,
PROP_BOTTOM PROP_BOTTOM
}; };
G_DEFINE_TYPE (TidyTextureFrame, G_DEFINE_TYPE (TidyTextureFrame, tidy_texture_frame, CLUTTER_TYPE_ACTOR);
tidy_texture_frame,
CLUTTER_TYPE_CLONE_TEXTURE);
#define TIDY_TEXTURE_FRAME_GET_PRIVATE(obj) \ #define TIDY_TEXTURE_FRAME_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFramePrivate))
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFramePrivate))
struct _TidyTextureFramePrivate struct _TidyTextureFramePrivate
{ {
gint left, top, right, bottom; ClutterTexture *parent_texture;
gfloat left;
gfloat top;
gfloat right;
gfloat bottom;
CoglHandle material;
}; };
static void
tidy_texture_frame_get_preferred_width (ClutterActor *self,
ClutterUnit for_height,
ClutterUnit *min_width_p,
ClutterUnit *natural_width_p)
{
TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
if (G_UNLIKELY (priv->parent_texture == NULL))
{
if (min_width_p)
*min_width_p = 0;
if (natural_width_p)
*natural_width_p = 0;
}
else
{
ClutterActorClass *klass;
/* by directly querying the parent texture's class implementation
* we are going around any override mechanism the parent texture
* might have in place, and we ask directly for the original
* preferred width
*/
klass = CLUTTER_ACTOR_GET_CLASS (priv->parent_texture);
klass->get_preferred_width (CLUTTER_ACTOR (priv->parent_texture),
for_height,
min_width_p,
natural_width_p);
}
}
static void
tidy_texture_frame_get_preferred_height (ClutterActor *self,
ClutterUnit for_width,
ClutterUnit *min_height_p,
ClutterUnit *natural_height_p)
{
TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
if (G_UNLIKELY (priv->parent_texture == NULL))
{
if (min_height_p)
*min_height_p = 0;
if (natural_height_p)
*natural_height_p = 0;
}
else
{
ClutterActorClass *klass;
/* by directly querying the parent texture's class implementation
* we are going around any override mechanism the parent texture
* might have in place, and we ask directly for the original
* preferred height
*/
klass = CLUTTER_ACTOR_GET_CLASS (priv->parent_texture);
klass->get_preferred_height (CLUTTER_ACTOR (priv->parent_texture),
for_width,
min_height_p,
natural_height_p);
}
}
static void
tidy_texture_frame_realize (ClutterActor *self)
{
TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
if (priv->material != COGL_INVALID_HANDLE)
return;
priv->material = cogl_material_new ();
CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
}
static void
tidy_texture_frame_unrealize (ClutterActor *self)
{
TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
if (priv->material == COGL_INVALID_HANDLE)
return;
cogl_material_unref (priv->material);
priv->material = COGL_INVALID_HANDLE;
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
}
static void static void
tidy_texture_frame_paint (ClutterActor *self) tidy_texture_frame_paint (ClutterActor *self)
{ {
TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv; TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (self)->priv;
ClutterCloneTexture *clone_texture = CLUTTER_CLONE_TEXTURE (self); CoglHandle cogl_texture = COGL_INVALID_HANDLE;
ClutterTexture *parent_texture; ClutterActorBox box = { 0, };
guint width, height; gfloat width, height;
guint tex_width, tex_height; gfloat tex_width, tex_height;
guint ex, ey; gfloat ex, ey;
ClutterFixed tx1, ty1, tx2, ty2; gfloat tx1, ty1, tx2, ty2;
ClutterColor col = { 0xff, 0xff, 0xff, 0xff }; guint8 opacity;
CoglHandle cogl_texture;
priv = TIDY_TEXTURE_FRAME (self)->priv;
/* no need to paint stuff if we don't have a texture */ /* no need to paint stuff if we don't have a texture */
parent_texture = clutter_clone_texture_get_parent_texture (clone_texture); if (G_UNLIKELY (priv->parent_texture == NULL))
if (!parent_texture)
return; return;
/* parent texture may have been hidden, so need to make sure it gets /* parent texture may have been hidden, so need to make sure it gets
* realized * realized
*/ */
if (!CLUTTER_ACTOR_IS_REALIZED (parent_texture)) if (!CLUTTER_ACTOR_IS_REALIZED (priv->parent_texture))
clutter_actor_realize (CLUTTER_ACTOR (parent_texture)); clutter_actor_realize (CLUTTER_ACTOR (priv->parent_texture));
cogl_texture = clutter_texture_get_cogl_texture (parent_texture); cogl_texture = clutter_texture_get_cogl_texture (priv->parent_texture);
if (cogl_texture == COGL_INVALID_HANDLE) if (cogl_texture == COGL_INVALID_HANDLE)
return; return;
cogl_push_matrix ();
tex_width = cogl_texture_get_width (cogl_texture); tex_width = cogl_texture_get_width (cogl_texture);
tex_height = cogl_texture_get_height (cogl_texture); tex_height = cogl_texture_get_height (cogl_texture);
clutter_actor_get_size (self, &width, &height); clutter_actor_get_allocation_box (self, &box);
width = box.x2 - box.x1;
height = box.y2 - box.y1;
tx1 = CLUTTER_INT_TO_FIXED (priv->left) / tex_width; tx1 = priv->left / tex_width;
tx2 = CLUTTER_INT_TO_FIXED (tex_width - priv->right) / tex_width; tx2 = (tex_width - priv->right) / tex_width;
ty1 = CLUTTER_INT_TO_FIXED (priv->top) / tex_height; ty1 = priv->top / tex_height;
ty2 = CLUTTER_INT_TO_FIXED (tex_height - priv->bottom) / tex_height; ty2 = (tex_height - priv->bottom) / tex_height;
col.alpha = clutter_actor_get_paint_opacity (self);
cogl_set_source_color4ub (col.red, col.green, col.blue, col.alpha);
ex = width - priv->right; ex = width - priv->right;
if (ex < 0) if (ex < 0)
@ -112,228 +205,278 @@ tidy_texture_frame_paint (ClutterActor *self)
if (ey < 0) if (ey < 0)
ey = priv->bottom; /* FIXME ? */ ey = priv->bottom; /* FIXME ? */
#define FX(x) CLUTTER_INT_TO_FIXED(x) opacity = clutter_actor_get_paint_opacity (self);
g_assert (priv->material != COGL_INVALID_HANDLE);
/* set the source material using the parent texture's COGL handle */
cogl_material_set_color4ub (priv->material, 255, 255, 255, opacity);
cogl_material_set_layer (priv->material, 0, cogl_texture);
cogl_set_source (priv->material);
/* top left corner */ /* top left corner */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (0, 0, priv->left, priv->top,
cogl_rectangle_with_texture_coords (0, 0.0, 0.0,
0, tx1, ty1);
FX(priv->left), /* FIXME: clip if smaller */
FX(priv->top),
0,
0,
tx1,
ty1);
/* top middle */ /* top middle */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (priv->left, 0, ex, priv->top,
cogl_rectangle_with_texture_coords (FX(priv->left), tx1, 0.0,
0, tx2, ty1);
FX(ex),
FX(priv->top),
tx1,
0,
tx2,
ty1);
/* top right */ /* top right */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (ex, 0, width, priv->top,
cogl_rectangle_with_texture_coords (FX(ex), tx2, 0.0,
0, 1.0, ty1);
FX(width),
FX(priv->top),
tx2,
0,
CFX_ONE,
ty1);
/* mid left */ /* mid left */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (0, priv->top, priv->left, ey,
cogl_rectangle_with_texture_coords ( 0.0, ty1,
0, tx1, ty2);
FX(priv->top),
FX(priv->left),
FX(ey),
0,
ty1,
tx1,
ty2);
/* center */ /* center */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (priv->left, priv->top, ex, ey,
cogl_rectangle_with_texture_coords ( tx1, ty1,
FX(priv->left), tx2, ty2);
FX(priv->top),
FX(ex),
FX(ey),
tx1,
ty1,
tx2,
ty2);
/* mid right */ /* mid right */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (ex, priv->top, width, ey,
cogl_rectangle_with_texture_coords ( tx2, ty1,
FX(ex), 1.0, ty2);
FX(priv->top),
FX(width),
FX(ey),
tx2,
ty1,
CFX_ONE,
ty2);
/* bottom left */ /* bottom left */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (0, ey, priv->left, height,
cogl_rectangle_with_texture_coords ( 0.0, ty2,
0, tx1, 1.0);
FX(ey),
FX(priv->left),
FX(height),
0,
ty2,
tx1,
CFX_ONE);
/* bottom center */ /* bottom center */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (priv->left, ey, ex, height,
cogl_rectangle_with_texture_coords ( tx1, ty2,
FX(priv->left), tx2, 1.0);
FX(ey),
FX(ex),
FX(height),
tx1,
ty2,
tx2,
CFX_ONE);
/* bottom right */ /* bottom right */
cogl_set_source_texture (cogl_texture); cogl_rectangle_with_texture_coords (ex, ey, width, height,
cogl_rectangle_with_texture_coords ( tx2, ty2,
FX(ex), 1.0, 1.0);
FX(ey),
FX(width),
FX(height),
tx2,
ty2,
CFX_ONE,
CFX_ONE);
cogl_pop_matrix ();
} }
static inline void
tidy_texture_frame_set_frame_internal (TidyTextureFrame *frame,
gfloat left,
gfloat top,
gfloat right,
gfloat bottom)
{
TidyTextureFramePrivate *priv = frame->priv;
GObject *gobject = G_OBJECT (frame);
gboolean changed = FALSE;
g_object_freeze_notify (gobject);
if (priv->top != top)
{
priv->top = top;
g_object_notify (gobject, "top");
changed = TRUE;
}
if (priv->right != right)
{
priv->right = right;
g_object_notify (gobject, "right");
changed = TRUE;
}
if (priv->bottom != bottom)
{
priv->bottom = bottom;
g_object_notify (gobject, "bottom");
changed = TRUE;
}
if (priv->left != left)
{
priv->left = left;
g_object_notify (gobject, "left");
changed = TRUE;
}
if (changed && CLUTTER_ACTOR_IS_VISIBLE (frame))
clutter_actor_queue_redraw (CLUTTER_ACTOR (frame));
g_object_thaw_notify (gobject);
}
static void static void
tidy_texture_frame_set_property (GObject *object, tidy_texture_frame_set_property (GObject *gobject,
guint prop_id, guint prop_id,
const GValue *value, const GValue *value,
GParamSpec *pspec) GParamSpec *pspec)
{ {
TidyTextureFrame *ctexture = TIDY_TEXTURE_FRAME (object); TidyTextureFrame *frame = TIDY_TEXTURE_FRAME (gobject);
TidyTextureFramePrivate *priv = ctexture->priv; TidyTextureFramePrivate *priv = frame->priv;
switch (prop_id) switch (prop_id)
{ {
case PROP_LEFT: case PROP_PARENT_TEXTURE:
priv->left = g_value_get_int (value); tidy_texture_frame_set_parent_texture (frame,
g_value_get_object (value));
break; break;
case PROP_TOP: case PROP_TOP:
priv->top = g_value_get_int (value); tidy_texture_frame_set_frame_internal (frame,
priv->left,
g_value_get_float (value),
priv->right,
priv->bottom);
break; break;
case PROP_RIGHT: case PROP_RIGHT:
priv->right = g_value_get_int (value); tidy_texture_frame_set_frame_internal (frame,
priv->top,
g_value_get_float (value),
priv->bottom,
priv->left);
break; break;
case PROP_BOTTOM: case PROP_BOTTOM:
priv->bottom = g_value_get_int (value); tidy_texture_frame_set_frame_internal (frame,
priv->top,
priv->right,
g_value_get_float (value),
priv->left);
break; break;
case PROP_LEFT:
tidy_texture_frame_set_frame_internal (frame,
priv->top,
priv->right,
priv->bottom,
g_value_get_float (value));
break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break; break;
} }
} }
static void static void
tidy_texture_frame_get_property (GObject *object, tidy_texture_frame_get_property (GObject *gobject,
guint prop_id, guint prop_id,
GValue *value, GValue *value,
GParamSpec *pspec) GParamSpec *pspec)
{ {
TidyTextureFrame *ctexture = TIDY_TEXTURE_FRAME (object); TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (gobject)->priv;
TidyTextureFramePrivate *priv = ctexture->priv;
switch (prop_id) switch (prop_id)
{ {
case PROP_PARENT_TEXTURE:
g_value_set_object (value, priv->parent_texture);
break;
case PROP_LEFT: case PROP_LEFT:
g_value_set_int (value, priv->left); g_value_set_float (value, priv->left);
break; break;
case PROP_TOP: case PROP_TOP:
g_value_set_int (value, priv->top); g_value_set_float (value, priv->top);
break; break;
case PROP_RIGHT: case PROP_RIGHT:
g_value_set_int (value, priv->right); g_value_set_float (value, priv->right);
break; break;
case PROP_BOTTOM: case PROP_BOTTOM:
g_value_set_int (value, priv->bottom); g_value_set_float (value, priv->bottom);
break; break;
default: default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break; break;
} }
} }
static void
tidy_texture_frame_dispose (GObject *gobject)
{
TidyTextureFramePrivate *priv = TIDY_TEXTURE_FRAME (gobject)->priv;
if (priv->parent_texture)
{
g_object_unref (priv->parent_texture);
priv->parent_texture = NULL;
}
if (priv->material)
{
cogl_material_unref (priv->material);
priv->material = COGL_INVALID_HANDLE;
}
G_OBJECT_CLASS (tidy_texture_frame_parent_class)->dispose (gobject);
}
static void static void
tidy_texture_frame_class_init (TidyTextureFrameClass *klass) tidy_texture_frame_class_init (TidyTextureFrameClass *klass)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass); ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
GParamSpec *pspec;
g_type_class_add_private (gobject_class, sizeof (TidyTextureFramePrivate));
actor_class->get_preferred_width =
tidy_texture_frame_get_preferred_width;
actor_class->get_preferred_height =
tidy_texture_frame_get_preferred_height;
actor_class->realize = tidy_texture_frame_realize;
actor_class->unrealize = tidy_texture_frame_unrealize;
actor_class->paint = tidy_texture_frame_paint; actor_class->paint = tidy_texture_frame_paint;
gobject_class->set_property = tidy_texture_frame_set_property; gobject_class->set_property = tidy_texture_frame_set_property;
gobject_class->get_property = tidy_texture_frame_get_property; gobject_class->get_property = tidy_texture_frame_get_property;
gobject_class->dispose = tidy_texture_frame_dispose;
g_object_class_install_property pspec = g_param_spec_object ("parent-texture",
(gobject_class, "Parent Texture",
PROP_LEFT, "The parent ClutterTexture",
g_param_spec_int ("left", CLUTTER_TYPE_TEXTURE,
"left", TIDY_PARAM_READWRITE |
"", G_PARAM_CONSTRUCT);
0, G_MAXINT, g_object_class_install_property (gobject_class, PROP_PARENT_TEXTURE, pspec);
0,
TIDY_PARAM_READWRITE));
g_object_class_install_property pspec = g_param_spec_float ("left",
(gobject_class, "Left",
PROP_TOP, "Left offset",
g_param_spec_int ("top", 0, G_MAXFLOAT,
"top", 0,
"", TIDY_PARAM_READWRITE);
0, G_MAXINT, g_object_class_install_property (gobject_class, PROP_LEFT, pspec);
0,
TIDY_PARAM_READWRITE));
g_object_class_install_property pspec = g_param_spec_float ("top",
(gobject_class, "Top",
PROP_BOTTOM, "Top offset",
g_param_spec_int ("bottom", 0, G_MAXFLOAT,
"bottom", 0,
"", TIDY_PARAM_READWRITE);
0, G_MAXINT, g_object_class_install_property (gobject_class, PROP_TOP, pspec);
0,
TIDY_PARAM_READWRITE));
g_object_class_install_property pspec = g_param_spec_float ("bottom",
(gobject_class, "Bottom",
PROP_RIGHT, "Bottom offset",
g_param_spec_int ("right", 0, G_MAXFLOAT,
"right", 0,
"", TIDY_PARAM_READWRITE);
0, G_MAXINT, g_object_class_install_property (gobject_class, PROP_BOTTOM, pspec);
0,
TIDY_PARAM_READWRITE));
g_type_class_add_private (gobject_class, sizeof (TidyTextureFramePrivate)); pspec = g_param_spec_float ("right",
"Right",
"Right offset",
0, G_MAXFLOAT,
0,
TIDY_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_RIGHT, pspec);
} }
static void static void
@ -342,14 +485,33 @@ tidy_texture_frame_init (TidyTextureFrame *self)
TidyTextureFramePrivate *priv; TidyTextureFramePrivate *priv;
self->priv = priv = TIDY_TEXTURE_FRAME_GET_PRIVATE (self); self->priv = priv = TIDY_TEXTURE_FRAME_GET_PRIVATE (self);
priv->material = COGL_INVALID_HANDLE;
} }
ClutterActor * /**
* tidy_texture_frame_new:
* @texture: a #ClutterTexture or %NULL
* @left: left margin preserving its content
* @top: top margin preserving its content
* @right: right margin preserving its content
* @bottom: bottom margin preserving its content
*
* A #TidyTextureFrame is a specialized texture that efficiently clones
* an area of the given @texture while keeping preserving portions of the
* same texture.
*
* A #TidyTextureFrame can be used to make a rectangular texture fit a
* given size without stretching its borders.
*
* Return value: the newly created #TidyTextureFrame
*/
ClutterActor*
tidy_texture_frame_new (ClutterTexture *texture, tidy_texture_frame_new (ClutterTexture *texture,
gint left, gfloat left,
gint top, gfloat top,
gint right, gfloat right,
gint bottom) gfloat bottom)
{ {
g_return_val_if_fail (texture == NULL || CLUTTER_IS_TEXTURE (texture), NULL); g_return_val_if_fail (texture == NULL || CLUTTER_IS_TEXTURE (texture), NULL);
@ -362,3 +524,87 @@ tidy_texture_frame_new (ClutterTexture *texture,
NULL); NULL);
} }
ClutterTexture *
tidy_texture_frame_get_parent_texture (TidyTextureFrame *frame)
{
g_return_val_if_fail (TIDY_IS_TEXTURE_FRAME (frame), NULL);
return frame->priv->parent_texture;
}
void
tidy_texture_frame_set_parent_texture (TidyTextureFrame *frame,
ClutterTexture *texture)
{
TidyTextureFramePrivate *priv;
gboolean was_visible;
g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
g_return_if_fail (texture == NULL || CLUTTER_IS_TEXTURE (texture));
priv = frame->priv;
was_visible = CLUTTER_ACTOR_IS_VISIBLE (frame);
if (priv->parent_texture == texture)
return;
if (priv->parent_texture)
{
g_object_unref (priv->parent_texture);
priv->parent_texture = NULL;
if (was_visible)
clutter_actor_hide (CLUTTER_ACTOR (frame));
}
if (texture)
{
priv->parent_texture = g_object_ref (texture);
if (was_visible && CLUTTER_ACTOR_IS_VISIBLE (priv->parent_texture))
clutter_actor_show (CLUTTER_ACTOR (frame));
}
clutter_actor_queue_relayout (CLUTTER_ACTOR (frame));
g_object_notify (G_OBJECT (frame), "parent-texture");
}
void
tidy_texture_frame_set_frame (TidyTextureFrame *frame,
gfloat top,
gfloat right,
gfloat bottom,
gfloat left)
{
g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
tidy_texture_frame_set_frame_internal (frame, top, right, bottom, left);
}
void
tidy_texture_frame_get_frame (TidyTextureFrame *frame,
gfloat *top,
gfloat *right,
gfloat *bottom,
gfloat *left)
{
TidyTextureFramePrivate *priv;
g_return_if_fail (TIDY_IS_TEXTURE_FRAME (frame));
priv = frame->priv;
if (top)
*top = priv->top;
if (right)
*right = priv->right;
if (bottom)
*bottom = priv->bottom;
if (left)
*left = priv->left;
}

67
src/compositor/mutter/tidy/tidy-texture-frame.h
View File

@ -1,6 +1,7 @@
/* tidy-texture-frame.h: Expandible texture actor /* tidy-texture-frame.h: Expandible texture actor
* *
* Copyright (C) 2007 OpenedHand * Copyright (C) 2007, 2008 OpenedHand Ltd
* Copyright (C) 2009 Intel Corp.
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -25,43 +26,28 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define TIDY_TYPE_TEXTURE_FRAME (tidy_texture_frame_get_type ()) #define TIDY_TYPE_TEXTURE_FRAME (tidy_texture_frame_get_type ())
#define TIDY_TEXTURE_FRAME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrame))
#define TIDY_TEXTURE_FRAME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrameClass))
#define TIDY_IS_TEXTURE_FRAME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TIDY_TYPE_TEXTURE_FRAME))
#define TIDY_IS_TEXTURE_FRAME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TIDY_TYPE_TEXTURE_FRAME))
#define TIDY_TEXTURE_FRAME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrameClass))
#define TIDY_TEXTURE_FRAME(obj) \ typedef struct _TidyTextureFrame TidyTextureFrame;
(G_TYPE_CHECK_INSTANCE_CAST ((obj), \ typedef struct _TidyTextureFramePrivate TidyTextureFramePrivate;
TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrame)) typedef struct _TidyTextureFrameClass TidyTextureFrameClass;
#define TIDY_TEXTURE_FRAME_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST ((klass), \
TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrameClass))
#define TIDY_IS_TEXTURE_FRAME(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
TIDY_TYPE_TEXTURE_FRAME))
#define TIDY_IS_TEXTURE_FRAME_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE ((klass), \
TIDY_TYPE_TEXTURE_FRAME))
#define TIDY_TEXTURE_FRAME_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS ((obj), \
TIDY_TYPE_TEXTURE_FRAME, TidyTextureFrameClass))
typedef struct _TidyTextureFrame TidyTextureFrame;
typedef struct _TidyTextureFramePrivate TidyTextureFramePrivate;
typedef struct _TidyTextureFrameClass TidyTextureFrameClass;
struct _TidyTextureFrame struct _TidyTextureFrame
{ {
ClutterCloneTexture parent; /*< private >*/
ClutterActor parent_instance;
/*< priv >*/
TidyTextureFramePrivate *priv; TidyTextureFramePrivate *priv;
}; };
struct _TidyTextureFrameClass struct _TidyTextureFrameClass
{ {
ClutterCloneTextureClass parent_class; ClutterActorClass parent_class;
/* padding for future expansion */ /* padding for future expansion */
void (*_clutter_box_1) (void); void (*_clutter_box_1) (void);
@ -70,12 +56,25 @@ struct _TidyTextureFrameClass
void (*_clutter_box_4) (void); void (*_clutter_box_4) (void);
}; };
GType tidy_texture_frame_get_type (void) G_GNUC_CONST; GType tidy_texture_frame_get_type (void) G_GNUC_CONST;
ClutterActor *tidy_texture_frame_new (ClutterTexture *texture, ClutterActor * tidy_texture_frame_new (ClutterTexture *texture,
gint left, gfloat top,
gint top, gfloat right,
gint right, gfloat bottom,
gint bottom); gfloat left);
void tidy_texture_frame_set_parent_texture (TidyTextureFrame *frame,
ClutterTexture *texture);
ClutterTexture *tidy_texture_frame_get_parent_texture (TidyTextureFrame *frame);
void tidy_texture_frame_set_frame (TidyTextureFrame *frame,
gfloat top,
gfloat right,
gfloat bottom,
gfloat left);
void tidy_texture_frame_get_frame (TidyTextureFrame *frame,
gfloat *top,
gfloat *right,
gfloat *bottom,
gfloat *left);
G_END_DECLS G_END_DECLS