mutter/clutter/clutter-snap-constraint.c

605 lines
18 KiB
C
Raw Normal View History

/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* 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, see <http://www.gnu.org/licenses/>.
*
* Author:
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
* SECTION:clutter-snap-constraint
* @Title: ClutterSnapConstraint
* @Short_Description: A constraint snapping two actors together
*
* #ClutterSnapConstraint is a constraint the snaps the edges of two
* actors together, expanding the actor's allocation if necessary.
*
* An offset can be applied to the constraint, to provide spacing.
*
* #ClutterSnapConstraint is available since Clutter 1.6
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <math.h>
#include "clutter-snap-constraint.h"
#include "clutter-actor-private.h"
#include "clutter-constraint.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-private.h"
#define CLUTTER_SNAP_CONSTRAINT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_SNAP_CONSTRAINT, ClutterSnapConstraintClass))
#define CLUTTER_IS_SNAP_CONSTRAINT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_SNAP_CONSTRAINT))
#define CLUTTER_SNAP_CONSTRAINT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_SNAP_CONSTRAINT, ClutterSnapConstraintClass))
struct _ClutterSnapConstraint
{
ClutterConstraint parent_instance;
ClutterActor *actor;
ClutterActor *source;
ClutterSnapEdge from_edge;
ClutterSnapEdge to_edge;
gfloat offset;
};
struct _ClutterSnapConstraintClass
{
ClutterConstraintClass parent_class;
};
enum
{
PROP_0,
PROP_SOURCE,
PROP_FROM_EDGE,
PROP_TO_EDGE,
PROP_OFFSET,
PROP_LAST
};
G_DEFINE_TYPE (ClutterSnapConstraint,
clutter_snap_constraint,
CLUTTER_TYPE_CONSTRAINT);
static GParamSpec *obj_props[PROP_LAST] = { NULL, };
static void
source_queue_relayout (ClutterActor *source,
ClutterSnapConstraint *constraint)
{
if (constraint->actor != NULL)
clutter_actor_queue_relayout (constraint->actor);
}
static void
source_destroyed (ClutterActor *actor,
ClutterSnapConstraint *constraint)
{
constraint->source = NULL;
}
static inline void
warn_horizontal_edge (const gchar *edge,
ClutterActor *actor,
ClutterActor *source)
{
g_warning (G_STRLOC ": the %s edge of actor '%s' can only be snapped "
"to either the right or the left edge of actor '%s'",
edge,
_clutter_actor_get_debug_name (actor),
_clutter_actor_get_debug_name (source));
}
static inline void
warn_vertical_edge (const gchar *edge,
ClutterActor *actor,
ClutterActor *source)
{
g_warning (G_STRLOC ": the %s edge of actor '%s' can only "
"be snapped to the top or bottom edge of actor '%s'",
edge,
_clutter_actor_get_debug_name (actor),
_clutter_actor_get_debug_name (source));
}
static void
clutter_snap_constraint_update_allocation (ClutterConstraint *constraint,
ClutterActor *actor,
ClutterActorBox *allocation)
{
ClutterSnapConstraint *self = CLUTTER_SNAP_CONSTRAINT (constraint);
gfloat source_width, source_height;
gfloat source_x, source_y;
gfloat actor_width, actor_height;
if (self->source == NULL)
return;
clutter_actor_get_position (self->source, &source_x, &source_y);
clutter_actor_get_size (self->source, &source_width, &source_height);
clutter_actor_box_get_size (allocation, &actor_width, &actor_height);
switch (self->to_edge)
{
case CLUTTER_SNAP_EDGE_LEFT:
if (self->from_edge == CLUTTER_SNAP_EDGE_LEFT)
allocation->x1 = source_x + self->offset;
else if (self->from_edge == CLUTTER_SNAP_EDGE_RIGHT)
allocation->x2 = source_x + self->offset;
else
warn_horizontal_edge ("left", self->actor, self->source);
break;
case CLUTTER_SNAP_EDGE_RIGHT:
if (self->from_edge == CLUTTER_SNAP_EDGE_RIGHT)
allocation->x2 = source_x + source_height + self->offset;
else if (self->from_edge == CLUTTER_SNAP_EDGE_LEFT)
allocation->x1 = source_x + source_height + self->offset;
else
warn_horizontal_edge ("right", self->actor, self->source);
break;
break;
case CLUTTER_SNAP_EDGE_TOP:
if (self->from_edge == CLUTTER_SNAP_EDGE_TOP)
allocation->y1 = source_y + self->offset;
else if (self->from_edge == CLUTTER_SNAP_EDGE_BOTTOM)
allocation->y2 = source_y + self->offset;
else
warn_vertical_edge ("top", self->actor, self->source);
break;
case CLUTTER_SNAP_EDGE_BOTTOM:
if (self->from_edge == CLUTTER_SNAP_EDGE_BOTTOM)
allocation->y2 = source_y + source_height + self->offset;
else if (self->from_edge == CLUTTER_SNAP_EDGE_TOP)
allocation->y1 = source_y + source_height + self->offset;
else
warn_vertical_edge ("bottom", self->actor, self->source);
break;
default:
g_assert_not_reached ();
break;
}
if (allocation->x2 - allocation->x1 < 0)
allocation->x2 = allocation->x1;
if (allocation->y2 - allocation->y1 < 0)
allocation->y2 = allocation->y1;
}
static void
clutter_snap_constraint_set_actor (ClutterActorMeta *meta,
ClutterActor *new_actor)
{
ClutterSnapConstraint *self = CLUTTER_SNAP_CONSTRAINT (meta);
ClutterActorMetaClass *parent;
/* store the pointer to the actor, for later use */
self->actor = new_actor;
parent = CLUTTER_ACTOR_META_CLASS (clutter_snap_constraint_parent_class);
parent->set_actor (meta, new_actor);
}
static void
clutter_snap_constraint_dispose (GObject *gobject)
{
ClutterSnapConstraint *snap = CLUTTER_SNAP_CONSTRAINT (gobject);
if (snap->source != NULL)
{
g_signal_handlers_disconnect_by_func (snap->source,
G_CALLBACK (source_destroyed),
snap);
g_signal_handlers_disconnect_by_func (snap->source,
G_CALLBACK (source_queue_relayout),
snap);
snap->source = NULL;
}
G_OBJECT_CLASS (clutter_snap_constraint_parent_class)->dispose (gobject);
}
static void
clutter_snap_constraint_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterSnapConstraint *self = CLUTTER_SNAP_CONSTRAINT (gobject);
switch (prop_id)
{
case PROP_SOURCE:
clutter_snap_constraint_set_source (self, g_value_get_object (value));
break;
case PROP_FROM_EDGE:
clutter_snap_constraint_set_edges (self,
g_value_get_enum (value),
self->to_edge);
break;
case PROP_TO_EDGE:
clutter_snap_constraint_set_edges (self,
self->from_edge,
g_value_get_enum (value));
break;
case PROP_OFFSET:
clutter_snap_constraint_set_offset (self, g_value_get_float (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_snap_constraint_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterSnapConstraint *self = CLUTTER_SNAP_CONSTRAINT (gobject);
switch (prop_id)
{
case PROP_SOURCE:
g_value_set_object (value, self->source);
break;
case PROP_FROM_EDGE:
g_value_set_enum (value, self->from_edge);
break;
case PROP_TO_EDGE:
g_value_set_enum (value, self->to_edge);
break;
case PROP_OFFSET:
g_value_set_float (value, self->offset);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_snap_constraint_class_init (ClutterSnapConstraintClass *klass)
{
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
ClutterConstraintClass *constraint_class = CLUTTER_CONSTRAINT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
meta_class->set_actor = clutter_snap_constraint_set_actor;
constraint_class->update_allocation = clutter_snap_constraint_update_allocation;
/**
* ClutterSnapConstraint:source:
*
* The #ClutterActor used as the source for the constraint
*
* Since: 1.6
*/
obj_props[PROP_SOURCE] =
g_param_spec_object ("source",
P_("Source"),
P_("The source of the constraint"),
CLUTTER_TYPE_ACTOR,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT);
/**
* ClutterSnapConstraint:from-edge:
*
* The edge of the #ClutterActor that should be snapped
*
* Since: 1.6
*/
obj_props[PROP_FROM_EDGE] =
g_param_spec_enum ("from-edge",
P_("From Edge"),
P_("The edge of the actor that should be snapped"),
CLUTTER_TYPE_SNAP_EDGE,
CLUTTER_SNAP_EDGE_RIGHT,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT);
/**
* ClutterSnapConstraint:to-edge:
*
* The edge of the #ClutterSnapConstraint:source that should be snapped
*
* Since: 1.6
*/
obj_props[PROP_TO_EDGE] =
g_param_spec_enum ("to-edge",
P_("To Edge"),
P_("The edge of the source that should be snapped"),
CLUTTER_TYPE_SNAP_EDGE,
CLUTTER_SNAP_EDGE_RIGHT,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT);
/**
* ClutterSnapConstraint:offset:
*
* The offset, in pixels, between #ClutterSnapConstraint:from-edge
* and #ClutterSnapConstraint:to-edge
*
* Since: 1.6
*/
obj_props[PROP_OFFSET] =
g_param_spec_float ("offset",
P_("Offset"),
P_("The offset in pixels to apply to the constraint"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0f,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT);
gobject_class->dispose = clutter_snap_constraint_dispose;
gobject_class->set_property = clutter_snap_constraint_set_property;
gobject_class->get_property = clutter_snap_constraint_get_property;
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
}
static void
clutter_snap_constraint_init (ClutterSnapConstraint *self)
{
self->actor = NULL;
self->source = NULL;
self->from_edge = CLUTTER_SNAP_EDGE_RIGHT;
self->to_edge = CLUTTER_SNAP_EDGE_RIGHT;
self->offset = 0.0f;
}
/**
* clutter_snap_constraint_new:
* @source: (allow-none): the #ClutterActor to use as the source of
* the constraint, or %NULL
* @from_edge: the edge of the actor to use in the constraint
* @to_edge: the edge of @source to use in the constraint
* @offset: the offset to apply to the constraint, in pixels
*
* Creates a new #ClutterSnapConstraint that will snap a #ClutterActor
* to the @edge of @source, with the given @offset.
*
* Return value: the newly created #ClutterSnapConstraint
*
* Since: 1.6
*/
ClutterConstraint *
clutter_snap_constraint_new (ClutterActor *source,
ClutterSnapEdge from_edge,
ClutterSnapEdge to_edge,
gfloat offset)
{
g_return_val_if_fail (source == NULL || CLUTTER_IS_ACTOR (source), NULL);
return g_object_new (CLUTTER_TYPE_SNAP_CONSTRAINT,
"source", source,
"from-edge", from_edge,
"to-edge", to_edge,
"offset", offset,
NULL);
}
/**
* clutter_snap_constraint_set_source:
* @constraint: a #ClutterSnapConstraint
* @source: (allow-none): a #ClutterActor, or %NULL to unset the source
*
* Sets the source #ClutterActor for the constraint
*
* Since: 1.6
*/
void
clutter_snap_constraint_set_source (ClutterSnapConstraint *constraint,
ClutterActor *source)
{
ClutterActor *old_source;
g_return_if_fail (CLUTTER_IS_SNAP_CONSTRAINT (constraint));
g_return_if_fail (source == NULL || CLUTTER_IS_ACTOR (source));
if (constraint->source == source)
return;
old_source = constraint->source;
if (old_source != NULL)
{
g_signal_handlers_disconnect_by_func (old_source,
G_CALLBACK (source_destroyed),
constraint);
g_signal_handlers_disconnect_by_func (old_source,
G_CALLBACK (source_queue_relayout),
constraint);
}
constraint->source = source;
if (constraint->source != NULL)
{
g_signal_connect (constraint->source, "queue-relayout",
G_CALLBACK (source_queue_relayout),
constraint);
g_signal_connect (constraint->source, "destroy",
G_CALLBACK (source_destroyed),
constraint);
if (constraint->actor != NULL)
clutter_actor_queue_relayout (constraint->actor);
}
g_object_notify_by_pspec (G_OBJECT (constraint), obj_props[PROP_SOURCE]);
}
/**
* clutter_snap_constraint_get_source:
* @constraint: a #ClutterSnapConstraint
*
* Retrieves the #ClutterActor set using clutter_snap_constraint_set_source()
*
* Return value: (transfer none): a pointer to the source actor
*
* Since: 1.6
*/
ClutterActor *
clutter_snap_constraint_get_source (ClutterSnapConstraint *constraint)
{
g_return_val_if_fail (CLUTTER_IS_SNAP_CONSTRAINT (constraint), NULL);
return constraint->source;
}
/**
* clutter_snap_constraint_set_edges:
* @constraint: a #ClutterSnapConstraint
* @from_edge: the edge on the actor
* @to_edge: the edge on the source
*
* Sets the edges to be used by the @constraint
*
* The @from_edge is the edge on the #ClutterActor to which @constraint
* has been added. The @to_edge is the edge of the #ClutterActor inside
* the #ClutterSnapConstraint:source property.
*
* Since: 1.6
*/
void
clutter_snap_constraint_set_edges (ClutterSnapConstraint *constraint,
ClutterSnapEdge from_edge,
ClutterSnapEdge to_edge)
{
gboolean from_changed = FALSE, to_changed = FALSE;
g_return_if_fail (CLUTTER_IS_SNAP_CONSTRAINT (constraint));
g_object_freeze_notify (G_OBJECT (constraint));
if (constraint->from_edge != from_edge)
{
constraint->from_edge = from_edge;
g_object_notify_by_pspec (G_OBJECT (constraint),
obj_props[PROP_FROM_EDGE]);
from_changed = TRUE;
}
if (constraint->to_edge != to_edge)
{
constraint->to_edge = to_edge;
g_object_notify_by_pspec (G_OBJECT (constraint),
obj_props[PROP_TO_EDGE]);
to_changed = TRUE;
}
if ((from_changed || to_changed) &&
constraint->actor != NULL)
{
clutter_actor_queue_relayout (constraint->actor);
}
g_object_thaw_notify (G_OBJECT (constraint));
}
/**
* clutter_snap_constraint_get_edges:
* @constraint: a #ClutterSnapConstraint
* @from_edge: (out): return location for the actor's edge, or %NULL
* @to_edge: (out): return location for the source's edge, or %NULL
*
* Retrieves the edges used by the @constraint
*
* Since: 1.6
*/
void
clutter_snap_constraint_get_edge (ClutterSnapConstraint *constraint,
ClutterSnapEdge *from_edge,
ClutterSnapEdge *to_edge)
{
g_return_if_fail (CLUTTER_IS_SNAP_CONSTRAINT (constraint));
if (from_edge)
*from_edge = constraint->from_edge;
if (to_edge)
*to_edge = constraint->to_edge;
}
/**
* clutter_snap_constraint_set_offset:
* @constraint: a #ClutterSnapConstraint
* @offset: the offset to apply, in pixels
*
* Sets the offset to be applied to the constraint
*
* Since: 1.6
*/
void
clutter_snap_constraint_set_offset (ClutterSnapConstraint *constraint,
gfloat offset)
{
g_return_if_fail (CLUTTER_IS_SNAP_CONSTRAINT (constraint));
if (fabs (constraint->offset - offset) < 0.00001f)
return;
constraint->offset = offset;
if (constraint->actor != NULL)
clutter_actor_queue_relayout (constraint->actor);
g_object_notify_by_pspec (G_OBJECT (constraint), obj_props[PROP_OFFSET]);
}
/**
* clutter_snap_constraint_get_offset:
* @constraint: a #ClutterSnapConstraint
*
* Retrieves the offset set using clutter_snap_constraint_set_offset()
*
* Return value: the offset, in pixels
*
* Since: 1.6
*/
gfloat
clutter_snap_constraint_get_offset (ClutterSnapConstraint *constraint)
{
g_return_val_if_fail (CLUTTER_IS_SNAP_CONSTRAINT (constraint), 0.0);
return constraint->offset;
}