807 lines
21 KiB
C
807 lines
21 KiB
C
#include "config.h"
|
|
|
|
#include "cogl.h"
|
|
|
|
#include "clutter-box.h"
|
|
#include "clutter-container.h"
|
|
#include "clutter-debug.h"
|
|
#include "clutter-enum-types.h"
|
|
#include "clutter-main.h"
|
|
#include "clutter-private.h"
|
|
|
|
/**
|
|
* SECTION:clutter-box
|
|
* @short_description: Base class for layout containers
|
|
*
|
|
* #ClutterBox is a base class for containers which impose a specific layout
|
|
* on their children, unlike #ClutterGroup which is a free-form container.
|
|
*
|
|
* Layout containers are expected to move and size their children depending
|
|
* on a layout contract they establish per-class. For instance, a #ClutterHBox
|
|
* (a subclass of #ClutterBox) lays out its children along an imaginary
|
|
* horizontal line.
|
|
*
|
|
* All #ClutterBox<!-- -->es have a margin, which is decomposed in four
|
|
* components (top, right, bottom left) and a background color. Each child
|
|
* of a #ClutterBox has a packing type and a padding, decomposed like the
|
|
* margin. Actors can be packed using clutter_box_pack() and providing
|
|
* the packing type and the padding, or using clutter_box_pack_defaults()
|
|
* and setting a default padding with clutter_box_set_default_padding().
|
|
* A #ClutterBox implements the #ClutterContainer interface: calling
|
|
* clutter_container_add_actor() on a #ClutterBox will automatically invoke
|
|
* clutter_box_pack_defaults().
|
|
*
|
|
* Each child of a #ClutterBox has its packing information wrapped into the
|
|
* #ClutterBoxChild structure, which can be retrieved either using the
|
|
* clutter_box_query_child() or the clutter_box_query_nth_child() function.
|
|
*
|
|
* Subclasses of #ClutterBox must implement the ClutterBox::pack_child and
|
|
* ClutterBox::unpack_child virtual functions; these functions will be called
|
|
* when adding a child and when removing one, respectively.
|
|
*
|
|
* #ClutterBox is available since Clutter 0.4
|
|
*/
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
|
|
PROP_MARGIN,
|
|
PROP_COLOR
|
|
};
|
|
|
|
static void clutter_container_iface_init (ClutterContainerIface *iface);
|
|
|
|
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (ClutterBox,
|
|
clutter_box,
|
|
CLUTTER_TYPE_ACTOR,
|
|
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
|
|
clutter_container_iface_init));
|
|
|
|
|
|
static void
|
|
clutter_box_add (ClutterContainer *container,
|
|
ClutterActor *actor)
|
|
{
|
|
clutter_box_pack_defaults (CLUTTER_BOX (container), actor);
|
|
}
|
|
|
|
static void
|
|
clutter_box_remove (ClutterContainer *container,
|
|
ClutterActor *actor)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (container);
|
|
GList *l;
|
|
|
|
g_object_ref (actor);
|
|
|
|
for (l = box->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
if (child->actor == actor)
|
|
{
|
|
CLUTTER_BOX_GET_CLASS (box)->unpack_child (box, child);
|
|
|
|
clutter_actor_unparent (actor);
|
|
|
|
box->children = g_list_remove_link (box->children, l);
|
|
g_list_free (l);
|
|
g_slice_free (ClutterBoxChild, child);
|
|
|
|
g_signal_emit_by_name (container, "actor-removed", actor);
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR (box)))
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (box));
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_object_unref (actor);
|
|
}
|
|
|
|
static void
|
|
clutter_box_foreach (ClutterContainer *container,
|
|
ClutterCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (container);
|
|
GList *l;
|
|
|
|
for (l = box->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
if (child->pack_type == CLUTTER_PACK_START)
|
|
(* callback) (child->actor, user_data);
|
|
}
|
|
|
|
for (l = g_list_last (box->children); l; l = l->prev)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
if (child->pack_type == CLUTTER_PACK_END)
|
|
(* callback) (child->actor, user_data);
|
|
}
|
|
}
|
|
|
|
static ClutterActor *
|
|
clutter_box_find_child_by_id (ClutterContainer *container,
|
|
guint child_id)
|
|
{
|
|
ClutterBox *self = CLUTTER_BOX (container);
|
|
ClutterActor *actor = NULL;
|
|
GList *l;
|
|
|
|
if (clutter_actor_get_id (CLUTTER_ACTOR (self)) == child_id)
|
|
return CLUTTER_ACTOR (self);
|
|
|
|
for (l = self->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
if (clutter_actor_get_id (child->actor) == child_id)
|
|
{
|
|
actor = child->actor;
|
|
break;
|
|
}
|
|
|
|
if (CLUTTER_IS_CONTAINER (child->actor))
|
|
{
|
|
ClutterContainer *c = CLUTTER_CONTAINER (child->actor);
|
|
|
|
actor = clutter_container_find_child_by_id (c, child_id);
|
|
if (actor)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return actor;
|
|
}
|
|
|
|
static void
|
|
clutter_container_iface_init (ClutterContainerIface *iface)
|
|
{
|
|
iface->add = clutter_box_add;
|
|
iface->remove = clutter_box_remove;
|
|
iface->foreach = clutter_box_foreach;
|
|
iface->find_child_by_id = clutter_box_find_child_by_id;
|
|
}
|
|
|
|
static void
|
|
clutter_box_show_all (ClutterActor *actor)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (actor);
|
|
GList *l;
|
|
|
|
for (l = box->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
clutter_actor_show (child->actor);
|
|
}
|
|
|
|
clutter_actor_show (actor);
|
|
}
|
|
|
|
static void
|
|
clutter_box_hide_all (ClutterActor *actor)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (actor);
|
|
GList *l;
|
|
|
|
clutter_actor_hide (actor);
|
|
|
|
for (l = box->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
clutter_actor_hide (child->actor);
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_box_paint (ClutterActor *actor)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (actor);
|
|
GList *l;
|
|
|
|
cogl_push_matrix ();
|
|
|
|
cogl_color (&box->color);
|
|
|
|
for (l = box->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
if (CLUTTER_ACTOR_IS_MAPPED (child->actor))
|
|
clutter_actor_paint (child->actor);
|
|
}
|
|
|
|
cogl_pop_matrix ();
|
|
}
|
|
|
|
static void
|
|
clutter_box_pick (ClutterActor *actor,
|
|
const ClutterColor *color)
|
|
{
|
|
/* just repaint; in the future we might enter in a "focused" status here */
|
|
clutter_box_paint (actor);
|
|
}
|
|
|
|
static void
|
|
clutter_box_dispose (GObject *gobject)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (gobject);
|
|
GList *l;
|
|
|
|
for (l = box->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *child = l->data;
|
|
|
|
clutter_actor_destroy (child->actor);
|
|
g_slice_free (ClutterBoxChild, child);
|
|
}
|
|
|
|
g_list_free (box->children);
|
|
box->children = NULL;
|
|
|
|
G_OBJECT_CLASS (clutter_box_parent_class)->dispose (gobject);
|
|
}
|
|
|
|
static void
|
|
clutter_box_pack_child_unimplemented (ClutterBox *box,
|
|
ClutterBoxChild *child)
|
|
{
|
|
g_warning ("ClutterBox of type `%s' does not implement the "
|
|
"ClutterBox::pack_child method.",
|
|
g_type_name (G_OBJECT_TYPE (box)));
|
|
}
|
|
|
|
static void
|
|
clutter_box_unpack_child_unimplemented (ClutterBox *box,
|
|
ClutterBoxChild *child)
|
|
{
|
|
g_warning ("ClutterBox of type `%s' does not implement the "
|
|
"ClutterBox::unpack_child method.",
|
|
g_type_name (G_OBJECT_TYPE (box)));
|
|
}
|
|
|
|
static void
|
|
clutter_box_set_property (GObject *gobject,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (gobject);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_COLOR:
|
|
clutter_box_set_color (box, g_value_get_boxed (value));
|
|
break;
|
|
case PROP_MARGIN:
|
|
clutter_box_set_margin (box, g_value_get_boxed (value));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_box_get_property (GObject *gobject,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
ClutterBox *box = CLUTTER_BOX (gobject);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_MARGIN:
|
|
{
|
|
ClutterMargin margin;
|
|
clutter_box_get_margin (box, &margin);
|
|
g_value_set_boxed (value, &margin);
|
|
}
|
|
break;
|
|
case PROP_COLOR:
|
|
{
|
|
ClutterColor color;
|
|
clutter_box_get_color (box, &color);
|
|
g_value_set_boxed (value, &color);
|
|
}
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
clutter_box_class_init (ClutterBoxClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
|
|
|
|
gobject_class->set_property = clutter_box_set_property;
|
|
gobject_class->get_property = clutter_box_get_property;
|
|
gobject_class->dispose = clutter_box_dispose;
|
|
|
|
actor_class->show_all = clutter_box_show_all;
|
|
actor_class->hide_all = clutter_box_hide_all;
|
|
actor_class->paint = clutter_box_paint;
|
|
actor_class->pick = clutter_box_pick;
|
|
|
|
klass->pack_child = clutter_box_pack_child_unimplemented;
|
|
klass->unpack_child = clutter_box_unpack_child_unimplemented;
|
|
|
|
/**
|
|
* ClutterBox:margin:
|
|
*
|
|
* The margin between the inner border of a #ClutterBox and its
|
|
* children.
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_MARGIN,
|
|
g_param_spec_boxed ("margin",
|
|
"Margin",
|
|
"Margin between the inner border of a box and its children",
|
|
CLUTTER_TYPE_MARGIN,
|
|
CLUTTER_PARAM_READWRITE));
|
|
/**
|
|
* ClutterBox:color:
|
|
*
|
|
* The background color of a #ClutterBox.
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
g_object_class_install_property (gobject_class,
|
|
PROP_COLOR,
|
|
g_param_spec_boxed ("color",
|
|
"Color",
|
|
"Background color of a box",
|
|
CLUTTER_TYPE_COLOR,
|
|
CLUTTER_PARAM_READWRITE));
|
|
}
|
|
|
|
static void
|
|
clutter_box_init (ClutterBox *box)
|
|
{
|
|
box->allocation.x1 = box->allocation.y1 = 0;
|
|
box->allocation.x2 = box->allocation.y2 = -1;
|
|
}
|
|
|
|
/*
|
|
* Public API
|
|
*/
|
|
|
|
/**
|
|
* clutter_box_pack:
|
|
* @box: a #ClutterBox
|
|
* @actor: a #ClutterActor to pack into the box
|
|
* @pack_type: Type of packing to use
|
|
* @padding: padding to use on the actor
|
|
*
|
|
* Packs @actor into @box.
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_pack (ClutterBox *box,
|
|
ClutterActor *actor,
|
|
ClutterPackType pack_type,
|
|
const ClutterPadding *padding)
|
|
{
|
|
ClutterBoxChild *child;
|
|
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
|
|
g_return_if_fail (padding != NULL);
|
|
|
|
child = g_slice_new (ClutterBoxChild);
|
|
child->actor = actor;
|
|
child->pack_type = pack_type;
|
|
memcpy (&(child->padding), padding, sizeof (ClutterPadding));
|
|
|
|
CLUTTER_BOX_GET_CLASS (box)->pack_child (box, child);
|
|
|
|
box->children = g_list_prepend (box->children, child);
|
|
clutter_actor_set_parent (actor, CLUTTER_ACTOR (box));
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR (box)))
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (box));
|
|
}
|
|
|
|
/**
|
|
* clutter_box_pack_defaults:
|
|
* @box: a #ClutterBox
|
|
* @actor: a #ClutterActor
|
|
*
|
|
* Packs @actor into @box, using the default settings for the
|
|
* pack type and padding.
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_pack_defaults (ClutterBox *box,
|
|
ClutterActor *actor)
|
|
{
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
|
|
|
|
clutter_box_pack (box, actor,
|
|
CLUTTER_PACK_START,
|
|
&box->default_padding);
|
|
}
|
|
|
|
/**
|
|
* clutter_box_query_child:
|
|
* @box: a #ClutterBox
|
|
* @actor: child to query
|
|
* @child: return location for a #ClutterBoxChild or %NULL
|
|
*
|
|
* Queries @box for the packing data of @actor.
|
|
*
|
|
* Return value: %TRUE if @actor is a child of @box
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
gboolean
|
|
clutter_box_query_child (ClutterBox *box,
|
|
ClutterActor *actor,
|
|
ClutterBoxChild *child)
|
|
{
|
|
GList *l;
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BOX (box), FALSE);
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
|
|
|
|
for (l = box->children; l; l = l->next)
|
|
{
|
|
ClutterBoxChild *box_child = l->data;
|
|
|
|
if (box_child->actor == actor)
|
|
{
|
|
if (child)
|
|
{
|
|
child->actor = actor;
|
|
|
|
child->pack_type = box_child->pack_type;
|
|
|
|
child->child_coords.x1 = box_child->child_coords.x1;
|
|
child->child_coords.y1 = box_child->child_coords.y1;
|
|
child->child_coords.x2 = box_child->child_coords.x2;
|
|
child->child_coords.y2 = box_child->child_coords.y2;
|
|
|
|
child->padding.top = box_child->padding.top;
|
|
child->padding.right = box_child->padding.right;
|
|
child->padding.bottom = box_child->padding.bottom;
|
|
child->padding.left = box_child->padding.left;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* clutter_box_query_nth_child:
|
|
* @box: a #ClutterBox
|
|
* @index_: position of the child
|
|
* @child: return value for a #ClutterBoxChild, or %NULL
|
|
*
|
|
* Queries the child of @box at @index_ and puts the packing informations
|
|
* inside @child.
|
|
*
|
|
* Return value: %TRUE if an actor was found at @index_
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
gboolean
|
|
clutter_box_query_nth_child (ClutterBox *box,
|
|
gint index_,
|
|
ClutterBoxChild *child)
|
|
{
|
|
ClutterBoxChild *box_child;
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_BOX (box), FALSE);
|
|
g_return_val_if_fail (index_ > 0, FALSE);
|
|
|
|
box_child = g_list_nth_data (box->children, index_);
|
|
if (!box_child)
|
|
return FALSE;
|
|
|
|
if (child)
|
|
{
|
|
child->actor = box_child->actor;
|
|
|
|
child->pack_type = box_child->pack_type;
|
|
|
|
child->child_coords.x1 = box_child->child_coords.x1;
|
|
child->child_coords.y1 = box_child->child_coords.y1;
|
|
child->child_coords.x2 = box_child->child_coords.x2;
|
|
child->child_coords.y2 = box_child->child_coords.y2;
|
|
|
|
child->padding.top = box_child->padding.top;
|
|
child->padding.right = box_child->padding.right;
|
|
child->padding.bottom = box_child->padding.bottom;
|
|
child->padding.left = box_child->padding.left;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* clutter_box_get_margin:
|
|
* @box: a #ClutterBox
|
|
* @margin: return location for a #ClutterMargin
|
|
*
|
|
* Gets the value set using clutter_box_set_margin().
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_get_margin (ClutterBox *box,
|
|
ClutterMargin *margin)
|
|
{
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
g_return_if_fail (margin != NULL);
|
|
|
|
margin->top = box->margin.top;
|
|
margin->right = box->margin.right;
|
|
margin->bottom = box->margin.bottom;
|
|
margin->left = box->margin.left;
|
|
}
|
|
|
|
/**
|
|
* clutter_box_set_margin:
|
|
* @box: a #ClutterBox
|
|
* @margin: a #ClutterMargin, or %NULL to unset the margin
|
|
*
|
|
* Sets the margin, in #ClutterUnit<!-- -->s, between the inner border
|
|
* of the box and the children of the box.
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_set_margin (ClutterBox *box,
|
|
const ClutterMargin *margin)
|
|
{
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
|
|
if (margin)
|
|
{
|
|
box->margin.top = margin->top;
|
|
box->margin.right = margin->right;
|
|
box->margin.bottom = margin->bottom;
|
|
box->margin.left = margin->left;
|
|
}
|
|
else
|
|
{
|
|
box->margin.top = 0;
|
|
box->margin.right = 0;
|
|
box->margin.bottom = 0;
|
|
box->margin.left = 0;
|
|
}
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR (box)))
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (box));
|
|
|
|
g_object_notify (G_OBJECT (box), "margin");
|
|
}
|
|
|
|
/**
|
|
* clutter_box_get_color:
|
|
* @box: a #ClutterBox
|
|
* @color: return location for the color
|
|
*
|
|
* Gets the background color of the box set with clutter_box_set_color().
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_get_color (ClutterBox *box,
|
|
ClutterColor *color)
|
|
{
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
g_return_if_fail (color != NULL);
|
|
|
|
color->red = box->color.red;
|
|
color->green = box->color.green;
|
|
color->blue = box->color.blue;
|
|
color->alpha = box->color.alpha;
|
|
}
|
|
|
|
/**
|
|
* clutter_box_set_color:
|
|
* @box: a #ClutterBox
|
|
* @color: the background color of the box
|
|
*
|
|
* Sets the background color of the box.
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_set_color (ClutterBox *box,
|
|
const ClutterColor *color)
|
|
{
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
g_return_if_fail (color != NULL);
|
|
|
|
box->color.red = color->red;
|
|
box->color.green = color->green;
|
|
box->color.blue = color->blue;
|
|
box->color.alpha = color->alpha;
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR (box)))
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (box));
|
|
|
|
g_object_notify (G_OBJECT (box), "color");
|
|
}
|
|
|
|
/**
|
|
* clutter_box_remove_all:
|
|
* @box: a #ClutterBox
|
|
*
|
|
* Removes all children actors from the #ClutterBox
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_remove_all (ClutterBox *box)
|
|
{
|
|
GList *children;
|
|
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
|
|
children = box->children;
|
|
while (children)
|
|
{
|
|
ClutterBoxChild *child = children->data;
|
|
children = children->next;
|
|
|
|
clutter_container_remove_actor (CLUTTER_CONTAINER (box), child->actor);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* clutter_box_set_default_padding:
|
|
* @box: a #ClutterBox
|
|
* @padding_top: top padding, in pixels
|
|
* @padding_right: right padding, in pixels
|
|
* @padding_bottom: bottom padding, in pixels
|
|
* @padding_left: left padding, in pixels
|
|
*
|
|
* Sets the default padding for children, which will be used when
|
|
* packing actors with clutter_box_pack_defaults(). The padding is
|
|
* given in pixels.
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_set_default_padding (ClutterBox *box,
|
|
gint padding_top,
|
|
gint padding_right,
|
|
gint padding_bottom,
|
|
gint padding_left)
|
|
{
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
|
|
box->default_padding.top = CLUTTER_UNITS_FROM_INT (padding_top);
|
|
box->default_padding.right = CLUTTER_UNITS_FROM_INT (padding_right);
|
|
box->default_padding.bottom = CLUTTER_UNITS_FROM_INT (padding_bottom);
|
|
box->default_padding.left = CLUTTER_UNITS_FROM_INT (padding_left);
|
|
}
|
|
|
|
/**
|
|
* clutter_box_get_default_padding:
|
|
* @box: a #ClutterBox
|
|
* @padding_top: return location for the top padding, or %NULL
|
|
* @padding_right: return location for the right padding, or %NULL
|
|
* @padding_bottom: return location for the bottom padding, or %NULL
|
|
* @padding_left: return location for the left padding, or %NULL
|
|
*
|
|
* Gets the default padding set with clutter_box_set_default_padding().
|
|
*
|
|
* Since: 0.4
|
|
*/
|
|
void
|
|
clutter_box_get_default_padding (ClutterBox *box,
|
|
gint *padding_top,
|
|
gint *padding_right,
|
|
gint *padding_bottom,
|
|
gint *padding_left)
|
|
{
|
|
g_return_if_fail (CLUTTER_IS_BOX (box));
|
|
|
|
if (padding_top)
|
|
*padding_top = CLUTTER_UNITS_TO_INT (box->default_padding.top);
|
|
if (padding_right)
|
|
*padding_right = CLUTTER_UNITS_TO_INT (box->default_padding.right);
|
|
if (padding_bottom)
|
|
*padding_bottom = CLUTTER_UNITS_TO_INT (box->default_padding.bottom);
|
|
if (padding_left)
|
|
*padding_left = CLUTTER_UNITS_TO_INT (box->default_padding.left);
|
|
}
|
|
|
|
/*
|
|
* Boxed types
|
|
*/
|
|
|
|
static void
|
|
clutter_margin_free (ClutterMargin *margin)
|
|
{
|
|
if (G_LIKELY (margin))
|
|
{
|
|
g_slice_free (ClutterMargin, margin);
|
|
}
|
|
}
|
|
|
|
static ClutterMargin *
|
|
clutter_margin_copy (const ClutterMargin *margin)
|
|
{
|
|
ClutterMargin *copy;
|
|
|
|
g_return_val_if_fail (margin != NULL, NULL);
|
|
|
|
copy = g_slice_new (ClutterMargin);
|
|
*copy = *margin;
|
|
|
|
return copy;
|
|
}
|
|
|
|
GType
|
|
clutter_margin_get_type (void)
|
|
{
|
|
static GType gtype = 0;
|
|
|
|
if (G_UNLIKELY (gtype == 0))
|
|
gtype = g_boxed_type_register_static (g_intern_static_string ("ClutterMargin"),
|
|
(GBoxedCopyFunc) clutter_margin_copy,
|
|
(GBoxedFreeFunc) clutter_margin_free);
|
|
|
|
return gtype;
|
|
}
|
|
|
|
static void
|
|
clutter_padding_free (ClutterPadding *padding)
|
|
{
|
|
if (G_LIKELY (padding))
|
|
{
|
|
g_slice_free (ClutterPadding, padding);
|
|
}
|
|
}
|
|
|
|
static ClutterPadding *
|
|
clutter_padding_copy (const ClutterPadding *padding)
|
|
{
|
|
ClutterPadding *copy;
|
|
|
|
g_return_val_if_fail (padding != NULL, NULL);
|
|
|
|
copy = g_slice_new (ClutterPadding);
|
|
*copy = *padding;
|
|
|
|
return copy;
|
|
}
|
|
|
|
GType
|
|
clutter_padding_get_type (void)
|
|
{
|
|
static GType gtype = 0;
|
|
|
|
if (G_UNLIKELY (gtype == 0))
|
|
gtype = g_boxed_type_register_static (g_intern_static_string ("ClutterPadding"),
|
|
(GBoxedCopyFunc) clutter_padding_copy,
|
|
(GBoxedFreeFunc) clutter_padding_free);
|
|
|
|
return gtype;
|
|
}
|