mutter/tests/interactive/test-layout.c
Emmanuele Bassi b0f5350379 test-layout: Port away from Behaviour
Use a simple animation with a looping+reversing timeline.
2010-11-18 15:21:16 +00:00

825 lines
22 KiB
C

#include <stdio.h>
#include <stdlib.h>
#include <gmodule.h>
#include <cogl/cogl.h>
#include <clutter/clutter.h>
/* layout actor, by Lucas Rocha */
#define MY_TYPE_THING (my_thing_get_type ())
#define MY_THING(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MY_TYPE_THING, MyThing))
#define MY_IS_THING(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MY_TYPE_THING))
#define MY_THING_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MY_TYPE_THING, MyThingClass))
#define MY_IS_THING_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MY_TYPE_THING))
#define MY_THING_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MY_TYPE_THING, MyThingClass))
typedef struct _MyThing MyThing;
typedef struct _MyThingPrivate MyThingPrivate;
typedef struct _MyThingClass MyThingClass;
struct _MyThing
{
ClutterActor parent_instance;
MyThingPrivate *priv;
};
struct _MyThingClass
{
ClutterActorClass parent_class;
};
enum
{
PROP_0,
PROP_SPACING,
PROP_PADDING,
PROP_USE_TRANSFORMED_BOX
};
static void clutter_container_iface_init (ClutterContainerIface *iface);
G_DEFINE_TYPE_WITH_CODE (MyThing,
my_thing,
CLUTTER_TYPE_ACTOR,
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
clutter_container_iface_init));
#define MY_THING_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), MY_TYPE_THING, MyThingPrivate))
struct _MyThingPrivate
{
GList *children;
gfloat spacing;
gfloat padding;
guint use_transformed_box : 1;
};
/* Add, remove, foreach, copied from ClutterGroup code. */
static void
my_thing_real_add (ClutterContainer *container,
ClutterActor *actor)
{
MyThing *group = MY_THING (container);
MyThingPrivate *priv = group->priv;
g_object_ref (actor);
priv->children = g_list_append (priv->children, actor);
clutter_actor_set_parent (actor, CLUTTER_ACTOR (group));
g_signal_emit_by_name (container, "actor-added", actor);
/* queue relayout to allocate new item */
clutter_actor_queue_relayout (CLUTTER_ACTOR (group));
g_object_unref (actor);
}
static void
my_thing_real_remove (ClutterContainer *container,
ClutterActor *actor)
{
MyThing *group = MY_THING (container);
MyThingPrivate *priv = group->priv;
g_object_ref (actor);
priv->children = g_list_remove (priv->children, actor);
clutter_actor_unparent (actor);
/* At this point, the actor passed to the "actor-removed" signal
* handlers is not parented anymore to the container but since we
* are holding a reference on it, it's still valid
*/
g_signal_emit_by_name (container, "actor-removed", actor);
/* queue relayout to re-allocate children without the
removed item */
clutter_actor_queue_relayout (CLUTTER_ACTOR (group));
g_object_unref (actor);
}
static void
my_thing_real_foreach (ClutterContainer *container,
ClutterCallback callback,
gpointer user_data)
{
MyThingPrivate *priv = MY_THING (container)->priv;
GList *l;
for (l = priv->children; l; l = l->next)
(* callback) (CLUTTER_ACTOR (l->data), user_data);
}
static void
clutter_container_iface_init (ClutterContainerIface *iface)
{
iface->add = my_thing_real_add;
iface->remove = my_thing_real_remove;
iface->foreach = my_thing_real_foreach;
}
static void
my_thing_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MyThingPrivate *priv = MY_THING (gobject)->priv;
gboolean needs_relayout = TRUE;
switch (prop_id)
{
case PROP_SPACING:
priv->spacing = g_value_get_float (value);
break;
case PROP_PADDING:
priv->padding = g_value_get_float (value);
break;
case PROP_USE_TRANSFORMED_BOX:
priv->use_transformed_box = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
needs_relayout = FALSE;
break;
}
/* setting spacing or padding queues a relayout
because they are supposed to change the internal
allocation of children */
if (needs_relayout)
clutter_actor_queue_relayout (CLUTTER_ACTOR (gobject));
}
static void
my_thing_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MyThingPrivate *priv = MY_THING (gobject)->priv;
switch (prop_id)
{
case PROP_SPACING:
g_value_set_float (value, priv->spacing);
break;
case PROP_PADDING:
g_value_set_float (value, priv->padding);
break;
case PROP_USE_TRANSFORMED_BOX:
g_value_set_boolean (value, priv->use_transformed_box);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
my_thing_finalize (GObject *gobject)
{
G_OBJECT_CLASS (my_thing_parent_class)->finalize (gobject);
}
static void
my_thing_dispose (GObject *gobject)
{
MyThing *self = MY_THING (gobject);
MyThingPrivate *priv = self->priv;
if (priv->children)
{
g_list_foreach (priv->children, (GFunc) clutter_actor_destroy, NULL);
priv->children = NULL;
}
G_OBJECT_CLASS (my_thing_parent_class)->dispose (gobject);
}
static void
my_thing_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
MyThingPrivate *priv;
GList *l;
gfloat min_left, min_right;
gfloat natural_left, natural_right;
priv = MY_THING (self)->priv;
min_left = 0;
min_right = 0;
natural_left = 0;
natural_right = 0;
for (l = priv->children; l != NULL; l = l->next)
{
ClutterActor *child;
gfloat child_x, child_min, child_natural;
child = l->data;
child_x = clutter_actor_get_x (child);
clutter_actor_get_preferred_size (child,
&child_min, NULL,
&child_natural, NULL);
if (l == priv->children)
{
/* First child */
min_left = child_x;
natural_left = child_x;
min_right = min_left + child_min;
natural_right = natural_left + child_natural;
}
else
{
/* Union of extents with previous children */
if (child_x < min_left)
min_left = child_x;
if (child_x < natural_left)
natural_left = child_x;
if (child_x + child_min > min_right)
min_right = child_x + child_min;
if (child_x + child_natural > natural_right)
natural_right = child_x + child_natural;
}
}
if (min_left < 0)
min_left = 0;
if (natural_left < 0)
natural_left = 0;
if (min_right < 0)
min_right = 0;
if (natural_right < 0)
natural_right = 0;
g_assert (min_right >= min_left);
g_assert (natural_right >= natural_left);
if (min_width_p)
*min_width_p = min_right - min_left;
if (natural_width_p)
*natural_width_p = natural_right - min_left;
}
static void
my_thing_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
MyThingPrivate *priv;
GList *l;
gfloat min_top, min_bottom;
gfloat natural_top, natural_bottom;
priv = MY_THING (self)->priv;
min_top = 0;
min_bottom = 0;
natural_top = 0;
natural_bottom = 0;
for (l = priv->children; l != NULL; l = l->next)
{
ClutterActor *child;
gfloat child_y, child_min, child_natural;
child = l->data;
child_y = clutter_actor_get_y (child);
clutter_actor_get_preferred_size (child,
NULL, &child_min,
NULL, &child_natural);
if (l == priv->children)
{
/* First child */
min_top = child_y;
natural_top = child_y;
min_bottom = min_top + child_min;
natural_bottom = natural_top + child_natural;
}
else
{
/* Union of extents with previous children */
if (child_y < min_top)
min_top = child_y;
if (child_y < natural_top)
natural_top = child_y;
if (child_y + child_min > min_bottom)
min_bottom = child_y + child_min;
if (child_y + child_natural > natural_bottom)
natural_bottom = child_y + child_natural;
}
}
if (min_top < 0)
min_top = 0;
if (natural_top < 0)
natural_top = 0;
if (min_bottom < 0)
min_bottom = 0;
if (natural_bottom < 0)
natural_bottom = 0;
g_assert (min_bottom >= min_top);
g_assert (natural_bottom >= natural_top);
if (min_height_p)
*min_height_p = min_bottom - min_top;
if (natural_height_p)
*natural_height_p = natural_bottom - min_top;
}
static void
my_thing_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MyThingPrivate *priv;
gfloat current_x, current_y, max_row_height;
GList *l;
/* chain up to set actor->allocation */
CLUTTER_ACTOR_CLASS (my_thing_parent_class)->allocate (self, box, flags);
priv = MY_THING (self)->priv;
current_x = priv->padding;
current_y = priv->padding;
max_row_height = 0;
/* The allocation logic here is to horizontally place children
* side-by-side and reflow into a new row when we run out of
* space
*/
for (l = priv->children; l != NULL; l = l->next)
{
ClutterActor *child;
gfloat natural_width, natural_height;
ClutterActorBox child_box;
child = l->data;
clutter_actor_get_preferred_size (child,
NULL, NULL,
&natural_width, &natural_height);
/* if it fits in the current row, keep it there; otherwise
* reflow into another row
*/
if (current_x + natural_width > box->x2 - box->x1 - priv->padding)
{
current_x = priv->padding;
current_y += max_row_height + priv->spacing;
max_row_height = 0;
}
child_box.x1 = current_x;
child_box.y1 = current_y;
child_box.x2 = child_box.x1 + natural_width;
child_box.y2 = child_box.y1 + natural_height;
clutter_actor_allocate (child, &child_box, flags);
/* if we take into account the transformation of the children
* then we first check if it's transformed; then we get the
* onscreen coordinates of the two points of the bounding box
* of the actor (origin(x, y) and (origin + size)(x,y)) and
* we update the coordinates and area given to the next child
*/
if (priv->use_transformed_box)
{
if (clutter_actor_is_scaled (child) ||
clutter_actor_is_rotated (child))
{
ClutterVertex v1 = { 0, }, v2 = { 0, };
ClutterActorBox transformed_box = { 0, };
/* origin */
if (!(flags & CLUTTER_ABSOLUTE_ORIGIN_CHANGED))
{
v1.x = 0;
v1.y = 0;
}
else
{
v1.x = box->x1;
v1.y = box->y1;
}
clutter_actor_apply_transform_to_point (child, &v1, &v2);
transformed_box.x1 = v2.x;
transformed_box.y1 = v2.y;
/* size */
v1.x = natural_width;
v1.y = natural_height;
clutter_actor_apply_transform_to_point (child, &v1, &v2);
transformed_box.x2 = v2.x;
transformed_box.y2 = v2.y;
natural_width = transformed_box.x2 - transformed_box.x1;
natural_height = transformed_box.y2 - transformed_box.y1;
}
}
/* Record the maximum child height on current row to know
* what's the increment that should be used for the next
* row
*/
if (natural_height > max_row_height)
max_row_height = natural_height;
current_x += natural_width + priv->spacing;
}
}
static void
my_thing_paint (ClutterActor *actor)
{
MyThing *self = MY_THING (actor);
GList *c;
cogl_push_matrix();
/* paint all visible children */
for (c = self->priv->children;
c != NULL;
c = c->next)
{
ClutterActor *child = c->data;
g_assert (child != NULL);
clutter_actor_paint (child);
}
cogl_pop_matrix();
}
#define MIN_SIZE 24
#define MAX_SIZE 64
static void
my_thing_class_init (MyThingClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
gobject_class->set_property = my_thing_set_property;
gobject_class->get_property = my_thing_get_property;
gobject_class->dispose = my_thing_dispose;
gobject_class->finalize = my_thing_finalize;
actor_class->get_preferred_width = my_thing_get_preferred_width;
actor_class->get_preferred_height = my_thing_get_preferred_height;
actor_class->allocate = my_thing_allocate;
actor_class->paint = my_thing_paint;
g_object_class_install_property (gobject_class,
PROP_SPACING,
g_param_spec_float ("spacing",
"Spacing",
"Spacing of the thing",
0, G_MAXFLOAT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PADDING,
g_param_spec_float ("padding",
"Padding",
"Padding around the thing",
0, G_MAXFLOAT,
0,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_USE_TRANSFORMED_BOX,
g_param_spec_boolean ("use-transformed-box",
"Use Transformed Box",
"Use transformed box when allocating",
FALSE,
G_PARAM_READWRITE));
g_type_class_add_private (klass, sizeof (MyThingPrivate));
}
static void
my_thing_init (MyThing *thing)
{
thing->priv = MY_THING_GET_PRIVATE (thing);
}
ClutterActor *
my_thing_new (gfloat padding,
gfloat spacing)
{
return g_object_new (MY_TYPE_THING,
"padding", padding,
"spacing", spacing,
NULL);
}
/* test code */
static ClutterActor *box = NULL;
static ClutterActor *icon = NULL;
static ClutterTimeline *main_timeline = NULL;
static void
toggle_property_value (ClutterActor *actor,
const gchar *property_name)
{
gboolean value;
g_object_get (G_OBJECT (actor),
property_name, &value,
NULL);
value = !value;
g_object_set (G_OBJECT (box),
property_name, value,
NULL);
}
static void
increase_property_value (ClutterActor *actor,
const char *property_name)
{
gfloat value;
g_object_get (G_OBJECT (actor),
property_name, &value,
NULL);
value = value + 10.0;
g_object_set (G_OBJECT (box),
property_name, value,
NULL);
}
static void
decrease_property_value (ClutterActor *actor,
const char *property_name)
{
gfloat value;
g_object_get (G_OBJECT (actor),
property_name, &value,
NULL);
value = MAX (0, value - 10.0);
g_object_set (G_OBJECT (box),
property_name, value,
NULL);
}
static ClutterActor *
create_item (void)
{
ClutterActor *clone = clutter_clone_new (icon);
gint32 size = g_random_int_range (MIN_SIZE, MAX_SIZE);
clutter_actor_set_size (clone, size, size);
clutter_actor_animate_with_timeline (clone, CLUTTER_EASE_OUT_CUBIC,
main_timeline,
"scale-x", 2.0,
"scale-y", 2.0,
"fixed::scale-gravity", CLUTTER_GRAVITY_CENTER,
NULL);
return clone;
}
static gboolean
keypress_cb (ClutterActor *actor,
ClutterEvent *event,
gpointer data)
{
switch (clutter_event_get_key_symbol (event))
{
case CLUTTER_KEY_q:
clutter_main_quit ();
break;
case CLUTTER_KEY_a:
{
if (icon != NULL)
{
ClutterActor *clone = create_item ();
/* Add one item to container */
clutter_container_add_actor (CLUTTER_CONTAINER (box), clone);
}
break;
}
case CLUTTER_KEY_d:
{
GList *children =
clutter_container_get_children (CLUTTER_CONTAINER (box));
if (children)
{
GList *last = g_list_last (children);
/* Remove last item on container */
clutter_container_remove_actor (CLUTTER_CONTAINER (box),
CLUTTER_ACTOR (last->data));
}
break;
}
case CLUTTER_KEY_w:
{
decrease_property_value (box, "padding");
break;
}
case CLUTTER_KEY_e:
{
increase_property_value (box, "padding");
break;
}
case CLUTTER_KEY_r:
{
decrease_property_value (box, "spacing");
break;
}
case CLUTTER_KEY_s:
{
toggle_property_value (box, "use-transformed-box");
break;
}
case CLUTTER_KEY_t:
{
increase_property_value (box, "spacing");
break;
}
case CLUTTER_KEY_z:
{
if (clutter_timeline_is_playing (main_timeline))
clutter_timeline_pause (main_timeline);
else
clutter_timeline_start (main_timeline);
break;
}
default:
break;
}
return FALSE;
}
static void
relayout_on_frame (ClutterTimeline *timeline)
{
gboolean use_transformed_box;
/* if we care about transformations updating the layout, we need to inform
* the layout that a transformation is happening; this is either done by
* attaching a notification on the transformation properties or by simply
* queuing a relayout on each frame of the timeline used to drive the
* behaviour. for simplicity's sake, we used the latter
*/
g_object_get (G_OBJECT (box),
"use-transformed-box", &use_transformed_box,
NULL);
if (use_transformed_box)
clutter_actor_queue_relayout (box);
}
G_MODULE_EXPORT int
test_layout_main (int argc, char *argv[])
{
ClutterActor *stage, *instructions;
gint i, size;
GError *error = NULL;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_actor_set_size (stage, 800, 600);
main_timeline = clutter_timeline_new (2000);
clutter_timeline_set_loop (main_timeline, TRUE);
clutter_timeline_set_reverse (main_timeline, TRUE);
g_signal_connect (main_timeline, "new-frame",
G_CALLBACK (relayout_on_frame),
NULL);
box = my_thing_new (10, 10);
clutter_actor_set_position (box, 20, 20);
clutter_actor_set_size (box, 350, -1);
icon = clutter_texture_new_from_file (TESTS_DATADIR
G_DIR_SEPARATOR_S
"redhand.png",
&error);
if (error)
g_error ("Unable to load 'redhand.png': %s", error->message);
size = g_random_int_range (MIN_SIZE, MAX_SIZE);
clutter_actor_set_size (icon, size, size);
clutter_container_add_actor (CLUTTER_CONTAINER (box), icon);
clutter_actor_animate_with_timeline (icon, CLUTTER_EASE_OUT_CUBIC,
main_timeline,
"scale-x", 2.0,
"scale-y", 2.0,
"fixed::scale-gravity", CLUTTER_GRAVITY_CENTER,
NULL);
for (i = 1; i < 33; i++)
{
ClutterActor *clone = create_item ();
clutter_container_add_actor (CLUTTER_CONTAINER (box), clone);
}
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
instructions = clutter_text_new_with_text ("Sans 14",
"<b>Instructions:</b>\n"
"a - add a new item\n"
"d - remove last item\n"
"z - start/pause behaviour\n"
"w - decrease padding\n"
"e - increase padding\n"
"r - decrease spacing\n"
"t - increase spacing\n"
"s - use transformed box\n"
"q - quit");
clutter_text_set_use_markup (CLUTTER_TEXT (instructions), TRUE);
clutter_actor_set_position (instructions, 450, 10);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), instructions);
g_signal_connect (stage, "key-release-event",
G_CALLBACK (keypress_cb),
NULL);
clutter_timeline_stop (main_timeline);
clutter_actor_show (stage);
clutter_main ();
g_object_unref (main_timeline);
return EXIT_SUCCESS;
}