mutter/clutter/clutter-group.c
Matthew Allum df92202c5f 2006-06-13 Matthew Allum <mallum@openedhand.com>
* clutter/Makefile.am:
        * clutter/clutter-actor.c:
        * clutter/clutter-actor.h:
        * clutter/clutter-clone-texture.c:
        * clutter/clutter-clone-texture.h:
        * clutter/clutter-element.c:
        * clutter/clutter-element.h:
        * clutter/clutter-group.c:
        * clutter/clutter-group.h:
        * clutter/clutter-label.c:
        * clutter/clutter-label.h:
        * clutter/clutter-main.c:
        * clutter/clutter-main.h:
        * clutter/clutter-rectangle.c:
        * clutter/clutter-rectangle.h:
        * clutter/clutter-stage.c:
        * clutter/clutter-stage.h:
        * clutter/clutter-texture.c:
        * clutter/clutter-texture.h:
        * clutter/clutter-video-texture.c:
        * clutter/clutter-video-texture.h:
        * clutter/clutter.h:
        * examples/super-oh.c:
        * examples/test-text.c:
        * examples/test-video.c:
        * examples/test.c:
        * examples/video-cube.c:
        * gtk/gtk-clutter-test.c:
        * gtk/gtk-clutter.c:
        * gtk/gtk-clutter.h:
        Element to Actor Renaming.
2006-06-13 13:17:45 +00:00

655 lines
15 KiB
C

