/**
* aran_solver3d_set_development:
* @solver: an #AranSolver3d.
* @devel_type: #GType of development to be used by the solver.
* @devel: instance of type @devel_type for cloning.
* @zero: @devel_type zeroing function.
*
* Associates @solver with a new development definition.
*/
void aran_solver3d_set_development (AranSolver3d *solver,
GType devel_type,
gpointer devel,
AranZeroFunc zero)
{
g_return_if_fail (solver != NULL);
g_return_if_fail ((devel_type == G_TYPE_NONE) ||
G_TYPE_IS_BOXED (devel_type));
if (solver->devel != NULL)
g_boxed_free (solver->devel_type, solver->devel);
solver->devel_type = devel_type;
solver->devel = devel;
solver->zero = zero;
if (devel != NULL)
{
vsg_prtree3d_set_node_data (solver->prtree, devel_type, devel);
}
else
{
vsg_prtree3d_set_node_data (solver->prtree,
G_TYPE_NONE,
NULL);
}
}
/**
* g_boxed_free:
* @boxed_type: The type of @boxed.
* @boxed: The boxed structure to be freed.
*
* Free the boxed structure @boxed which is of type @boxed_type.
*/
void
g_boxed_free (GType boxed_type,
gpointer boxed)
{
GTypeValueTable *value_table;
g_return_if_fail (G_TYPE_IS_BOXED (boxed_type));
g_return_if_fail (G_TYPE_IS_ABSTRACT (boxed_type) == FALSE);
g_return_if_fail (boxed != NULL);
value_table = g_type_value_table_peek (boxed_type);
if (!value_table)
g_return_if_fail (G_TYPE_IS_VALUE_TYPE (boxed_type));
/* check if our proxying implementation is used, we can short-cut here */
if (value_table->value_free == boxed_proxy_value_free)
{
BoxedNode key, *node;
key.type = boxed_type;
node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
node->free (boxed);
}
else
{
GValue value;
/* see g_boxed_copy() on why we think we can do this */
value_meminit (&value, boxed_type);
value.data[0].v_pointer = boxed;
value_table->value_free (&value);
}
}
gpointer
g_boxed_copy (GType boxed_type,
gconstpointer src_boxed)
{
GTypeValueTable *value_table;
gpointer dest_boxed;
g_return_val_if_fail (G_TYPE_IS_BOXED (boxed_type), NULL);
g_return_val_if_fail (G_TYPE_IS_ABSTRACT (boxed_type) == FALSE, NULL);
g_return_val_if_fail (src_boxed != NULL, NULL);
value_table = g_type_value_table_peek (boxed_type);
if (!value_table)
g_return_val_if_fail (G_TYPE_IS_VALUE_TYPE (boxed_type), NULL);
/* check if our proxying implementation is used, we can short-cut here */
if (value_table->value_copy == boxed_proxy_value_copy)
{
BoxedNode key, *node;
key.type = boxed_type;
node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
dest_boxed = node->copy ((gpointer) src_boxed);
}
else
{
GValue src_value, dest_value;
/* we heavil rely on third-party boxed type value vtable
* implementations to follow normal boxed value storage
* (data[0].v_pointer is the boxed struct, and
* data[1].v_uint holds the G_VALUE_NOCOPY_CONTENTS flag,
* rest zero).
* but then, we can expect that since we layed out the
* g_boxed_*() API.
* data[1].v_uint&G_VALUE_NOCOPY_CONTENTS shouldn't be set
* after a copy.
*/
/* equiv. to g_value_set_static_boxed() */
value_meminit (&src_value, boxed_type);
src_value.data[0].v_pointer = (gpointer) src_boxed;
src_value.data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
/* call third-party code copy fucntion, fingers-crossed */
value_meminit (&dest_value, boxed_type);
value_table->value_copy (&src_value, &dest_value);
/* double check and grouse if things went wrong */
if (dest_value.data[1].v_ulong ||
dest_value.data[2].v_ulong)
g_warning ("the copy_value() implementation of type `%s' seems to make use of reserved GValue fields",
g_type_name (boxed_type));
dest_boxed = dest_value.data[0].v_pointer;
}
return dest_boxed;
}
void
gkm_credential_set_data (GkmCredential *self, GType type, gpointer data)
{
g_return_if_fail (GKM_IS_CREDENTIAL (self));
if (data) {
g_return_if_fail (type);
g_return_if_fail (G_TYPE_IS_BOXED (type) || G_TYPE_IS_OBJECT (type));
}
clear_data (self);
if (data) {
self->pv->user_type = type;
if (G_TYPE_IS_BOXED (type))
self->pv->user_data = g_boxed_copy (type, data);
else if (G_TYPE_IS_OBJECT (type))
self->pv->user_data = g_object_ref (data);
else
g_assert_not_reached ();
}
}
static void
clear_data (GkmCredential *self)
{
if (!self->pv->user_data)
return;
if (G_TYPE_IS_BOXED (self->pv->user_type))
g_boxed_free (self->pv->user_type, self->pv->user_data);
else if (G_TYPE_IS_OBJECT (self->pv->user_type))
g_object_unref (self->pv->user_data);
else
g_assert_not_reached ();
self->pv->user_data = NULL;
self->pv->user_type = 0;
}
gpointer
gkm_credential_pop_data (GkmCredential *self, GType type)
{
gpointer data = NULL;
g_return_val_if_fail (GKM_IS_CREDENTIAL (self), NULL);
if (self->pv->user_data) {
g_return_val_if_fail (type == self->pv->user_type, NULL);
if (G_TYPE_IS_BOXED (self->pv->user_type))
data = g_boxed_copy (self->pv->user_type, self->pv->user_data);
else if (G_TYPE_IS_OBJECT (self->pv->user_type))
data = g_object_ref (self->pv->user_data);
else
g_assert_not_reached ();
}
gkm_object_mark_used (GKM_OBJECT (self));
return data;
}
GParamSpec*
g_param_spec_boxed (const gchar *name,
const gchar *nick,
const gchar *blurb,
GType boxed_type,
GParamFlags flags)
{
GParamSpecBoxed *bspec;
g_return_val_if_fail (G_TYPE_IS_BOXED (boxed_type), NULL);
g_return_val_if_fail (G_TYPE_IS_VALUE_TYPE (boxed_type), NULL);
bspec = g_param_spec_internal (G_TYPE_PARAM_BOXED,
name,
nick,
blurb,
flags);
G_PARAM_SPEC (bspec)->value_type = boxed_type;
return G_PARAM_SPEC (bspec);
}
GParamSpec*
bse_param_spec_boxed (const gchar *name,
const gchar *nick,
const gchar *blurb,
GType boxed_type,
const gchar *hints)
{
GParamSpec *pspec = NULL;
g_return_val_if_fail (G_TYPE_IS_BOXED (boxed_type), NULL);
if (sfi_boxed_type_get_rec_fields (boxed_type).n_fields ||
sfi_boxed_type_get_seq_element (boxed_type))
{
pspec = g_param_spec_boxed (name, nick, blurb, boxed_type, 0);
sfi_pspec_set_options (pspec, hints);
}
else
g_warning ("boxed parameter \"%s\" of type `%s' can't be converted to record or sequence",
name, g_type_name (boxed_type));
return pspec;
}
gboolean is_type_boxed(GType t) {
return G_TYPE_IS_BOXED(t);
}
static void
print_signal_info (GstElement * element)
{
/* Signals/Actions Block */
guint *signals;
guint nsignals;
gint i = 0, j, k;
GSignalQuery *query = NULL;
GType type;
GSList *found_signals, *l;
for (k = 0; k < 2; k++) {
found_signals = NULL;
/* For elements that have sometimes pads, also list a few useful GstElement
* signals. Put these first, so element-specific ones come later. */
if (k == 0 && has_sometimes_template (element)) {
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("pad-added", GST_TYPE_ELEMENT), query);
found_signals = g_slist_append (found_signals, query);
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("pad-removed", GST_TYPE_ELEMENT), query);
found_signals = g_slist_append (found_signals, query);
query = g_new0 (GSignalQuery, 1);
g_signal_query (g_signal_lookup ("no-more-pads", GST_TYPE_ELEMENT),
query);
found_signals = g_slist_append (found_signals, query);
}
for (type = G_OBJECT_TYPE (element); type; type = g_type_parent (type)) {
if (type == GST_TYPE_ELEMENT || type == GST_TYPE_OBJECT)
break;
if (type == GST_TYPE_BIN && G_OBJECT_TYPE (element) != GST_TYPE_BIN)
continue;
signals = g_signal_list_ids (type, &nsignals);
for (i = 0; i < nsignals; i++) {
query = g_new0 (GSignalQuery, 1);
g_signal_query (signals[i], query);
if ((k == 0 && !(query->signal_flags & G_SIGNAL_ACTION)) ||
(k == 1 && (query->signal_flags & G_SIGNAL_ACTION)))
found_signals = g_slist_append (found_signals, query);
else
g_free (query);
}
g_free (signals);
signals = NULL;
}
if (found_signals) {
n_print ("\n");
if (k == 0)
n_print ("Element Signals:\n");
else
n_print ("Element Actions:\n");
} else {
continue;
}
for (l = found_signals; l; l = l->next) {
gchar *indent;
const gchar *pmark;
int indent_len;
query = (GSignalQuery *) l->data;
indent_len = strlen (query->signal_name) +
strlen (g_type_name (query->return_type)) + 24;
if (query->return_type == G_TYPE_POINTER) {
pmark = "";
} else if (G_TYPE_FUNDAMENTAL (query->return_type) == G_TYPE_POINTER
|| G_TYPE_IS_BOXED (query->return_type)
|| G_TYPE_IS_OBJECT (query->return_type)) {
pmark = "* ";
indent_len += 2;
} else {
pmark = "";
}
indent = g_new0 (gchar, indent_len + 1);
memset (indent, ' ', indent_len);
n_print (" \"%s\" : %s %suser_function (%s* object",
query->signal_name, g_type_name (query->return_type), pmark,
g_type_name (type));
for (j = 0; j < query->n_params; j++) {
g_print (",\n");
if (G_TYPE_IS_FUNDAMENTAL (query->param_types[j])) {
n_print ("%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else if (G_TYPE_IS_ENUM (query->param_types[j])) {
n_print ("%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else {
n_print ("%s%s* arg%d", indent,
g_type_name (query->param_types[j]), j);
}
}
if (k == 0) {
g_print (",\n");
n_print ("%sgpointer user_data);\n", indent);
} else
g_print (");\n");
g_free (indent);
}
if (found_signals) {
g_slist_foreach (found_signals, (GFunc) g_free, NULL);
g_slist_free (found_signals);
}
}
}
