0b4899ef23
The build for interactive tests creates symbolic links for the data under tests/data; it also uses symbolic links for creating "binaries" for each interactive test. This is less than ideal, though. Instead, the tests should build a path to the data files by using a pre-processor define like TESTS_DATADIR; both g_build_filename() and pre-processor string concatenation can be used to generate a valid file name with the full path to the files. The build system should also create wrapper scripts, just like we do inside the conformance test suite, to be able to launch single tests.
822 lines
22 KiB
C
822 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 ClutterBehaviour *behaviour = NULL;
|
|
|
|
static ClutterColor bg_color;
|
|
|
|
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_behaviour_apply (behaviour, clone);
|
|
|
|
return clone;
|
|
}
|
|
|
|
static gboolean
|
|
keypress_cb (ClutterActor *actor,
|
|
ClutterEvent *event,
|
|
gpointer data)
|
|
{
|
|
switch (clutter_event_get_key_symbol (event))
|
|
{
|
|
case CLUTTER_q:
|
|
{
|
|
clutter_main_quit ();
|
|
}
|
|
|
|
case CLUTTER_a:
|
|
{
|
|
if (icon != NULL)
|
|
{
|
|
ClutterActor *clone = create_item ();
|
|
|
|
/* Add one item to container */
|
|
clutter_container_add_actor (CLUTTER_CONTAINER (box), clone);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case CLUTTER_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_w:
|
|
{
|
|
decrease_property_value (box, "padding");
|
|
break;
|
|
}
|
|
|
|
case CLUTTER_e:
|
|
{
|
|
increase_property_value (box, "padding");
|
|
break;
|
|
}
|
|
|
|
case CLUTTER_r:
|
|
{
|
|
decrease_property_value (box, "spacing");
|
|
break;
|
|
}
|
|
|
|
case CLUTTER_s:
|
|
{
|
|
toggle_property_value (box, "use-transformed-box");
|
|
break;
|
|
}
|
|
|
|
case CLUTTER_t:
|
|
{
|
|
increase_property_value (box, "spacing");
|
|
break;
|
|
}
|
|
|
|
case CLUTTER_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;
|
|
ClutterAlpha *alpha;
|
|
gint i, size;
|
|
GError *error = NULL;
|
|
|
|
clutter_init (&argc, &argv);
|
|
|
|
stage = clutter_stage_get_default ();
|
|
clutter_actor_set_size (stage, 800, 600);
|
|
|
|
clutter_color_from_string (&bg_color, "Red");
|
|
|
|
main_timeline = clutter_timeline_new (2000);
|
|
clutter_timeline_set_loop (main_timeline, TRUE);
|
|
g_signal_connect (main_timeline, "new-frame",
|
|
G_CALLBACK (relayout_on_frame),
|
|
NULL);
|
|
|
|
alpha = clutter_alpha_new_full (main_timeline, CLUTTER_LINEAR);
|
|
behaviour = clutter_behaviour_scale_new (alpha, 1.0, 1.0, 2.0, 2.0);
|
|
|
|
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_behaviour_apply (behaviour, icon);
|
|
clutter_container_add_actor (CLUTTER_CONTAINER (box), icon);
|
|
|
|
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_actor_show (stage);
|
|
|
|
clutter_main ();
|
|
|
|
g_object_unref (main_timeline);
|
|
g_object_unref (behaviour);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|