/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum <mallum@openedhand.com>
*
* Copyright (C) 2006 OpenedHand
*
* 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
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <stdarg.h>
#include "clutter-group.h"
#include "clutter-main.h"
#include "clutter-marshal.h"
#include "clutter-enum-types.h"
enum
{
ADD,
REMOVE,
LAST_SIGNAL
};
static guint group_signals[LAST_SIGNAL] = { 0 };
G_DEFINE_TYPE (ClutterGroup, clutter_group, CLUTTER_TYPE_ACTOR);
#define CLUTTER_GROUP_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_GROUP, ClutterGroupPrivate))
struct _ClutterGroupPrivate
{
GList *children;
};
static void
clutter_group_paint (ClutterActor *actor)
{
ClutterGroup *self = CLUTTER_GROUP(actor);
GList *child_item;
child_item = self->priv->children;
glPushMatrix();
/* Translate if parent ( i.e not stage window ).
*/
if (clutter_actor_get_parent (actor) != NULL)
{
ClutterGeometry geom;
clutter_actor_get_geometry (actor, &geom);
if (geom.x != 0 && geom.y != 0)
glTranslatef(geom.x, geom.y, 0.0);
}
#if 0
for (child_item = self->priv->children;
child_item != NULL;
child_item = child_item->next)
{
ClutterActor *child = child_item->data;
g_assert (child != NULL);
if (CLUTTER_ACTOR_IS_MAPPED (child))
clutter_actor_paint (child);
}
#endif
if (child_item)
{
do
{
ClutterActor *child = CLUTTER_ACTOR(child_item->data);
if (CLUTTER_ACTOR_IS_MAPPED (child))
{
clutter_actor_paint(child);
}
}
while ((child_item = g_list_next(child_item)) != NULL);
}
glPopMatrix();
}
static void
clutter_group_request_coords (ClutterActor *self,
ClutterActorBox *box)
{
/* FIXME: what to do here ?
* o clip if smaller ?
* o scale each actor ?
*/
}
static void
clutter_group_allocate_coords (ClutterActor *self,
ClutterActorBox *box)
{
ClutterGroupPrivate *priv;
GList *child_item;
priv = CLUTTER_GROUP(self)->priv;
child_item = priv->children;
if (child_item)
{
do
{
ClutterActor *child = CLUTTER_ACTOR(child_item->data);
if (CLUTTER_ACTOR_IS_VISIBLE (child))
{
ClutterActorBox cbox;
clutter_actor_allocate_coords (child, &cbox);
/*
if (box->x1 == 0 || cbox.x1 < box->x1)
box->x1 = cbox.x1;
if (box->y1 == 0 || cbox.y1 < box->y1)
box->y1 = cbox.y1;
*/
if (box->x2 == 0 || cbox.x2 > box->x2)
box->x2 = cbox.x2;
if (box->y2 == 0 || cbox.y2 < box->y2)
box->y2 = cbox.y2;
}
}
while ((child_item = g_list_next(child_item)) != NULL);
}
}
static void
clutter_group_dispose (GObject *object)
{
ClutterGroup *self = CLUTTER_GROUP(object);
if (self->priv)
{
/* FIXME: Do we need to actually free anything here ?
* Children ref us so this wont get called till
* they are all removed.
*/
}
G_OBJECT_CLASS (clutter_group_parent_class)->dispose (object);
}
static void
clutter_group_finalize (GObject *object)
{
ClutterGroup *group = CLUTTER_GROUP (object);
/* XXX - if something survives ::dispose then there's something
* wrong; but, at least, we won't leak stuff around.
*/
if (group->priv->children)
{
g_list_foreach (group->priv->children, (GFunc) g_object_unref, NULL);
g_list_free (group->priv->children);
}
G_OBJECT_CLASS (clutter_group_parent_class)->finalize (object);
}
static void
clutter_group_class_init (ClutterGroupClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
actor_class->paint = clutter_group_paint;
/*
actor_class->show = clutter_group_show_all;
actor_class->hide = clutter_group_hide_all;
*/
actor_class->request_coords = clutter_group_request_coords;
actor_class->allocate_coords = clutter_group_allocate_coords;
/* GObject */
object_class->finalize = clutter_group_finalize;
object_class->dispose = clutter_group_dispose;
group_signals[ADD] =
g_signal_new ("add",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterGroupClass, add),
NULL, NULL,
clutter_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
group_signals[REMOVE] =
g_signal_new ("remove",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterGroupClass, remove),
NULL, NULL,
clutter_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
g_type_class_add_private (object_class, sizeof (ClutterGroupPrivate));
}
static void
clutter_group_init (ClutterGroup *self)
{
self->priv = CLUTTER_GROUP_GET_PRIVATE (self);
}
/**
* clutter_group_new:
*
* Create a new #ClutterGroup instance.
*
* returns a new #ClutterGroup
**/
ClutterGroup*
clutter_group_new (void)
{
return g_object_new (CLUTTER_TYPE_GROUP, NULL);
}
/**
* clutter_group_get_children:
* @self: A #ClutterGroup
*
* Get a list containing all actors contained in the group.
*
* Return value: A GList containing child #ClutterActors.
**/
GList*
clutter_group_get_children (ClutterGroup *self)
{
/* FIXME: remane get_actors() */
g_return_val_if_fail (CLUTTER_IS_GROUP (self), NULL);
return g_list_copy(self->priv->children);
}
/**
* clutter_group_forall:
* @self: A #ClutterGroup
* @callback: a callback
* @user_data: callback user data
*
* Invokes callback on each child of the group.
**/
void
clutter_group_foreach (ClutterGroup *self,
ClutterCallback callback,
gpointer user_data)
{
ClutterActor *child;
GList *children;
g_return_if_fail (CLUTTER_IS_GROUP (self));
g_return_if_fail (callback != NULL);
children = self->priv->children;
while (children)
{
child = children->data;
(*callback) (child, user_data);
children = g_list_next(children);
}
}
/**
* clutter_group_show_all:
* @self: A #ClutterGroup
*
* Show all child actors of the group. Note, does not recurse.
**/
void
clutter_group_show_all (ClutterGroup *self)
{
g_return_if_fail (CLUTTER_IS_GROUP (self));
clutter_actor_show(CLUTTER_ACTOR(self));
g_list_foreach (self->priv->children,
(GFunc)clutter_actor_show,
NULL);
}
/**
* clutter_group_hide_all:
* @self: A #ClutterGroup
*
* Hide all child actors of the group. Note, does not recurse.
**/
void
clutter_group_hide_all (ClutterGroup *self)
{
g_return_if_fail (CLUTTER_IS_GROUP (self));
clutter_actor_hide(CLUTTER_ACTOR(self));
g_list_foreach (self->priv->children,
(GFunc)clutter_actor_hide,
NULL);
}
/**
* clutter_group_add:
* @self: A #ClutterGroup
* @actor: A #ClutterActor
*
* Adds a new child #ClutterActor to the #ClutterGroup.
**/
void
clutter_group_add (ClutterGroup *self,
ClutterActor *actor)
{
ClutterActor *parent;
g_return_if_fail (CLUTTER_IS_GROUP (self));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
parent = clutter_actor_get_parent (actor);
if (parent)
{
g_warning ("Attempting to add actor of type `%s' to a "
"group of type `%s', but the actor has already "
"a parent of type `%s'.",
g_type_name (G_OBJECT_TYPE (actor)),
g_type_name (G_OBJECT_TYPE (self)),
g_type_name (G_OBJECT_TYPE (parent)));
return;
}
self->priv->children = g_list_append (self->priv->children, actor);
/* below refs */
clutter_actor_set_parent (actor, CLUTTER_ACTOR(self));
g_object_ref (actor);
clutter_group_sort_depth_order (self);
g_signal_emit (self, group_signals[ADD], 0, actor);
}
/**
* clutter_group_add_manyv:
* @self: a #ClutterGroup
* @first_actor: the #ClutterActor actor to add to the group
* @args: the actors to be added
*
* Similar to clutter_group_add_many() but using a va_list. Use this
* function inside bindings.
*/
void
clutter_group_add_many_valist (ClutterGroup *group,
ClutterActor *first_actor,
va_list args)
{
ClutterActor *actor;
g_return_if_fail (CLUTTER_IS_GROUP (group));
g_return_if_fail (CLUTTER_IS_ACTOR (first_actor));
actor = first_actor;
while (actor)
{
clutter_group_add (group, actor);
actor = va_arg (args, ClutterActor *);
}
}
/**
* clutter_group_add_many:
* @self: A #ClutterGroup
* @first_actor: the #ClutterActor actor to add to the group
* @Varargs: additional actors to add to the group
*
* Adds a NULL-terminated list of actors to a group. This function is
* equivalent to calling clutter_group_add() for each member of the list.
*/
void
clutter_group_add_many (ClutterGroup *self,
ClutterActor *first_actor,
...)
{
va_list args;
va_start (args, first_actor);
clutter_group_add_many_valist (self, first_actor, args);
va_end (args);
}
/**
* clutter_group_remove
* @self: A #ClutterGroup
* @actor: A #ClutterActor
*
* Remove a child #ClutterActor from the #ClutterGroup.
**/
void
clutter_group_remove (ClutterGroup *self,
ClutterActor *actor)
{
ClutterActor *parent;
g_return_if_fail (CLUTTER_IS_GROUP (self));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
parent = clutter_actor_get_parent (actor);
if (parent != CLUTTER_ACTOR (self))
{
g_warning ("Attempting to remove actor of type `%s' from "
"group of class `%s', but the group is not the "
"actor's parent.",
g_type_name (G_OBJECT_TYPE (actor)),
g_type_name (G_OBJECT_TYPE (self)));
return;
}
self->priv->children = g_list_remove (self->priv->children, actor);
clutter_actor_set_parent (actor, NULL);
g_signal_emit (self, group_signals[REMOVE], 0, actor);
g_object_unref (actor);
}
/**
* clutter_group_remove_all:
* @self: A #ClutterGroup
*
* Remove all child #ClutterActor from the #ClutterGroup.
*/
void
clutter_group_remove_all (ClutterGroup *self)
{
GList *child_item;
g_return_if_fail (CLUTTER_IS_GROUP (self));
child_item = self->priv->children;
if (child_item)
{
do
{
clutter_group_remove (self, CLUTTER_ACTOR(child_item->data));
}
while ((child_item = g_list_next(child_item)) != NULL);
}
}
/**
* clutter_group_find_child_by_id:
* @self: A #ClutterGroup
* @id: A unique #Clutteractor ID
*
* Finds a child actor of a group by its unique ID. Search recurses
* into any child groups.
*/
ClutterActor *
clutter_group_find_child_by_id (ClutterGroup *self,
guint id)
{
ClutterActor *actor = NULL, *inner_actor;
GList *child_item;
g_return_val_if_fail (CLUTTER_IS_GROUP (self), NULL);
if (clutter_actor_get_id (CLUTTER_ACTOR(self)) == id)
return CLUTTER_ACTOR(self);
child_item = self->priv->children;
if (child_item)
{
do
{
inner_actor = (ClutterActor*)child_item->data;
if (clutter_actor_get_id (inner_actor) == id)
return inner_actor;
if (CLUTTER_IS_GROUP(inner_actor))
{
actor =
clutter_group_find_child_by_id (CLUTTER_GROUP(inner_actor),
id);
if (actor)
return actor;
}
}
while ((child_item = g_list_next(child_item)) != NULL);
}
return actor;
}
/**
* clutter_group_raise:
* @self: a #ClutterGroup
* @actor: a #ClutterActor
* @sibling: a #ClutterActor
*
* FIXME
*/
void
clutter_group_raise (ClutterGroup *self,
ClutterActor *actor,
ClutterActor *sibling)
{
ClutterGroupPrivate *priv;
gint pos;
g_return_if_fail (actor != sibling);
priv = self->priv;
pos = g_list_index (priv->children, actor) + 1;
priv->children = g_list_remove (priv->children, actor);
if (sibling == NULL)
{
GList *last_item;
/* Raise top */
last_item = g_list_last (priv->children);
sibling = last_item->data;
priv->children = g_list_append (priv->children, actor);
}
else
{
priv->children = g_list_insert (priv->children, actor, pos);
}
/* set Z ordering a value below, this will then call sort
* as values are equal ordering shouldn't change but Z
* values will be correct.
* FIXME: optimise
*/
if (clutter_actor_get_depth(sibling) != clutter_actor_get_depth(actor))
clutter_actor_set_depth (actor,
clutter_actor_get_depth(sibling));
}
/**
* clutter_group_lower:
* @self: a #ClutterGroup
* @actor: a #ClutterActor
* @sibling: a #ClutterActor
*
* FIXME
*/
void
clutter_group_lower (ClutterGroup *self,
ClutterActor *actor,
ClutterActor *sibling)
{
ClutterGroupPrivate *priv;
gint pos;
g_return_if_fail (actor != sibling);
priv = self->priv;
pos = g_list_index (priv->children, actor) - 1;
priv->children = g_list_remove (priv->children, actor);
if (sibling == NULL)
{
GList *last_item;
/* Raise top */
last_item = g_list_first (priv->children);
sibling = last_item->data;
priv->children = g_list_prepend (priv->children, actor);
}
else
priv->children = g_list_insert (priv->children, actor, pos);
/* See comment in group_raise for this */
if (clutter_actor_get_depth(sibling) != clutter_actor_get_depth(actor))
clutter_actor_set_depth (actor,
clutter_actor_get_depth(sibling));
}
static gint
sort_z_order (gconstpointer a, gconstpointer b)
{
if (clutter_actor_get_depth (CLUTTER_ACTOR(a))
== clutter_actor_get_depth (CLUTTER_ACTOR(b)))
return 0;
if (clutter_actor_get_depth (CLUTTER_ACTOR(a))
> clutter_actor_get_depth (CLUTTER_ACTOR(b)))
return 1;
return -1;
}
/**
* clutter_group_sort_z_order:
* @self: A #ClutterGroup
*
* Sorts a #ClutterGroup's children by there depth value.
* This function should not be used by applications.
**/
void
clutter_group_sort_depth_order (ClutterGroup *self)
{
ClutterGroupPrivate *priv;
g_return_if_fail (CLUTTER_IS_GROUP(self));
priv = self->priv;
priv->children = g_list_sort (priv->children, sort_z_order);
if (CLUTTER_ACTOR_IS_VISIBLE (CLUTTER_ACTOR(self)))
clutter_actor_queue_redraw (CLUTTER_ACTOR(self));
}