mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-10-02 08:42:32 +00:00
c802a40a96
We used to always call the `->set_child_property` virtual method of the object that `ges_timeline_element_set_child_property` was called from, but that means that, in the case of referencing GESContainer children properties from its children, the children wouldn't know what child property have been set, and the children override wouldn't be takent into account, in turns, it means that the behaviour could be different in the setter depending on parent the method was called, which is totally unexpected. We now make sure that the vmethod from the element that introduced the child property is called whatever parent method is called, making the behaviour more uniform. Fix the python override to make sure that new behaviour is respected.
1028 lines
30 KiB
C
1028 lines
30 KiB
C
/* GStreamer Editing Services
|
|
* Copyright (C) <2013> Thibault Saunier <thibault.saunier@collabora.com>
|
|
* <2013> Collabora Ltd.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
/**
|
|
* SECTION:gescontainer
|
|
* @title: GESContainer
|
|
* @short_description: Base Class for objects responsible for controlling other
|
|
* GESTimelineElement-s
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "ges-container.h"
|
|
#include "ges.h"
|
|
#include "ges-internal.h"
|
|
|
|
#include <string.h>
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (ges_container_debug);
|
|
#undef GST_CAT_DEFAULT
|
|
#define GST_CAT_DEFAULT ges_container_debug
|
|
|
|
/* Mapping of relationship between a Container and the TimelineElements
|
|
* it controls
|
|
*
|
|
* NOTE : Does it make sense to make it public in the future ?
|
|
*/
|
|
typedef struct
|
|
{
|
|
GESTimelineElement *child;
|
|
|
|
GstClockTime start_offset;
|
|
GstClockTime duration_offset;
|
|
GstClockTime inpoint_offset;
|
|
gint32 priority_offset;
|
|
|
|
guint start_notifyid;
|
|
guint duration_notifyid;
|
|
guint inpoint_notifyid;
|
|
} ChildMapping;
|
|
|
|
enum
|
|
{
|
|
CHILD_ADDED_SIGNAL,
|
|
CHILD_REMOVED_SIGNAL,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
static guint ges_container_signals[LAST_SIGNAL] = { 0 };
|
|
|
|
struct _GESContainerPrivate
|
|
{
|
|
/*< public > */
|
|
GESLayer *layer;
|
|
|
|
/*< private > */
|
|
/* Set to TRUE when the container is doing updates of track object
|
|
* properties so we don't end up in infinite property update loops
|
|
*/
|
|
GHashTable *mappings;
|
|
|
|
/* List of GESTimelineElement being in the "child-added" signal
|
|
* emission stage */
|
|
GList *adding_children;
|
|
|
|
GList *copied_children;
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_HEIGHT,
|
|
PROP_LAST
|
|
};
|
|
|
|
static GParamSpec *properties[PROP_LAST];
|
|
|
|
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GESContainer, ges_container,
|
|
GES_TYPE_TIMELINE_ELEMENT);
|
|
|
|
/************************
|
|
* Private methods *
|
|
************************/
|
|
static void
|
|
_free_mapping (ChildMapping * mapping)
|
|
{
|
|
GESTimelineElement *child = mapping->child;
|
|
|
|
/* Disconnect all notify listeners */
|
|
if (mapping->start_notifyid)
|
|
g_signal_handler_disconnect (child, mapping->start_notifyid);
|
|
if (mapping->duration_notifyid)
|
|
g_signal_handler_disconnect (child, mapping->duration_notifyid);
|
|
if (mapping->inpoint_notifyid)
|
|
g_signal_handler_disconnect (child, mapping->inpoint_notifyid);
|
|
|
|
ges_timeline_element_set_parent (child, NULL);
|
|
g_slice_free (ChildMapping, mapping);
|
|
}
|
|
|
|
static gint
|
|
compare_grouping_prio (GType * a, GType * b)
|
|
{
|
|
gint ret = 0;
|
|
GObjectClass *aclass = g_type_class_ref (*a);
|
|
GObjectClass *bclass = g_type_class_ref (*b);
|
|
|
|
/* We want higher prios to be first */
|
|
if (GES_CONTAINER_CLASS (aclass)->grouping_priority <
|
|
GES_CONTAINER_CLASS (bclass)->grouping_priority)
|
|
ret = 1;
|
|
else if (GES_CONTAINER_CLASS (aclass)->grouping_priority >
|
|
GES_CONTAINER_CLASS (bclass)->grouping_priority)
|
|
ret = -1;
|
|
|
|
g_type_class_unref (aclass);
|
|
g_type_class_unref (bclass);
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
_resync_start_offsets (GESTimelineElement * child,
|
|
ChildMapping * map, GESContainer * container)
|
|
{
|
|
map->start_offset = _START (container) - _START (child);
|
|
}
|
|
|
|
/*****************************************************
|
|
* *
|
|
* GESTimelineElement virtual methods implementation *
|
|
* *
|
|
*****************************************************/
|
|
static gboolean
|
|
_set_start (GESTimelineElement * element, GstClockTime start)
|
|
{
|
|
GList *tmp;
|
|
ChildMapping *map;
|
|
GESContainer *container = GES_CONTAINER (element);
|
|
GESContainerPrivate *priv = container->priv;
|
|
|
|
GST_DEBUG_OBJECT (element, "Updating children offsets, (initiated_move: %"
|
|
GST_PTR_FORMAT ")", container->initiated_move);
|
|
|
|
for (tmp = container->children; tmp; tmp = g_list_next (tmp)) {
|
|
GESTimelineElement *child = (GESTimelineElement *) tmp->data;
|
|
|
|
map = g_hash_table_lookup (priv->mappings, child);
|
|
map->start_offset = start - _START (child);
|
|
}
|
|
container->children_control_mode = GES_CHILDREN_UPDATE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_set_inpoint (GESTimelineElement * element, GstClockTime inpoint)
|
|
{
|
|
GList *tmp;
|
|
GESContainer *container = GES_CONTAINER (element);
|
|
|
|
for (tmp = container->children; tmp; tmp = g_list_next (tmp)) {
|
|
GESTimelineElement *child = (GESTimelineElement *) tmp->data;
|
|
ChildMapping *map = g_hash_table_lookup (container->priv->mappings, child);
|
|
|
|
map->inpoint_offset = inpoint - _INPOINT (child);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_set_duration (GESTimelineElement * element, GstClockTime duration)
|
|
{
|
|
GList *tmp;
|
|
GESContainer *container = GES_CONTAINER (element);
|
|
GESContainerPrivate *priv = container->priv;
|
|
|
|
for (tmp = container->children; tmp; tmp = g_list_next (tmp)) {
|
|
GESTimelineElement *child = (GESTimelineElement *) tmp->data;
|
|
ChildMapping *map = g_hash_table_lookup (priv->mappings, child);
|
|
|
|
map->duration_offset = duration - _DURATION (child);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_ges_container_add_child_properties (GESContainer * container,
|
|
GESTimelineElement * child)
|
|
{
|
|
guint n_props, i;
|
|
|
|
GParamSpec **child_props =
|
|
ges_timeline_element_list_children_properties (child,
|
|
&n_props);
|
|
|
|
for (i = 0; i < n_props; i++) {
|
|
GObject *prop_child;
|
|
gchar *prop_name = g_strdup_printf ("%s::%s",
|
|
g_type_name (child_props[i]->owner_type),
|
|
child_props[i]->name);
|
|
|
|
if (ges_timeline_element_lookup_child (child, prop_name, &prop_child, NULL)) {
|
|
ges_timeline_element_add_child_property_full (GES_TIMELINE_ELEMENT
|
|
(container), child, child_props[i], prop_child);
|
|
gst_object_unref (prop_child);
|
|
|
|
}
|
|
g_free (prop_name);
|
|
g_param_spec_unref (child_props[i]);
|
|
}
|
|
|
|
g_free (child_props);
|
|
}
|
|
|
|
static void
|
|
_ges_container_remove_child_properties (GESContainer * container,
|
|
GESTimelineElement * child)
|
|
{
|
|
guint n_props, i;
|
|
|
|
GParamSpec **child_props =
|
|
ges_timeline_element_list_children_properties (child,
|
|
&n_props);
|
|
|
|
for (i = 0; i < n_props; i++) {
|
|
GObject *prop_child;
|
|
gchar *prop_name = g_strdup_printf ("%s::%s",
|
|
g_type_name (child_props[i]->owner_type),
|
|
child_props[i]->name);
|
|
|
|
if (ges_timeline_element_lookup_child (child, prop_name, &prop_child, NULL)) {
|
|
ges_timeline_element_remove_child_property (GES_TIMELINE_ELEMENT
|
|
(container), child_props[i]);
|
|
gst_object_unref (prop_child);
|
|
|
|
}
|
|
|
|
g_free (prop_name);
|
|
g_param_spec_unref (child_props[i]);
|
|
}
|
|
|
|
g_free (child_props);
|
|
}
|
|
|
|
static GParamSpec **
|
|
_list_children_properties (GESTimelineElement * self, guint * n_properties)
|
|
{
|
|
GList *tmp;
|
|
|
|
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next)
|
|
_ges_container_add_child_properties (GES_CONTAINER (self), tmp->data);
|
|
|
|
return
|
|
GES_TIMELINE_ELEMENT_CLASS
|
|
(ges_container_parent_class)->list_children_properties (self,
|
|
n_properties);
|
|
}
|
|
|
|
static gboolean
|
|
_lookup_child (GESTimelineElement * self, const gchar * prop_name,
|
|
GObject ** child, GParamSpec ** pspec)
|
|
{
|
|
GList *tmp;
|
|
|
|
/* FIXME Implement a syntax to precisely get properties by path */
|
|
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
|
|
if (ges_timeline_element_lookup_child (tmp->data, prop_name, child, pspec))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static GESTrackType
|
|
_get_track_types (GESTimelineElement * object)
|
|
{
|
|
GESTrackType types = GES_TRACK_TYPE_UNKNOWN;
|
|
GList *tmp, *children = ges_container_get_children (GES_CONTAINER (object),
|
|
TRUE);
|
|
|
|
for (tmp = children; tmp; tmp = tmp->next) {
|
|
if (GES_IS_TRACK_ELEMENT (tmp->data)) {
|
|
types |= ges_timeline_element_get_track_types (tmp->data);
|
|
}
|
|
}
|
|
|
|
g_list_free_full (children, gst_object_unref);
|
|
|
|
return types ^ GES_TRACK_TYPE_UNKNOWN;
|
|
}
|
|
|
|
static void
|
|
_deep_copy (GESTimelineElement * element, GESTimelineElement * copy)
|
|
{
|
|
GList *tmp;
|
|
GESContainer *self = GES_CONTAINER (element), *ccopy = GES_CONTAINER (copy);
|
|
|
|
for (tmp = GES_CONTAINER_CHILDREN (element); tmp; tmp = tmp->next) {
|
|
ChildMapping *map;
|
|
|
|
map =
|
|
g_slice_dup (ChildMapping, g_hash_table_lookup (self->priv->mappings,
|
|
tmp->data));
|
|
map->child = ges_timeline_element_copy (tmp->data, TRUE);
|
|
map->start_notifyid = 0;
|
|
map->inpoint_notifyid = 0;
|
|
map->duration_notifyid = 0;
|
|
|
|
ccopy->priv->copied_children = g_list_prepend (ccopy->priv->copied_children,
|
|
map);
|
|
}
|
|
}
|
|
|
|
static GESTimelineElement *
|
|
_paste (GESTimelineElement * element, GESTimelineElement * ref,
|
|
GstClockTime paste_position)
|
|
{
|
|
GList *tmp;
|
|
ChildMapping *map;
|
|
GESContainer *ncontainer =
|
|
GES_CONTAINER (ges_timeline_element_copy (element, FALSE));
|
|
GESContainer *self = GES_CONTAINER (element);
|
|
|
|
for (tmp = self->priv->copied_children; tmp; tmp = tmp->next) {
|
|
GESTimelineElement *nchild;
|
|
|
|
map = tmp->data;
|
|
nchild =
|
|
ges_timeline_element_paste (map->child,
|
|
paste_position - map->start_offset);
|
|
|
|
if (!nchild) {
|
|
while (ncontainer->children)
|
|
ges_container_remove (ncontainer, ncontainer->children->data);
|
|
|
|
g_object_unref (ncontainer);
|
|
return NULL;
|
|
}
|
|
|
|
ges_timeline_element_set_timeline (GES_TIMELINE_ELEMENT (ncontainer),
|
|
GES_TIMELINE_ELEMENT_TIMELINE (ref));
|
|
ges_container_add (ncontainer, nchild);
|
|
}
|
|
|
|
return GES_TIMELINE_ELEMENT (ncontainer);
|
|
}
|
|
|
|
|
|
/******************************************
|
|
* *
|
|
* GObject virtual methods implementation *
|
|
* *
|
|
******************************************/
|
|
static void
|
|
_dispose (GObject * object)
|
|
{
|
|
GList *tmp;
|
|
GESContainer *self = GES_CONTAINER (object);
|
|
GList *children;
|
|
|
|
_ges_container_sort_children (self);
|
|
children = ges_container_get_children (self, FALSE);
|
|
|
|
for (tmp = g_list_last (children); tmp; tmp = tmp->prev)
|
|
ges_container_remove (self, tmp->data);
|
|
|
|
g_list_free_full (children, gst_object_unref);
|
|
self->children = NULL;
|
|
|
|
G_OBJECT_CLASS (ges_container_parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
_finalize (GObject * object)
|
|
{
|
|
GESContainer *self = GES_CONTAINER (object);
|
|
|
|
g_list_free_full (self->priv->copied_children,
|
|
(GDestroyNotify) _free_mapping);
|
|
|
|
if (self->priv->mappings)
|
|
g_hash_table_destroy (self->priv->mappings);
|
|
|
|
G_OBJECT_CLASS (ges_container_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
_get_property (GObject * container, guint property_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GESContainer *tobj = GES_CONTAINER (container);
|
|
|
|
switch (property_id) {
|
|
case PROP_HEIGHT:
|
|
g_value_set_uint (value, tobj->height);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (container, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
_set_property (GObject * container, guint property_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
switch (property_id) {
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (container, property_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ges_container_class_init (GESContainerClass * klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GESTimelineElementClass *element_class = GES_TIMELINE_ELEMENT_CLASS (klass);
|
|
|
|
GST_DEBUG_CATEGORY_INIT (ges_container_debug, "gescontainer",
|
|
GST_DEBUG_FG_YELLOW, "ges container");
|
|
|
|
object_class->get_property = _get_property;
|
|
object_class->set_property = _set_property;
|
|
object_class->dispose = _dispose;
|
|
object_class->finalize = _finalize;
|
|
|
|
/**
|
|
* GESContainer:height:
|
|
*
|
|
* The span of priorities which this container occupies.
|
|
*/
|
|
properties[PROP_HEIGHT] = g_param_spec_uint ("height", "Height",
|
|
"The span of priorities this container occupies", 0, G_MAXUINT, 1,
|
|
G_PARAM_READABLE);
|
|
g_object_class_install_property (object_class, PROP_HEIGHT,
|
|
properties[PROP_HEIGHT]);
|
|
|
|
/**
|
|
* GESContainer::child-added:
|
|
* @container: the #GESContainer
|
|
* @element: the #GESTimelineElement that was added.
|
|
*
|
|
* Will be emitted after a child was added to @container.
|
|
* Usually you should connect with #g_signal_connect_after
|
|
* as in the first emission stage, the signal emission might
|
|
* get stopped internally.
|
|
*/
|
|
ges_container_signals[CHILD_ADDED_SIGNAL] =
|
|
g_signal_new ("child-added", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GESContainerClass, child_added),
|
|
NULL, NULL, NULL, G_TYPE_NONE, 1, GES_TYPE_TIMELINE_ELEMENT);
|
|
|
|
/**
|
|
* GESContainer::child-removed:
|
|
* @container: the #GESContainer
|
|
* @element: the #GESTimelineElement that was removed.
|
|
*
|
|
* Will be emitted after a child was removed from @container.
|
|
*/
|
|
ges_container_signals[CHILD_REMOVED_SIGNAL] =
|
|
g_signal_new ("child-removed", G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GESContainerClass, child_removed),
|
|
NULL, NULL, NULL, G_TYPE_NONE, 1, GES_TYPE_TIMELINE_ELEMENT);
|
|
|
|
|
|
element_class->set_start = _set_start;
|
|
element_class->set_duration = _set_duration;
|
|
element_class->set_inpoint = _set_inpoint;
|
|
element_class->list_children_properties = _list_children_properties;
|
|
element_class->lookup_child = _lookup_child;
|
|
element_class->get_track_types = _get_track_types;
|
|
element_class->paste = _paste;
|
|
element_class->deep_copy = _deep_copy;
|
|
|
|
/* No default implementations */
|
|
klass->remove_child = NULL;
|
|
klass->add_child = NULL;
|
|
klass->ungroup = NULL;
|
|
klass->group = NULL;
|
|
klass->grouping_priority = 0;
|
|
klass->edit = NULL;
|
|
}
|
|
|
|
static void
|
|
ges_container_init (GESContainer * self)
|
|
{
|
|
self->priv = ges_container_get_instance_private (self);
|
|
|
|
/* FIXME, check why default was GST_SECOND? (before the existend of
|
|
* ges-container)
|
|
*
|
|
* _DURATION (self) = GST_SECOND; */
|
|
self->height = 1; /* FIXME Why 1 and not 0? */
|
|
self->children = NULL;
|
|
|
|
self->priv->mappings = g_hash_table_new_full (g_direct_hash, g_direct_equal,
|
|
NULL, (GDestroyNotify) _free_mapping);
|
|
}
|
|
|
|
/**********************************************
|
|
* *
|
|
* Property notifications from Children *
|
|
* *
|
|
**********************************************/
|
|
static void
|
|
_child_start_changed_cb (GESTimelineElement * child,
|
|
GParamSpec * arg G_GNUC_UNUSED, GESContainer * container)
|
|
{
|
|
ChildMapping *map;
|
|
GstClockTime start;
|
|
|
|
GESContainerPrivate *priv = container->priv;
|
|
GESTimelineElement *element = GES_TIMELINE_ELEMENT (container);
|
|
GESChildrenControlMode pmode = container->children_control_mode;
|
|
|
|
map = g_hash_table_lookup (priv->mappings, child);
|
|
g_assert (map);
|
|
|
|
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
|
|
container->children_control_mode = GES_CHILDREN_UPDATE_ALL_VALUES;
|
|
|
|
switch (container->children_control_mode) {
|
|
case GES_CHILDREN_IGNORE_NOTIFIES:
|
|
return;
|
|
case GES_CHILDREN_UPDATE_ALL_VALUES:
|
|
_ges_container_sort_children (container);
|
|
start = container->children ?
|
|
_START (container->children->data) : _START (container);
|
|
|
|
if (start != _START (container)) {
|
|
_DURATION (container) = _END (container) - start;
|
|
_START (container) = start;
|
|
|
|
GST_DEBUG_OBJECT (container, "Child move made us move %" GES_FORMAT,
|
|
GES_ARGS (container));
|
|
|
|
g_object_notify (G_OBJECT (container), "start");
|
|
}
|
|
|
|
/* Falltrough! */
|
|
case GES_CHILDREN_UPDATE_OFFSETS:
|
|
map->start_offset = _START (container) - _START (child);
|
|
break;
|
|
|
|
case GES_CHILDREN_UPDATE:
|
|
/* We update all the children calling our set_start method */
|
|
container->initiated_move = child;
|
|
_set_start0 (element, _START (child) + map->start_offset);
|
|
container->initiated_move = NULL;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
|
|
container->children_control_mode = pmode;
|
|
}
|
|
|
|
static void
|
|
_child_inpoint_changed_cb (GESTimelineElement * child,
|
|
GParamSpec * arg G_GNUC_UNUSED, GESContainer * container)
|
|
{
|
|
ChildMapping *map;
|
|
|
|
GESContainerPrivate *priv = container->priv;
|
|
GESTimelineElement *element = GES_TIMELINE_ELEMENT (container);
|
|
|
|
if (container->children_control_mode == GES_CHILDREN_IGNORE_NOTIFIES)
|
|
return;
|
|
|
|
map = g_hash_table_lookup (priv->mappings, child);
|
|
g_assert (map);
|
|
|
|
if (container->children_control_mode == GES_CHILDREN_UPDATE_OFFSETS
|
|
|| ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE)) {
|
|
map->inpoint_offset = _INPOINT (container) - _INPOINT (child);
|
|
|
|
return;
|
|
}
|
|
|
|
/* We update all the children calling our set_inpoint method */
|
|
container->initiated_move = child;
|
|
_set_inpoint0 (element, _INPOINT (child) + map->inpoint_offset);
|
|
container->initiated_move = NULL;
|
|
}
|
|
|
|
static void
|
|
_child_duration_changed_cb (GESTimelineElement * child,
|
|
GParamSpec * arg G_GNUC_UNUSED, GESContainer * container)
|
|
{
|
|
ChildMapping *map;
|
|
|
|
GList *tmp;
|
|
GstClockTime end = 0;
|
|
GESContainerPrivate *priv = container->priv;
|
|
GESTimelineElement *element = GES_TIMELINE_ELEMENT (container);
|
|
GESChildrenControlMode pmode = container->children_control_mode;
|
|
|
|
if (container->children_control_mode == GES_CHILDREN_IGNORE_NOTIFIES)
|
|
return;
|
|
|
|
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
|
|
container->children_control_mode = GES_CHILDREN_UPDATE_ALL_VALUES;
|
|
|
|
map = g_hash_table_lookup (priv->mappings, child);
|
|
g_assert (map);
|
|
|
|
switch (container->children_control_mode) {
|
|
case GES_CHILDREN_IGNORE_NOTIFIES:
|
|
break;
|
|
case GES_CHILDREN_UPDATE_ALL_VALUES:
|
|
_ges_container_sort_children_by_end (container);
|
|
|
|
for (tmp = container->children; tmp; tmp = tmp->next)
|
|
end = MAX (end, _END (tmp->data));
|
|
|
|
if (end != _END (container)) {
|
|
_DURATION (container) = end - _START (container);
|
|
g_object_notify (G_OBJECT (container), "duration");
|
|
}
|
|
/* Falltrough */
|
|
case GES_CHILDREN_UPDATE_OFFSETS:
|
|
map->inpoint_offset = _START (container) - _START (child);
|
|
break;
|
|
case GES_CHILDREN_UPDATE:
|
|
/* We update all the children calling our set_duration method */
|
|
container->initiated_move = child;
|
|
_set_duration0 (element, _DURATION (child) + map->duration_offset);
|
|
container->initiated_move = NULL;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (ELEMENT_FLAG_IS_SET (child, GES_TIMELINE_ELEMENT_SET_SIMPLE))
|
|
container->children_control_mode = pmode;
|
|
}
|
|
|
|
/****************************************************
|
|
* *
|
|
* Internal methods implementation *
|
|
* *
|
|
****************************************************/
|
|
|
|
void
|
|
_ges_container_sort_children (GESContainer * container)
|
|
{
|
|
container->children = g_list_sort (container->children,
|
|
(GCompareFunc) element_start_compare);
|
|
}
|
|
|
|
void
|
|
_ges_container_sort_children_by_end (GESContainer * container)
|
|
{
|
|
container->children = g_list_sort (container->children,
|
|
(GCompareFunc) element_end_compare);
|
|
}
|
|
|
|
void
|
|
_ges_container_set_height (GESContainer * container, guint32 height)
|
|
{
|
|
if (container->height != height) {
|
|
container->height = height;
|
|
GST_DEBUG_OBJECT (container, "Updating height %i", container->height);
|
|
g_object_notify (G_OBJECT (container), "height");
|
|
}
|
|
}
|
|
|
|
gint
|
|
_ges_container_get_priority_offset (GESContainer * container,
|
|
GESTimelineElement * elem)
|
|
{
|
|
ChildMapping *map = g_hash_table_lookup (container->priv->mappings, elem);
|
|
|
|
g_return_val_if_fail (map, 0);
|
|
|
|
return map->priority_offset;
|
|
}
|
|
|
|
void
|
|
_ges_container_set_priority_offset (GESContainer * container,
|
|
GESTimelineElement * elem, gint32 priority_offset)
|
|
{
|
|
ChildMapping *map = g_hash_table_lookup (container->priv->mappings, elem);
|
|
|
|
g_return_if_fail (map);
|
|
|
|
map->priority_offset = priority_offset;
|
|
}
|
|
|
|
/**********************************************
|
|
* *
|
|
* API implementation *
|
|
* *
|
|
**********************************************/
|
|
|
|
/**
|
|
* ges_container_add:
|
|
* @container: a #GESContainer
|
|
* @child: the #GESTimelineElement
|
|
*
|
|
* Add the #GESTimelineElement to the container.
|
|
*
|
|
* Returns: %TRUE on success, %FALSE on failure.
|
|
*/
|
|
gboolean
|
|
ges_container_add (GESContainer * container, GESTimelineElement * child)
|
|
{
|
|
ChildMapping *mapping;
|
|
gboolean notify_start = FALSE;
|
|
GESContainerClass *class;
|
|
GESContainerPrivate *priv;
|
|
|
|
g_return_val_if_fail (GES_IS_CONTAINER (container), FALSE);
|
|
g_return_val_if_fail (GES_IS_TIMELINE_ELEMENT (child), FALSE);
|
|
g_return_val_if_fail (GES_TIMELINE_ELEMENT_PARENT (child) == NULL, FALSE);
|
|
|
|
class = GES_CONTAINER_GET_CLASS (container);
|
|
priv = container->priv;
|
|
|
|
GST_DEBUG_OBJECT (container, "adding timeline element %" GST_PTR_FORMAT,
|
|
child);
|
|
|
|
container->children_control_mode = GES_CHILDREN_IGNORE_NOTIFIES;
|
|
if (class->add_child) {
|
|
if (class->add_child (container, child) == FALSE) {
|
|
container->children_control_mode = GES_CHILDREN_UPDATE;
|
|
GST_WARNING_OBJECT (container, "Erreur adding child %p", child);
|
|
return FALSE;
|
|
}
|
|
}
|
|
container->children_control_mode = GES_CHILDREN_UPDATE;
|
|
|
|
if (_START (container) > _START (child)) {
|
|
_START (container) = _START (child);
|
|
|
|
g_hash_table_foreach (priv->mappings, (GHFunc) _resync_start_offsets,
|
|
container);
|
|
notify_start = TRUE;
|
|
}
|
|
|
|
mapping = g_slice_new0 (ChildMapping);
|
|
mapping->child = gst_object_ref (child);
|
|
mapping->start_offset = _START (container) - _START (child);
|
|
mapping->duration_offset = _DURATION (container) - _DURATION (child);
|
|
mapping->inpoint_offset = _INPOINT (container) - _INPOINT (child);
|
|
|
|
g_hash_table_insert (priv->mappings, child, mapping);
|
|
|
|
container->children = g_list_prepend (container->children, child);
|
|
|
|
_ges_container_sort_children (container);
|
|
|
|
/* Listen to all property changes */
|
|
mapping->start_notifyid =
|
|
g_signal_connect (G_OBJECT (child), "notify::start",
|
|
G_CALLBACK (_child_start_changed_cb), container);
|
|
mapping->duration_notifyid =
|
|
g_signal_connect (G_OBJECT (child), "notify::duration",
|
|
G_CALLBACK (_child_duration_changed_cb), container);
|
|
mapping->inpoint_notifyid =
|
|
g_signal_connect (G_OBJECT (child), "notify::in-point",
|
|
G_CALLBACK (_child_inpoint_changed_cb), container);
|
|
|
|
if (ges_timeline_element_set_parent (child, GES_TIMELINE_ELEMENT (container))
|
|
== FALSE) {
|
|
if (class->remove_child)
|
|
class->remove_child (container, child);
|
|
|
|
g_hash_table_remove (priv->mappings, child);
|
|
container->children = g_list_remove (container->children, child);
|
|
_ges_container_sort_children (container);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
_ges_container_add_child_properties (container, child);
|
|
|
|
priv->adding_children = g_list_prepend (priv->adding_children, child);
|
|
g_signal_emit (container, ges_container_signals[CHILD_ADDED_SIGNAL], 0,
|
|
child);
|
|
priv->adding_children = g_list_remove (priv->adding_children, child);
|
|
|
|
if (notify_start)
|
|
g_object_notify (G_OBJECT (container), "start");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* ges_container_remove:
|
|
* @container: a #GESContainer
|
|
* @child: the #GESTimelineElement to release
|
|
*
|
|
* Release the @child from the control of @container.
|
|
*
|
|
* Returns: %TRUE if the @child was properly released, else %FALSE.
|
|
*/
|
|
gboolean
|
|
ges_container_remove (GESContainer * container, GESTimelineElement * child)
|
|
{
|
|
GESContainerClass *klass;
|
|
GESContainerPrivate *priv;
|
|
|
|
g_return_val_if_fail (GES_IS_CONTAINER (container), FALSE);
|
|
g_return_val_if_fail (GES_IS_TIMELINE_ELEMENT (child), FALSE);
|
|
|
|
GST_DEBUG_OBJECT (container, "removing child: %" GST_PTR_FORMAT, child);
|
|
|
|
klass = GES_CONTAINER_GET_CLASS (container);
|
|
priv = container->priv;
|
|
|
|
if (!(g_hash_table_lookup (priv->mappings, child))) {
|
|
GST_WARNING_OBJECT (container, "Element isn't controlled by this "
|
|
"container");
|
|
return FALSE;
|
|
}
|
|
|
|
if (klass->remove_child) {
|
|
if (klass->remove_child (container, child) == FALSE)
|
|
return FALSE;
|
|
}
|
|
|
|
container->children = g_list_remove (container->children, child);
|
|
/* Let it live removing from our mappings */
|
|
g_hash_table_remove (priv->mappings, child);
|
|
|
|
_ges_container_remove_child_properties (container, child);
|
|
|
|
if (!g_list_find (container->priv->adding_children, child)) {
|
|
g_signal_emit (container, ges_container_signals[CHILD_REMOVED_SIGNAL], 0,
|
|
child);
|
|
} else {
|
|
GST_INFO_OBJECT (container, "Not emitting 'child-removed' signal as child"
|
|
" removal happend during 'child-added' signal emission");
|
|
}
|
|
gst_object_unref (child);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
_get_children_recursively (GESContainer * container, GList ** children)
|
|
{
|
|
GList *tmp;
|
|
|
|
*children =
|
|
g_list_concat (*children, g_list_copy_deep (container->children,
|
|
(GCopyFunc) gst_object_ref, NULL));
|
|
|
|
for (tmp = container->children; tmp; tmp = tmp->next) {
|
|
GESTimelineElement *element = tmp->data;
|
|
|
|
if (GES_IS_CONTAINER (element))
|
|
_get_children_recursively (tmp->data, children);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ges_container_get_children:
|
|
* @container: a #GESContainer
|
|
* @recursive: Whether to recursively get children in @container
|
|
*
|
|
* Get the list of #GESTimelineElement contained in @container
|
|
* The user is responsible for unreffing the contained objects
|
|
* and freeing the list.
|
|
*
|
|
* Returns: (transfer full) (element-type GESTimelineElement): The list of
|
|
* timeline element contained in @container.
|
|
*/
|
|
GList *
|
|
ges_container_get_children (GESContainer * container, gboolean recursive)
|
|
{
|
|
GList *children = NULL;
|
|
|
|
g_return_val_if_fail (GES_IS_CONTAINER (container), NULL);
|
|
|
|
if (!recursive)
|
|
return g_list_copy_deep (container->children, (GCopyFunc) gst_object_ref,
|
|
NULL);
|
|
|
|
_get_children_recursively (container, &children);
|
|
return children;
|
|
}
|
|
|
|
/**
|
|
* ges_container_ungroup:
|
|
* @container: (transfer full): The #GESContainer to ungroup
|
|
* @recursive: Wether to recursively ungroup @container
|
|
*
|
|
* Ungroups the #GESTimelineElement contained in this GESContainer,
|
|
* creating new #GESContainer containing those #GESTimelineElement
|
|
* apropriately.
|
|
*
|
|
* Returns: (transfer full) (element-type GESContainer): The list of
|
|
* #GESContainer resulting from the ungrouping operation
|
|
* The user is responsible for unreffing the contained objects
|
|
* and freeing the list.
|
|
*/
|
|
GList *
|
|
ges_container_ungroup (GESContainer * container, gboolean recursive)
|
|
{
|
|
GESContainerClass *klass;
|
|
|
|
g_return_val_if_fail (GES_IS_CONTAINER (container), NULL);
|
|
|
|
GST_DEBUG_OBJECT (container, "Ungrouping container %s recursively",
|
|
recursive ? "" : "not");
|
|
|
|
klass = GES_CONTAINER_GET_CLASS (container);
|
|
if (klass->ungroup == NULL) {
|
|
GST_INFO_OBJECT (container, "No ungoup virtual method, doint nothing");
|
|
return NULL;
|
|
}
|
|
|
|
return klass->ungroup (container, recursive);
|
|
}
|
|
|
|
/**
|
|
* ges_container_group:
|
|
* @containers: (transfer none)(element-type GESContainer) (allow-none): The
|
|
* #GESContainer to group, they must all be in a same #GESTimeline
|
|
*
|
|
* Groups the #GESContainer-s provided in @containers. It creates a subclass
|
|
* of #GESContainer, depending on the containers provided in @containers.
|
|
* Basically, if all the containers in @containers should be contained in a same
|
|
* clip (all the #GESTrackElement they contain have the exact same
|
|
* start/inpoint/duration and are in the same layer), it will create a #GESClip
|
|
* otherwise a #GESGroup will be created
|
|
*
|
|
* Returns: (transfer none): The #GESContainer (subclass) resulting of the
|
|
* grouping
|
|
*/
|
|
GESContainer *
|
|
ges_container_group (GList * containers)
|
|
{
|
|
GList *tmp;
|
|
guint n_children;
|
|
GType *children_types;
|
|
GESTimelineElement *element;
|
|
GObjectClass *clip_class;
|
|
|
|
guint i = 0;
|
|
GESContainer *ret = NULL;
|
|
GESTimeline *timeline = NULL;
|
|
|
|
if (containers) {
|
|
element = GES_TIMELINE_ELEMENT (containers->data);
|
|
timeline = GES_TIMELINE_ELEMENT_TIMELINE (element);
|
|
g_return_val_if_fail (timeline, NULL);
|
|
}
|
|
|
|
if (g_list_length (containers) == 1)
|
|
return containers->data;
|
|
|
|
for (tmp = containers; tmp; tmp = tmp->next) {
|
|
g_return_val_if_fail (GES_IS_CONTAINER (tmp->data), NULL);
|
|
g_return_val_if_fail (GES_TIMELINE_ELEMENT_PARENT (tmp->data) == NULL,
|
|
NULL);
|
|
g_return_val_if_fail (GES_TIMELINE_ELEMENT_TIMELINE (tmp->data) == timeline,
|
|
NULL);
|
|
}
|
|
|
|
children_types = g_type_children (GES_TYPE_CONTAINER, &n_children);
|
|
g_qsort_with_data (children_types, n_children, sizeof (GType),
|
|
(GCompareDataFunc) compare_grouping_prio, NULL);
|
|
|
|
for (i = 0; i < n_children; i++) {
|
|
clip_class = g_type_class_peek (children_types[i]);
|
|
ret = GES_CONTAINER_CLASS (clip_class)->group (containers);
|
|
|
|
if (ret)
|
|
break;
|
|
}
|
|
|
|
g_free (children_types);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ges_container_edit:
|
|
* @container: the #GESClip to edit
|
|
* @layers: (element-type GESLayer): The layers you want the edit to
|
|
* happen in, %NULL means that the edition is done in all the
|
|
* #GESLayers contained in the current timeline.
|
|
* @new_layer_priority: The priority of the layer @container should land in.
|
|
* If the layer you're trying to move the container to doesn't exist, it will
|
|
* be created automatically. -1 means no move.
|
|
* @mode: The #GESEditMode in which the editition will happen.
|
|
* @edge: The #GESEdge the edit should happen on.
|
|
* @position: The position at which to edit @container (in nanosecond)
|
|
*
|
|
* Edit @container in the different exisiting #GESEditMode modes. In the case of
|
|
* slide, and roll, you need to specify a #GESEdge
|
|
*
|
|
* Returns: %TRUE if the container as been edited properly, %FALSE if an error
|
|
* occured
|
|
*
|
|
* Deprecated: 1.18: use #ges_timeline_element_edit instead.
|
|
*/
|
|
gboolean
|
|
ges_container_edit (GESContainer * container, GList * layers,
|
|
gint new_layer_priority, GESEditMode mode, GESEdge edge, guint64 position)
|
|
{
|
|
g_return_val_if_fail (GES_IS_CONTAINER (container), FALSE);
|
|
|
|
return ges_timeline_element_edit (GES_TIMELINE_ELEMENT (container),
|
|
layers, new_layer_priority, mode, edge, position);
|
|
}
|