/**
* _validate:
* @datatype: #FoDatatype to be validated against allowed datatypes and
* values for current property.
* @context: #FoContext object from which to possibly inherit values.
* @error: Information about any error that has occurred.
*
* Validates @datatype against allowed values. Returns @datatype, a
* replacement datatype value, or NULL if validation failed.
*
* Return value: Valid datatype value or NULL.
**/
FoDatatype*
_validate (FoDatatype *datatype,
FoContext *context,
GError **error)
{
FoDatatype *new_datatype;
GError *tmp_error = NULL;
gchar *token;
g_return_val_if_fail (datatype != NULL, NULL);
g_return_val_if_fail (FO_IS_DATATYPE (datatype), NULL);
g_return_val_if_fail (context != NULL, NULL);
g_return_val_if_fail (FO_IS_CONTEXT (context), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (FO_IS_URI_SPECIFICATION (datatype))
{
return datatype;
}
else if (FO_IS_ENUM (datatype))
{
FoEnumEnum value = fo_enum_get_value (datatype);
if ((value == FO_ENUM_ENUM_NONE))
{
return datatype;
}
else
{
gchar *datatype_sprintf = fo_object_sprintf (datatype);
g_set_error (error,
FO_FO_ERROR,
FO_FO_ERROR_ENUMERATION_TOKEN,
_(fo_fo_error_messages[FO_FO_ERROR_ENUMERATION_TOKEN]),
class_name,
datatype_sprintf,
g_type_name (G_TYPE_FROM_INSTANCE (datatype)));
g_object_unref (datatype);
g_free (datatype_sprintf);
return NULL;
}
}
else if (FO_IS_STRING (datatype))
{
token = fo_string_get_value (datatype);
new_datatype =
_resolve_enum (token, context, &tmp_error);
g_object_unref (datatype);
fo_propagate_and_return_val_if_error (error, tmp_error, NULL);
return new_datatype;
}
else if (FO_IS_NAME (datatype))
{
token = fo_name_get_value (datatype);
new_datatype =
_resolve_enum (token, context, &tmp_error);
g_object_unref (datatype);
fo_propagate_and_return_val_if_error (error, tmp_error, NULL);
return new_datatype;
}
else
{
gchar *datatype_sprintf = fo_object_sprintf (datatype);
g_set_error (error,
FO_FO_ERROR,
FO_FO_ERROR_DATATYPE,
_(fo_fo_error_messages[FO_FO_ERROR_DATATYPE]),
class_name,
datatype_sprintf,
g_type_name (G_TYPE_FROM_INSTANCE (datatype)));
g_object_unref (datatype);
g_free (datatype_sprintf);
return NULL;
}
}
static gboolean
on_key_press_event (GtkWidget *widget, GdkEventKey *event, gpointer data)
{
gboolean modifier_matches = FALSE;
guint default_modifiers;
const gchar *type;
GtkWidget *focusw;
gint browse_key_setting;
if (event->type == GDK_KEY_PRESS) {
default_modifiers = gtk_accelerator_get_default_mod_mask ();
/* handle [<modifier>+]<Space> headline skimming hotkey */
switch (event->keyval) {
case GDK_KEY_space:
conf_get_int_value (BROWSE_KEY_SETTING, &browse_key_setting);
switch (browse_key_setting) {
default:
case 0:
modifier_matches = ((event->state & default_modifiers) == 0);
/* Hack to make space handled in the module. This is necessary
because the HTML widget code must be able to catch spaces
for input fields.
By ignoring the space here it will be passed to the HTML
widget which in turn will pass it back if it is not eaten by
any input field currently focussed. */
return FALSE;
case 1:
modifier_matches = ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK);
break;
case 2:
modifier_matches = ((event->state & GDK_MOD1_MASK) == GDK_MOD1_MASK);
break;
}
if (modifier_matches) {
itemview_scroll ();
return TRUE;
}
break;
}
/* some <Ctrl> hotkeys that overrule the HTML view */
if ((event->state & GDK_CONTROL_MASK) == GDK_CONTROL_MASK) {
switch (event->keyval) {
case GDK_KEY_KP_Add:
case GDK_KEY_equal:
case GDK_KEY_plus:
liferea_shell_do_zoom (TRUE);
return TRUE;
break;
case GDK_KEY_KP_Subtract:
case GDK_KEY_minus:
liferea_shell_do_zoom (FALSE);
return TRUE;
break;
}
}
/* prevent usage of navigation keys in entries */
focusw = gtk_window_get_focus (GTK_WINDOW (widget));
if (!focusw || GTK_IS_ENTRY (focusw))
return FALSE;
/* prevent usage of navigation keys in HTML view */
type = g_type_name (G_OBJECT_TYPE (focusw));
if (type && (g_str_equal (type, "WebKitWebView")))
return FALSE;
/* check for treeview navigation */
if (0 == (event->state & default_modifiers)) {
switch (event->keyval) {
case GDK_KEY_KP_Delete:
case GDK_KEY_Delete:
if (focusw == GTK_WIDGET (shell->priv->feedlistView))
return FALSE; /* to be handled in feed_list_view_key_press_cb() */
on_remove_item_activate (NULL, NULL);
return TRUE;
break;
case GDK_KEY_n:
on_next_unread_item_activate (NULL, NULL);
return TRUE;
break;
case GDK_KEY_f:
itemview_move_cursor (1);
return TRUE;
break;
case GDK_KEY_b:
itemview_move_cursor (-1);
return TRUE;
break;
case GDK_KEY_u:
ui_common_treeview_move_cursor (shell->priv->feedlistView, -1);
itemview_move_cursor_to_first ();
return TRUE;
break;
case GDK_KEY_d:
ui_common_treeview_move_cursor (shell->priv->feedlistView, 1);
itemview_move_cursor_to_first ();
return TRUE;
break;
}
}
}
return FALSE;
}
static GtkWidget *
property_editor (GObject *object,
GParamSpec *spec,
GtkInspectorPropEditor *editor)
{
GtkWidget *prop_edit;
GtkAdjustment *adj;
gchar *msg;
GType type = G_PARAM_SPEC_TYPE (spec);
if (type == G_TYPE_PARAM_INT)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_INT (spec)->default_value,
G_PARAM_SPEC_INT (spec)->minimum,
G_PARAM_SPEC_INT (spec)->maximum,
1,
MAX ((G_PARAM_SPEC_INT (spec)->maximum - G_PARAM_SPEC_INT (spec)->minimum) / 10, 1),
0.0);
prop_edit = gtk_spin_button_new (adj, 1.0, 0);
g_object_connect_property (object, spec, G_CALLBACK (int_changed), adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (int_modified));
}
else if (type == G_TYPE_PARAM_UINT)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_UINT (spec)->default_value,
G_PARAM_SPEC_UINT (spec)->minimum,
G_PARAM_SPEC_UINT (spec)->maximum,
1,
MAX ((G_PARAM_SPEC_UINT (spec)->maximum - G_PARAM_SPEC_UINT (spec)->minimum) / 10, 1),
0.0);
prop_edit = gtk_spin_button_new (adj, 1.0, 0);
g_object_connect_property (object, spec,
G_CALLBACK (uint_changed),
adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (uint_modified));
}
else if (type == G_TYPE_PARAM_FLOAT)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_FLOAT (spec)->default_value,
G_PARAM_SPEC_FLOAT (spec)->minimum,
G_PARAM_SPEC_FLOAT (spec)->maximum,
0.1,
MAX ((G_PARAM_SPEC_FLOAT (spec)->maximum - G_PARAM_SPEC_FLOAT (spec)->minimum) / 10, 0.1),
0.0);
prop_edit = gtk_spin_button_new (adj, 0.1, 2);
g_object_connect_property (object, spec,
G_CALLBACK (float_changed),
adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (float_modified));
}
else if (type == G_TYPE_PARAM_DOUBLE)
{
adj = gtk_adjustment_new (G_PARAM_SPEC_DOUBLE (spec)->default_value,
G_PARAM_SPEC_DOUBLE (spec)->minimum,
G_PARAM_SPEC_DOUBLE (spec)->maximum,
0.1,
MAX ((G_PARAM_SPEC_DOUBLE (spec)->maximum - G_PARAM_SPEC_DOUBLE (spec)->minimum) / 10, 0.1),
0.0);
prop_edit = gtk_spin_button_new (adj, 0.1, 2);
g_object_connect_property (object, spec,
G_CALLBACK (double_changed),
adj, G_OBJECT (adj));
connect_controller (G_OBJECT (adj), "value_changed",
object, spec, G_CALLBACK (double_modified));
}
else if (type == G_TYPE_PARAM_STRING)
{
prop_edit = gtk_entry_new ();
g_object_connect_property (object, spec,
G_CALLBACK (string_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "changed",
object, spec, G_CALLBACK (string_modified));
}
else if (type == G_TYPE_PARAM_BOOLEAN)
{
prop_edit = gtk_toggle_button_new_with_label ("");
g_object_connect_property (object, spec,
G_CALLBACK (bool_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "toggled",
object, spec, G_CALLBACK (bool_modified));
}
else if (type == G_TYPE_PARAM_ENUM)
{
{
GtkWidget *box;
GEnumClass *eclass;
GtkWidget *first;
gint j;
prop_edit = gtk_scrolled_window_new (NULL, NULL);
g_object_set (prop_edit,
"expand", TRUE,
"hscrollbar-policy", GTK_POLICY_NEVER,
"vscrollbar-policy", GTK_POLICY_NEVER,
NULL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (prop_edit), box);
eclass = G_ENUM_CLASS (g_type_class_ref (spec->value_type));
j = 0;
first = NULL;
while (j < eclass->n_values)
{
GtkWidget *b;
b = gtk_radio_button_new_with_label_from_widget ((GtkRadioButton*)first, eclass->values[j].value_name);
if (first == NULL)
first = b;
g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j));
gtk_widget_show (b);
gtk_box_pack_start (GTK_BOX (box), b, FALSE, FALSE, 0);
connect_controller (G_OBJECT (b), "toggled",
object, spec, G_CALLBACK (enum_modified));
++j;
}
if (j >= 10)
g_object_set (prop_edit, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL);
g_type_class_unref (eclass);
g_object_connect_property (object, spec,
G_CALLBACK (enum_changed),
prop_edit, G_OBJECT (prop_edit));
}
}
else if (type == G_TYPE_PARAM_FLAGS)
{
{
GtkWidget *box;
GFlagsClass *fclass;
gint j;
prop_edit = gtk_scrolled_window_new (NULL, NULL);
g_object_set (prop_edit,
"expand", TRUE,
"hscrollbar-policy", GTK_POLICY_NEVER,
"vscrollbar-policy", GTK_POLICY_NEVER,
NULL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (prop_edit), box);
fclass = G_FLAGS_CLASS (g_type_class_ref (spec->value_type));
for (j = 0; j < fclass->n_values; j++)
{
GtkWidget *b;
b = gtk_check_button_new_with_label (fclass->values[j].value_name);
g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j));
gtk_widget_show (b);
gtk_box_pack_start (GTK_BOX (box), b, FALSE, FALSE, 0);
connect_controller (G_OBJECT (b), "toggled",
object, spec, G_CALLBACK (flags_modified));
}
if (j >= 10)
g_object_set (prop_edit, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL);
g_type_class_unref (fclass);
g_object_connect_property (object, spec,
G_CALLBACK (flags_changed),
prop_edit, G_OBJECT (prop_edit));
}
}
else if (type == G_TYPE_PARAM_UNICHAR)
{
prop_edit = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (prop_edit), 1);
g_object_connect_property (object, spec,
G_CALLBACK (unichar_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "changed",
object, spec, G_CALLBACK (unichar_modified));
}
else if (type == G_TYPE_PARAM_POINTER)
{
prop_edit = gtk_label_new ("");
g_object_connect_property (object, spec,
G_CALLBACK (pointer_changed),
prop_edit, G_OBJECT (prop_edit));
}
else if (type == G_TYPE_PARAM_OBJECT)
{
GtkWidget *label, *button;
prop_edit = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
label = gtk_label_new ("");
button = gtk_button_new_with_label (_("Properties"));
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (object_properties),
editor);
gtk_container_add (GTK_CONTAINER (prop_edit), label);
gtk_container_add (GTK_CONTAINER (prop_edit), button);
gtk_widget_show (label);
gtk_widget_show (button);
g_object_connect_property (object, spec,
G_CALLBACK (object_changed),
prop_edit, G_OBJECT (label));
}
else if (type == G_TYPE_PARAM_BOXED &&
G_PARAM_SPEC_VALUE_TYPE (spec) == GDK_TYPE_RGBA)
{
prop_edit = gtk_color_chooser_widget_new ();
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (prop_edit), TRUE);
g_object_connect_property (object, spec,
G_CALLBACK (rgba_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "notify::rgba",
object, spec, G_CALLBACK (rgba_modified));
}
else if (type == G_TYPE_PARAM_BOXED &&
G_PARAM_SPEC_VALUE_TYPE (spec) == g_type_from_name ("GdkColor"))
{
prop_edit = gtk_color_chooser_widget_new ();
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (prop_edit), FALSE);
g_object_connect_property (object, spec,
G_CALLBACK (color_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "notify::rgba",
object, spec, G_CALLBACK (color_modified));
}
else if (type == G_TYPE_PARAM_BOXED &&
G_PARAM_SPEC_VALUE_TYPE (spec) == PANGO_TYPE_FONT_DESCRIPTION)
{
prop_edit = gtk_font_chooser_widget_new ();
g_object_connect_property (object, spec,
G_CALLBACK (font_changed),
prop_edit, G_OBJECT (prop_edit));
connect_controller (G_OBJECT (prop_edit), "notify::font-desc",
object, spec, G_CALLBACK (font_modified));
}
else
{
msg = g_strdup_printf (_("Uneditable property type: %s"),
g_type_name (G_PARAM_SPEC_TYPE (spec)));
prop_edit = gtk_label_new (msg);
g_free (msg);
gtk_widget_set_halign (prop_edit, GTK_ALIGN_START);
gtk_widget_set_valign (prop_edit, GTK_ALIGN_CENTER);
}
if (g_param_spec_get_blurb (spec))
gtk_widget_set_tooltip_text (prop_edit, g_param_spec_get_blurb (spec));
notify_property (object, spec);
return prop_edit;
}
static void
print_element_list (gboolean print_all)
{
int plugincount = 0, featurecount = 0, blacklistcount = 0;
GList *plugins, *orig_plugins;
orig_plugins = plugins = gst_registry_get_plugin_list (gst_registry_get ());
while (plugins) {
GList *features, *orig_features;
GstPlugin *plugin;
plugin = (GstPlugin *) (plugins->data);
plugins = g_list_next (plugins);
plugincount++;
if (GST_OBJECT_FLAG_IS_SET (plugin, GST_PLUGIN_FLAG_BLACKLISTED)) {
blacklistcount++;
continue;
}
orig_features = features =
gst_registry_get_feature_list_by_plugin (gst_registry_get (),
gst_plugin_get_name (plugin));
while (features) {
GstPluginFeature *feature;
if (G_UNLIKELY (features->data == NULL))
goto next;
feature = GST_PLUGIN_FEATURE (features->data);
featurecount++;
if (GST_IS_ELEMENT_FACTORY (feature)) {
GstElementFactory *factory;
factory = GST_ELEMENT_FACTORY (feature);
if (print_all)
print_element_info (factory, TRUE);
else
g_print ("%s: %s: %s\n", gst_plugin_get_name (plugin),
GST_OBJECT_NAME (factory),
gst_element_factory_get_metadata (factory,
GST_ELEMENT_METADATA_LONGNAME));
} else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
GstTypeFindFactory *factory;
const gchar *const *extensions;
factory = GST_TYPE_FIND_FACTORY (feature);
if (!print_all)
g_print ("%s: %s: ", gst_plugin_get_name (plugin),
gst_plugin_feature_get_name (feature));
extensions = gst_type_find_factory_get_extensions (factory);
if (extensions != NULL) {
guint i = 0;
while (extensions[i]) {
if (!print_all)
g_print ("%s%s", i > 0 ? ", " : "", extensions[i]);
i++;
}
if (!print_all)
g_print ("\n");
} else {
if (!print_all)
g_print ("no extensions\n");
}
} else {
if (!print_all)
n_print ("%s: %s (%s)\n", gst_plugin_get_name (plugin),
GST_OBJECT_NAME (feature), g_type_name (G_OBJECT_TYPE (feature)));
}
next:
features = g_list_next (features);
}
gst_plugin_feature_list_free (orig_features);
}
gst_plugin_list_free (orig_plugins);
g_print ("\n");
g_print (_("Total count: "));
g_print (ngettext ("%d plugin", "%d plugins", plugincount), plugincount);
if (blacklistcount) {
g_print (" (");
g_print (ngettext ("%d blacklist entry", "%d blacklist entries",
blacklistcount), blacklistcount);
g_print (" not shown)");
}
g_print (", ");
g_print (ngettext ("%d feature", "%d features", featurecount), featurecount);
g_print ("\n");
}
/**
* g_strdup_value_contents:
* @value: #GValue which contents are to be described.
*
* Return a newly allocated string, which describes the contents of a
* #GValue. The main purpose of this function is to describe #GValue
* contents for debugging output, the way in which the contents are
* described may change between different GLib versions.
*
* Returns: Newly allocated string.
*/
gchar*
g_strdup_value_contents (const GValue *value)
{
const gchar *src;
gchar *contents;
g_return_val_if_fail (G_IS_VALUE (value), NULL);
if (G_VALUE_HOLDS_STRING (value))
{
src = g_value_get_string (value);
if (!src)
contents = g_strdup ("NULL");
else
{
gchar *s = g_strescape (src, NULL);
contents = g_strdup_printf ("\"%s\"", s);
g_free (s);
}
}
else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
{
GValue tmp_value = { 0, };
gchar *s;
g_value_init (&tmp_value, G_TYPE_STRING);
g_value_transform (value, &tmp_value);
s = g_strescape (g_value_get_string (&tmp_value), NULL);
g_value_unset (&tmp_value);
if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
contents = g_strdup_printf ("((%s) %s)",
g_type_name (G_VALUE_TYPE (value)),
s);
else
contents = g_strdup (s ? s : "NULL");
g_free (s);
}
else if (g_value_fits_pointer (value))
{
gpointer p = g_value_peek_pointer (value);
if (!p)
contents = g_strdup ("NULL");
else if (G_VALUE_HOLDS_OBJECT (value))
contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS_PARAM (value))
contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
GStrv strv = g_value_get_boxed (value);
GString *tmp = g_string_new ("[");
while (*strv != NULL)
{
gchar *escaped = g_strescape (*strv, NULL);
g_string_append_printf (tmp, "\"%s\"", escaped);
g_free (escaped);
if (*++strv != NULL)
g_string_append (tmp, ", ");
}
g_string_append (tmp, "]");
contents = g_string_free (tmp, FALSE);
}
else if (G_VALUE_HOLDS_BOXED (value))
contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
else if (G_VALUE_HOLDS_POINTER (value))
contents = g_strdup_printf ("((gpointer) %p)", p);
else
contents = g_strdup ("???");
}
else
contents = g_strdup ("???");
return contents;
}
static void
validate_one_property (const char *key, const char *value, gpointer user_data)
{
ValidateInfo *info = (ValidateInfo *) user_data;
int i;
if (*(info->error))
return;
info->have_items = TRUE;
/* 'name' is the setting name; always allowed but unused */
if (!strcmp (key, NM_SETTING_NAME))
return;
for (i = 0; info->table[i].name; i++) {
ValidProperty prop = info->table[i];
long int tmp;
if (strcmp (prop.name, key))
continue;
switch (prop.type) {
case G_TYPE_STRING:
return;
case G_TYPE_INT:
errno = 0;
tmp = strtol (value, NULL, 10);
if (errno == 0 && tmp >= prop.int_min && tmp <= prop.int_max)
return; /* valid */
g_set_error (info->error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
"invalid integer property '%s' or out of range [%d -> %d]",
key, prop.int_min, prop.int_max);
break;
case G_TYPE_BOOLEAN:
if (!strcmp (value, "yes") || !strcmp (value, "no"))
return; /* valid */
g_set_error (info->error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
"invalid boolean property '%s' (not yes or no)",
key);
break;
default:
g_set_error (info->error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
"unhandled property '%s' type %s",
key, g_type_name (prop.type));
break;
}
}
/* Did not find the property from valid_properties or the type did not match */
if (!info->table[i].name) {
g_set_error (info->error,
NM_VPN_PLUGIN_ERROR,
NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
"property '%s' invalid or not supported",
key);
}
}
static void
print_element_properties_info (GstElement * element)
{
GParamSpec **property_specs;
guint num_properties, i;
gboolean readable;
gboolean first_flag;
property_specs = g_object_class_list_properties
(G_OBJECT_GET_CLASS (element), &num_properties);
n_print ("\n");
n_print ("Element Properties:\n");
for (i = 0; i < num_properties; i++) {
GValue value = { 0, };
GParamSpec *param = property_specs[i];
readable = FALSE;
g_value_init (&value, param->value_type);
n_print (" %-20s: %s\n", g_param_spec_get_name (param),
g_param_spec_get_blurb (param));
first_flag = TRUE;
n_print ("%-23.23s flags: ", "");
if (param->flags & G_PARAM_READABLE) {
g_object_get_property (G_OBJECT (element), param->name, &value);
readable = TRUE;
g_print ("%s%s", (first_flag) ? "" : ", ", _("readable"));
first_flag = FALSE;
} else {
/* if we can't read the property value, assume it's set to the default
* (which might not be entirely true for sub-classes, but that's an
* unlikely corner-case anyway) */
g_param_value_set_default (param, &value);
}
if (param->flags & G_PARAM_WRITABLE) {
g_print ("%s%s", (first_flag) ? "" : ", ", _("writable"));
first_flag = FALSE;
}
if (param->flags & G_PARAM_DEPRECATED) {
g_print ("%s%s", (first_flag) ? "" : ", ", _("deprecated"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_CONTROLLABLE) {
g_print (", %s", _("controllable"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_MUTABLE_PLAYING) {
g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state"));
} else if (param->flags & GST_PARAM_MUTABLE_PAUSED) {
g_print (", %s", _("changeable only in NULL, READY or PAUSED state"));
} else if (param->flags & GST_PARAM_MUTABLE_READY) {
g_print (", %s", _("changeable only in NULL or READY state"));
}
if (param->flags & ~KNOWN_PARAM_FLAGS) {
g_print ("%s0x%0x", (first_flag) ? "" : ", ",
param->flags & ~KNOWN_PARAM_FLAGS);
}
n_print ("\n");
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
{
const char *string_val = g_value_get_string (&value);
n_print ("%-23.23s String. ", "");
if (string_val == NULL)
g_print ("Default: null");
else
g_print ("Default: \"%s\"", string_val);
break;
}
case G_TYPE_BOOLEAN:
{
gboolean bool_val = g_value_get_boolean (&value);
n_print ("%-23.23s Boolean. ", "");
g_print ("Default: %s", bool_val ? "true" : "false");
break;
}
case G_TYPE_ULONG:
{
GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
n_print ("%-23.23s Unsigned Long. ", "");
g_print ("Range: %lu - %lu Default: %lu ",
pulong->minimum, pulong->maximum, g_value_get_ulong (&value));
GST_ERROR ("%s: property '%s' of type ulong: consider changing to "
"uint/uint64", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
break;
}
case G_TYPE_LONG:
{
GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
n_print ("%-23.23s Long. ", "");
g_print ("Range: %ld - %ld Default: %ld ",
plong->minimum, plong->maximum, g_value_get_long (&value));
GST_ERROR ("%s: property '%s' of type long: consider changing to "
"int/int64", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
break;
}
case G_TYPE_UINT:
{
GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
n_print ("%-23.23s Unsigned Integer. ", "");
g_print ("Range: %u - %u Default: %u ",
puint->minimum, puint->maximum, g_value_get_uint (&value));
break;
}
case G_TYPE_INT:
{
GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
n_print ("%-23.23s Integer. ", "");
g_print ("Range: %d - %d Default: %d ",
pint->minimum, pint->maximum, g_value_get_int (&value));
break;
}
case G_TYPE_UINT64:
{
GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
n_print ("%-23.23s Unsigned Integer64. ", "");
g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT
" Default: %" G_GUINT64_FORMAT " ",
puint64->minimum, puint64->maximum, g_value_get_uint64 (&value));
break;
}
case G_TYPE_INT64:
{
GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
n_print ("%-23.23s Integer64. ", "");
g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
" Default: %" G_GINT64_FORMAT " ",
pint64->minimum, pint64->maximum, g_value_get_int64 (&value));
break;
}
case G_TYPE_FLOAT:
{
GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
n_print ("%-23.23s Float. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pfloat->minimum, pfloat->maximum, g_value_get_float (&value));
break;
}
case G_TYPE_DOUBLE:
{
GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
n_print ("%-23.23s Double. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pdouble->minimum, pdouble->maximum, g_value_get_double (&value));
break;
}
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
GST_ERROR ("%s: property '%s' of type char: consider changing to "
"int/string", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
/* fall through */
default:
if (param->value_type == GST_TYPE_CAPS) {
const GstCaps *caps = gst_value_get_caps (&value);
if (!caps)
n_print ("%-23.23s Caps (NULL)", "");
else {
print_caps (caps, " ");
}
} else if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
guint j = 0;
gint enum_value;
const gchar *value_nick = "";
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
enum_value = g_value_get_enum (&value);
while (values[j].value_name) {
if (values[j].value == enum_value)
value_nick = values[j].value_nick;
j++;
}
n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\"", "",
g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick);
j = 0;
while (values[j].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (%d): %-16s - %s", "",
values[j].value, values[j].value_nick, values[j].value_name);
j++;
}
/* g_type_class_unref (ec); */
} else if (G_IS_PARAM_SPEC_FLAGS (param)) {
GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param);
GFlagsValue *vals;
gchar *cur;
vals = pflags->flags_class->values;
cur = flags_to_string (vals, g_value_get_flags (&value));
n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "",
g_type_name (G_VALUE_TYPE (&value)),
g_value_get_flags (&value), cur);
while (vals[0].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (0x%08x): %-16s - %s", "",
vals[0].value, vals[0].value_nick, vals[0].value_name);
++vals;
}
g_free (cur);
} else if (G_IS_PARAM_SPEC_OBJECT (param)) {
n_print ("%-23.23s Object of type \"%s\"", "",
g_type_name (param->value_type));
} else if (G_IS_PARAM_SPEC_BOXED (param)) {
n_print ("%-23.23s Boxed pointer of type \"%s\"", "",
g_type_name (param->value_type));
if (param->value_type == GST_TYPE_STRUCTURE) {
const GstStructure *s = gst_value_get_structure (&value);
if (s)
gst_structure_foreach (s, print_field,
(gpointer) " ");
}
} else if (G_IS_PARAM_SPEC_POINTER (param)) {
if (param->value_type != G_TYPE_POINTER) {
n_print ("%-23.23s Pointer of type \"%s\".", "",
g_type_name (param->value_type));
} else {
n_print ("%-23.23s Pointer.", "");
}
} else if (param->value_type == G_TYPE_VALUE_ARRAY) {
GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param);
if (pvarray->element_spec) {
n_print ("%-23.23s Array of GValues of type \"%s\"", "",
g_type_name (pvarray->element_spec->value_type));
} else {
n_print ("%-23.23s Array of GValues", "");
}
} else if (GST_IS_PARAM_SPEC_FRACTION (param)) {
GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param);
n_print ("%-23.23s Fraction. ", "");
g_print ("Range: %d/%d - %d/%d Default: %d/%d ",
pfraction->min_num, pfraction->min_den,
pfraction->max_num, pfraction->max_den,
gst_value_get_fraction_numerator (&value),
gst_value_get_fraction_denominator (&value));
} else {
n_print ("%-23.23s Unknown type %ld \"%s\"", "",
(glong) param->value_type, g_type_name (param->value_type));
}
break;
}
if (!readable)
g_print (" Write only\n");
else
g_print ("\n");
g_value_reset (&value);
}
if (num_properties == 0)
n_print (" none\n");
g_free (property_specs);
}
/* Invalidate style to recompute styles */
static void _xfdashboard_actor_stylable_invalidate(XfdashboardStylable *inStylable)
{
XfdashboardActor *self;
XfdashboardActorPrivate *priv;
XfdashboardActorClass *klass;
XfdashboardTheme *theme;
XfdashboardThemeCSS *themeCSS;
GHashTable *possibleStyleSet;
GParamSpec *paramSpec;
GHashTableIter hashIter;
GHashTable *themeStyleSet;
gchar *styleName;
XfdashboardThemeCSSValue *styleValue;
gboolean didChange;
#ifdef DEBUG
gboolean doDebug=FALSE;
#endif
g_return_if_fail(XFDASHBOARD_IS_ACTOR(inStylable));
self=XFDASHBOARD_ACTOR(inStylable);
priv=self->priv;
klass=XFDASHBOARD_ACTOR_GET_CLASS(self);
didChange=FALSE;
/* Only recompute style for mapped actors */
if(!CLUTTER_ACTOR_IS_MAPPED(self)) return;
/* Get theme CSS */
theme=xfdashboard_application_get_theme();
themeCSS=xfdashboard_theme_get_css(theme);
/* First get list of all stylable properties of this and parent classes.
* It is used to determine if key in theme style sets are valid.
*/
possibleStyleSet=xfdashboard_actor_get_stylable_properties_full(klass);
#ifdef DEBUG
if(doDebug)
{
gint i=0;
gchar *defaultsKey;
GValue defaultsVal=G_VALUE_INIT;
gchar *defaultsValStr;
GParamSpec *realParamSpec;
g_debug("Got param specs for %p (%s) with class '%s' and pseudo-class '%s'", self, G_OBJECT_TYPE_NAME(self), priv->styleClasses, priv->stylePseudoClasses);
g_hash_table_iter_init(&hashIter, possibleStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&defaultsKey, (gpointer*)¶mSpec))
{
realParamSpec=(GParamSpec*)g_param_spec_get_qdata(paramSpec, XFDASHBOARD_ACTOR_PARAM_SPEC_REF);
g_value_init(&defaultsVal, G_PARAM_SPEC_VALUE_TYPE(realParamSpec));
g_param_value_set_default(realParamSpec, &defaultsVal);
defaultsValStr=g_strdup_value_contents(&defaultsVal);
g_debug("%d: param spec [%s] %s=%s\n", ++i, G_OBJECT_CLASS_NAME(klass), defaultsKey, defaultsValStr);
g_free(defaultsValStr);
g_value_unset(&defaultsVal);
}
g_debug("End of param specs");
}
#endif
/* Get style information from theme */
themeStyleSet=xfdashboard_theme_css_get_properties(themeCSS, XFDASHBOARD_STYLABLE(self));
#ifdef DEBUG
if(doDebug)
{
gint i=0;
g_debug("Got styles from theme for %p (%s) with class '%s' and pseudo-class '%s'", self, G_OBJECT_TYPE_NAME(self), priv->styleClasses, priv->stylePseudoClasses);
g_hash_table_iter_init(&hashIter, themeStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&styleName, (gpointer*)&styleValue))
{
g_debug("%d: [%s] %s=%s\n", ++i, styleValue->source, (gchar*)styleName, styleValue->string);
}
g_debug("End of styles from theme");
}
#endif
/* The 'property-changed' notification will be freezed and thawed
* (fired at once) after all stylable properties of this instance are set.
*/
g_object_freeze_notify(G_OBJECT(self));
/* Iterate through style information retrieved from theme and
* set the corresponding property in object instance if key
* is valid.
*/
g_hash_table_iter_init(&hashIter, themeStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&styleName, (gpointer*)&styleValue))
{
GValue cssValue=G_VALUE_INIT;
GValue propertyValue=G_VALUE_INIT;
GParamSpec *realParamSpec;
/* Check if key is a valid object property name */
if(!g_hash_table_lookup_extended(possibleStyleSet, styleName, NULL, (gpointer*)¶mSpec)) continue;
/* Get original referenced parameter specification. It does not need
* to be referenced while converting because it is valid as this
* value is stored in hashtable.
*/
realParamSpec=(GParamSpec*)g_param_spec_get_qdata(paramSpec, XFDASHBOARD_ACTOR_PARAM_SPEC_REF);
/* Convert style value to type of object property and set value
* if conversion was successful. Otherwise do nothing.
*/
g_value_init(&cssValue, G_TYPE_STRING);
g_value_set_string(&cssValue, styleValue->string);
g_value_init(&propertyValue, G_PARAM_SPEC_VALUE_TYPE(realParamSpec));
if(g_param_value_convert(realParamSpec, &cssValue, &propertyValue, FALSE))
{
g_object_set_property(G_OBJECT(self), styleName, &propertyValue);
didChange=TRUE;
#ifdef DEBUG
if(doDebug)
{
gchar *valstr;
valstr=g_strdup_value_contents(&propertyValue);
g_debug("Setting theme value of style property [%s] %s=%s\n", G_OBJECT_CLASS_NAME(klass), styleName, valstr);
g_free(valstr);
}
#endif
}
else
{
g_warning(_("Could not transform CSS string value for property '%s' to type %s of class %s"),
styleName, g_type_name(G_PARAM_SPEC_VALUE_TYPE(realParamSpec)), G_OBJECT_CLASS_NAME(klass));
}
/* Release allocated resources */
g_value_unset(&propertyValue);
g_value_unset(&cssValue);
}
/* Now remove all duplicate keys in set of properties changed we set the last
* time. The remaining keys determine the properties which were set the last
* time but not this time and should be restored to their default values.
*/
if(priv->lastThemeStyleSet)
{
/* Remove duplicate keys from set of last changed properties */
g_hash_table_foreach_remove(priv->lastThemeStyleSet, (GHRFunc)_xfdashboard_actor_hashtable_is_duplicate_key, themeStyleSet);
/* Iterate through remaining key and restore corresponding object properties
* to their default values.
*/
g_hash_table_iter_init(&hashIter, priv->lastThemeStyleSet);
while(g_hash_table_iter_next(&hashIter, (gpointer*)&styleName, (gpointer*)¶mSpec))
{
GValue propertyValue=G_VALUE_INIT;
GParamSpec *realParamSpec;
/* Check if key is a valid object property name */
if(!g_hash_table_lookup_extended(possibleStyleSet, styleName, NULL, (gpointer*)¶mSpec)) continue;
/* Get original referenced parameter specification. It does not need
* to be referenced while converting because it is valid as this
* value is stored in hashtable.
*/
realParamSpec=(GParamSpec*)g_param_spec_get_qdata(paramSpec, XFDASHBOARD_ACTOR_PARAM_SPEC_REF);
/* Initialize property value to its type and default value */
g_value_init(&propertyValue, G_PARAM_SPEC_VALUE_TYPE(realParamSpec));
g_param_value_set_default(realParamSpec, &propertyValue);
/* Set value at object property */
g_object_set_property(G_OBJECT(self), styleName, &propertyValue);
didChange=TRUE;
#ifdef DEBUG
if(doDebug)
{
gchar *valstr;
valstr=g_strdup_value_contents(&propertyValue);
g_debug("Restoring default value of style property [%s] %s=%s\n", G_OBJECT_CLASS_NAME(klass), styleName, valstr);
g_free(valstr);
}
#endif
/* Release allocated resources */
g_value_unset(&propertyValue);
}
/* Release resources of set of last changed properties as we do not need
* it anymore.
*/
g_hash_table_destroy(priv->lastThemeStyleSet);
priv->lastThemeStyleSet=NULL;
}
/* Remember this set of changed properties for next time to determine properties
* which need to be restored to their default value.
*/
priv->lastThemeStyleSet=themeStyleSet;
/* Release allocated resources */
g_hash_table_destroy(possibleStyleSet);
/* Force a redraw if any change was made at this actor */
if(didChange) clutter_actor_queue_redraw(CLUTTER_ACTOR(self));
/* All stylable properties are set now. So thaw 'property-changed'
* notification now and fire all notifications at once.
*/
g_object_thaw_notify(G_OBJECT(self));
}
static void
list_properties (GType type,
gint indent,
gboolean html)
{
GParamSpec **self;
GParamSpec **parent;
guint n_self;
guint n_parent;
gint prop_no;
if (!type)
return;
self = g_object_class_list_properties (
G_OBJECT_CLASS (g_type_class_ref (type)),
&n_self);
parent = g_object_class_list_properties (
/*G_OBJECT_CLASS (g_type_class_peek_parent (g_type_class_ref (type))),*/
G_OBJECT_CLASS (g_type_class_ref (GEGL_TYPE_OPERATION)),
&n_parent);
for (prop_no=0;prop_no<n_self;prop_no++)
{
gint parent_no;
gboolean found=FALSE;
for (parent_no=0;parent_no<n_parent;parent_no++)
if (self[prop_no]==parent[parent_no])
found=TRUE;
/* only print properties if we are an addition compared to
* GeglOperation
*/
if (!found)
{
const gchar *type_name = g_type_name (G_OBJECT_TYPE (self[prop_no]));
type_name = strstr (type_name, "Param");
type_name+=5;
g_print("<tr><td colspan='1'> </td><td colspan='1' class='prop_type' valign='top'>%s<br/><span style='font-style:normal;text-align:right;float:right;padding-right:1em;'>", type_name);
if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_DOUBLE))
{
g_print ("%2.2f", G_PARAM_SPEC_DOUBLE (self[prop_no])->default_value);
{
gdouble min = G_PARAM_SPEC_DOUBLE (self[prop_no])->minimum;
gdouble max = G_PARAM_SPEC_DOUBLE (self[prop_no])->maximum;
g_print ("<br/>");
if (min<-10000000)
g_print ("-inf ");
else
g_print ("%2.2f", min);
g_print ("-");
if (max>10000000)
g_print (" +inf");
else
g_print ("%2.2f", max);
}
}
else if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_INT))
{
g_print ("%i", G_PARAM_SPEC_INT (self[prop_no])->default_value);
{
gint min = G_PARAM_SPEC_INT (self[prop_no])->minimum;
gint max = G_PARAM_SPEC_INT (self[prop_no])->maximum;
g_print ("<br/>");
if (min<-10000000)
g_print ("-inf ");
else
g_print ("%i", min);
g_print ("-");
if (max>10000000)
g_print (" +inf");
else
g_print ("%i", max);
}
}
else if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_FLOAT))
{
g_print ("%2.2f", G_PARAM_SPEC_FLOAT (self[prop_no])->default_value);
}
else if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_BOOLEAN))
{
g_print ("%s", G_PARAM_SPEC_BOOLEAN (self[prop_no])->default_value?"True":"False");
}
else if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_STRING))
{
const gchar *string = G_PARAM_SPEC_STRING (self[prop_no])->default_value;
if (strlen (string) > 8)
{
gchar copy[16];
g_snprintf (copy, 12, "%s..", string);
g_print ("%s", copy);
}
else
g_print ("%s", string);
}
else if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), GEGL_TYPE_COLOR))
{
GeglColor *color = gegl_param_spec_color_get_default (self[prop_no]);
if (color)
{
gchar *string;
g_object_get (color, "string", &string, NULL);
g_print ("%s", string);
g_free (string);
g_object_unref (color);
}
}
else
{
g_print ("\n");
}
g_print ("</span></td>");
g_print("<td class='prop_name' valign='top'>%s</td>\n",
g_param_spec_get_name (self[prop_no]));
if (g_param_spec_get_blurb (self[prop_no])[0]!='\0')
g_print ("<td colspan='1' valign='top' class='prop_blurb'>%s</td>\n",
g_param_spec_get_blurb (self[prop_no]));
else
g_print ("<td><em>not documented</em></td>\n\n");
g_print ("</tr>\n");
}
}
if (self)
g_free (self);
if (parent)
g_free (parent);
}
static void
dvb_base_bin_class_init (DvbBaseBinClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBinClass *bin_class;
DvbBaseBinClass *dvbbasebin_class;
GstElementFactory *dvbsrc_factory;
GObjectClass *dvbsrc_class;
typedef struct
{
guint prop_id;
const gchar *prop_name;
} ProxyedProperty;
ProxyedProperty *walk;
ProxyedProperty proxyed_properties[] = {
{PROP_ADAPTER, "adapter"},
{PROP_FRONTEND, "frontend"},
{PROP_DISEQC_SRC, "diseqc-source"},
{PROP_FREQUENCY, "frequency"},
{PROP_POLARITY, "polarity"},
{PROP_SYMBOL_RATE, "symbol-rate"},
#ifndef GST_REMOVE_DEPRECATED
{PROP_BANDWIDTH, "bandwidth"},
#endif
{PROP_CODE_RATE_HP, "code-rate-hp"},
{PROP_CODE_RATE_LP, "code-rate-lp"},
{PROP_GUARD, "guard"},
{PROP_MODULATION, "modulation"},
{PROP_TRANS_MODE, "trans-mode"},
{PROP_HIERARCHY, "hierarchy"},
{PROP_INVERSION, "inversion"},
{PROP_STATS_REPORTING_INTERVAL, "stats-reporting-interval"},
{PROP_TUNING_TIMEOUT, "tuning-timeout"},
{PROP_DELSYS, "delsys"},
{PROP_PILOT, "pilot"},
{PROP_ROLLOFF, "rolloff"},
{PROP_STREAM_ID, "stream-id"},
{PROP_BANDWIDTH_HZ, "bandwidth-hz"},
{PROP_ISDBT_LAYER_ENABLED, "isdbt-layer-enabled"},
{PROP_ISDBT_PARTIAL_RECEPTION, "isdbt-partial-reception"},
{PROP_ISDBT_SOUND_BROADCASTING, "isdbt-sound-broadcasting"},
{PROP_ISDBT_SB_SUBCHANNEL_ID, "isdbt-sb-subchannel-id"},
{PROP_ISDBT_SB_SEGMENT_IDX, "isdbt-sb-segment-idx"},
{PROP_ISDBT_SB_SEGMENT_COUNT, "isdbt-sb-segment-count"},
{PROP_ISDBT_LAYERA_FEC, "isdbt-layera-fec"},
{PROP_ISDBT_LAYERA_MODULATION, "isdbt-layera-modulation"},
{PROP_ISDBT_LAYERA_SEGMENT_COUNT, "isdbt-layera-segment-count"},
{PROP_ISDBT_LAYERA_TIME_INTERLEAVING, "isdbt-layera-time-interleaving"},
{PROP_ISDBT_LAYERB_FEC, "isdbt-layerb-fec"},
{PROP_ISDBT_LAYERB_MODULATION, "isdbt-layerb-modulation"},
{PROP_ISDBT_LAYERB_SEGMENT_COUNT, "isdbt-layerb-segment-count"},
{PROP_ISDBT_LAYERB_TIME_INTERLEAVING, "isdbt-layerb-time-interleaving"},
{PROP_ISDBT_LAYERC_FEC, "isdbt-layerc-fec"},
{PROP_ISDBT_LAYERC_MODULATION, "isdbt-layerc-modulation"},
{PROP_ISDBT_LAYERC_SEGMENT_COUNT, "isdbt-layerc-segment-count"},
{PROP_ISDBT_LAYERC_TIME_INTERLEAVING, "isdbt-layerc-time-interleaving"},
{PROP_LNB_SLOF, "lnb-slof"},
{PROP_LNB_LOF1, "lnb-lof1"},
{PROP_LNB_LOF2, "lnb-lof2"},
{PROP_INTERLEAVING, "interleaving"},
{0, NULL}
};
bin_class = GST_BIN_CLASS (klass);
bin_class->handle_message = dvb_base_bin_handle_message;
element_class = GST_ELEMENT_CLASS (klass);
element_class->change_state = dvb_base_bin_change_state;
element_class->request_new_pad = dvb_base_bin_request_new_pad;
element_class->release_pad = dvb_base_bin_release_pad;
gst_element_class_add_static_pad_template (element_class, &program_template);
gst_element_class_add_static_pad_template (element_class, &src_template);
gst_element_class_set_static_metadata (element_class, "DVB bin",
"Source/Bin/Video",
"Access descramble and split DVB streams",
"Alessandro Decina <*****@*****.**>\n"
"Reynaldo H. Verdejo Pinochet <*****@*****.**>");
gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = dvb_base_bin_set_property;
gobject_class->get_property = dvb_base_bin_get_property;
gobject_class->dispose = dvb_base_bin_dispose;
gobject_class->finalize = dvb_base_bin_finalize;
dvbbasebin_class = (DvbBaseBinClass *) klass;
dvbbasebin_class->do_tune = dvb_base_bin_do_tune;
/* install dvbsrc properties */
dvbsrc_factory = gst_element_factory_find ("dvbsrc");
dvbsrc_class =
g_type_class_ref (gst_element_factory_get_element_type (dvbsrc_factory));
walk = proxyed_properties;
while (walk->prop_name != NULL) {
GParamSpec *pspec;
GParamSpec *our_pspec;
pspec = g_object_class_find_property (dvbsrc_class, walk->prop_name);
if (pspec != NULL) {
GType param_type = G_PARAM_SPEC_TYPE (pspec);
if (param_type == G_TYPE_PARAM_INT) {
GParamSpecInt *src_pspec = G_PARAM_SPEC_INT (pspec);
our_pspec = g_param_spec_int (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_UINT) {
GParamSpecUInt *src_pspec = G_PARAM_SPEC_UINT (pspec);
our_pspec = g_param_spec_uint (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_UINT64) {
GParamSpecUInt64 *src_pspec = G_PARAM_SPEC_UINT64 (pspec);
our_pspec = g_param_spec_uint64 (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->minimum, src_pspec->maximum, src_pspec->default_value,
pspec->flags);
} else if (param_type == G_TYPE_PARAM_STRING) {
GParamSpecString *src_pspec = G_PARAM_SPEC_STRING (pspec);
our_pspec = g_param_spec_string (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
src_pspec->default_value, pspec->flags);
} else if (param_type == G_TYPE_PARAM_ENUM) {
GParamSpecEnum *src_pspec = G_PARAM_SPEC_ENUM (pspec);
our_pspec = g_param_spec_enum (g_param_spec_get_name (pspec),
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec),
pspec->value_type, src_pspec->default_value, pspec->flags);
} else {
GST_ERROR ("Unsupported property type %s for property %s",
g_type_name (param_type), g_param_spec_get_name (pspec));
++walk;
continue;
}
g_object_class_install_property (gobject_class, walk->prop_id, our_pspec);
} else {
g_warning ("dvbsrc has no property named %s", walk->prop_name);
}
++walk;
}
g_type_class_unref (dvbsrc_class);
g_object_class_install_property (gobject_class, PROP_PROGRAM_NUMBERS,
g_param_spec_string ("program-numbers",
"Program Numbers",
"Colon separated list of programs", "", G_PARAM_READWRITE));
/**
* DvbBaseBin::tuning-start:
* @dvbbasebin: the element on which the signal is emitted
*
* Signal emited when the element first attempts to tune the
* frontend tunner to a given frequency.
*/
dvb_base_bin_signals[SIGNAL_TUNING_START] =
g_signal_new ("tuning-start", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
/**
* DvbBaseBin::tuning-done:
* @dvbbasebin: the element on which the signal is emitted
*
* Signal emited when the tunner has successfully got a lock on a signal.
*/
dvb_base_bin_signals[SIGNAL_TUNING_DONE] =
g_signal_new ("tuning-done", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
/**
* DvbBaseBin::tuning-fail:
* @dvbbasebin: the element on which the signal is emitted
*
* Signal emited when the tunner failed to get a lock on the
* signal.
*/
dvb_base_bin_signals[SIGNAL_TUNING_FAIL] =
g_signal_new ("tuning-fail", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
/**
* DvbBaseBin::tune:
* @dvbbasesink: the element on which the signal is emitted
*
* Signal emited from the application to the element, instructing it
* to tune.
*/
dvb_base_bin_signals[SIGNAL_TUNE] =
g_signal_new ("tune", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (DvbBaseBinClass, do_tune),
NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
}
static void
gst_object_class_init (GstObjectClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
parent_class = g_type_class_peek_parent (klass);
#ifndef GST_DISABLE_TRACE
_gst_object_trace = gst_alloc_trace_register (g_type_name (GST_TYPE_OBJECT));
#endif
gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_object_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_object_get_property);
g_object_class_install_property (gobject_class, ARG_NAME,
g_param_spec_string ("name", "Name", "The name of the object",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
/**
* GstObject::parent-set:
* @gstobject: a #GstObject
* @parent: the new parent
*
* Emitted when the parent of an object is set.
*/
gst_object_signals[PARENT_SET] =
g_signal_new ("parent-set", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GstObjectClass, parent_set), NULL, NULL,
g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_OBJECT);
/**
* GstObject::parent-unset:
* @gstobject: a #GstObject
* @parent: the old parent
*
* Emitted when the parent of an object is unset.
*/
gst_object_signals[PARENT_UNSET] =
g_signal_new ("parent-unset", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstObjectClass, parent_unset), NULL,
NULL, g_cclosure_marshal_VOID__OBJECT, G_TYPE_NONE, 1, GST_TYPE_OBJECT);
#ifndef GST_DISABLE_LOADSAVE
/**
* GstObject::object-saved:
* @gstobject: a #GstObject
* @xml_node: the xmlNodePtr of the parent node
*
* Trigered whenever a new object is saved to XML. You can connect to this
* signal to insert custom XML tags into the core XML.
*/
/* FIXME This should be the GType of xmlNodePtr instead of G_TYPE_POINTER
* (if libxml would use GObject)
*/
gst_object_signals[OBJECT_SAVED] =
g_signal_new ("object-saved", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstObjectClass, object_saved), NULL,
NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);
klass->restore_thyself = gst_object_real_restore_thyself;
#endif
/**
* GstObject::deep-notify:
* @gstobject: a #GstObject
* @prop_object: the object that originated the signal
* @prop: the property that changed
*
* The deep notify signal is used to be notified of property changes. It is
* typically attached to the toplevel bin to receive notifications from all
* the elements contained in that bin.
*/
gst_object_signals[DEEP_NOTIFY] =
g_signal_new ("deep-notify", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED |
G_SIGNAL_NO_HOOKS, G_STRUCT_OFFSET (GstObjectClass, deep_notify), NULL,
NULL, gst_marshal_VOID__OBJECT_PARAM, G_TYPE_NONE, 2, GST_TYPE_OBJECT,
G_TYPE_PARAM);
klass->path_string_separator = "/";
klass->lock = g_new0 (GStaticRecMutex, 1);
g_static_rec_mutex_init (klass->lock);
klass->signal_object = g_object_new (gst_signal_object_get_type (), NULL);
/* see the comments at gst_object_dispatch_properties_changed */
gobject_class->dispatch_properties_changed
= GST_DEBUG_FUNCPTR (gst_object_dispatch_properties_changed);
gobject_class->dispose = gst_object_dispose;
gobject_class->finalize = gst_object_finalize;
}
JsonNode *
json_serialize_pspec (const GValue *real_value,
GParamSpec *pspec)
{
JsonNode *retval = NULL;
JsonNodeType node_type;
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (real_value)))
{
/* JSON native types */
case G_TYPE_INT64:
retval = json_node_init_int (json_node_alloc (), g_value_get_int64 (real_value));
break;
case G_TYPE_BOOLEAN:
retval = json_node_init_boolean (json_node_alloc (), g_value_get_boolean (real_value));
break;
case G_TYPE_DOUBLE:
retval = json_node_init_double (json_node_alloc (), g_value_get_double (real_value));
break;
case G_TYPE_STRING:
retval = json_node_init_string (json_node_alloc (), g_value_get_string (real_value));
break;
/* auto-promoted types */
case G_TYPE_INT:
retval = json_node_init_int (json_node_alloc (), g_value_get_int (real_value));
break;
case G_TYPE_UINT:
retval = json_node_init_int (json_node_alloc (), g_value_get_uint (real_value));
break;
case G_TYPE_LONG:
retval = json_node_init_int (json_node_alloc (), g_value_get_long (real_value));
break;
case G_TYPE_ULONG:
retval = json_node_init_int (json_node_alloc (), g_value_get_ulong (real_value));
break;
case G_TYPE_FLOAT:
retval = json_node_init_double (json_node_alloc (), g_value_get_float (real_value));
break;
case G_TYPE_CHAR:
retval = json_node_alloc ();
json_node_init_int (retval, g_value_get_schar (real_value));
break;
case G_TYPE_UCHAR:
retval = json_node_init_int (json_node_alloc (), g_value_get_uchar (real_value));
break;
case G_TYPE_ENUM:
retval = json_node_init_int (json_node_alloc (), g_value_get_enum (real_value));
break;
case G_TYPE_FLAGS:
retval = json_node_init_int (json_node_alloc (), g_value_get_flags (real_value));
break;
/* complex types */
case G_TYPE_BOXED:
if (G_VALUE_HOLDS (real_value, G_TYPE_STRV))
{
gchar **strv = g_value_get_boxed (real_value);
gint i, strv_len;
JsonArray *array;
strv_len = g_strv_length (strv);
array = json_array_sized_new (strv_len);
for (i = 0; i < strv_len; i++)
{
JsonNode *str = json_node_new (JSON_NODE_VALUE);
json_node_set_string (str, strv[i]);
json_array_add_element (array, str);
}
retval = json_node_init_array (json_node_alloc (), array);
json_array_unref (array);
}
else if (json_boxed_can_serialize (G_VALUE_TYPE (real_value), &node_type))
{
gpointer boxed = g_value_get_boxed (real_value);
retval = json_boxed_serialize (G_VALUE_TYPE (real_value), boxed);
}
else
g_warning ("Boxed type '%s' is not handled by JSON-GLib",
g_type_name (G_VALUE_TYPE (real_value)));
break;
case G_TYPE_OBJECT:
{
GObject *object = g_value_get_object (real_value);
retval = json_node_alloc ();
if (object != NULL)
{
json_node_init (retval, JSON_NODE_OBJECT);
json_node_take_object (retval, json_gobject_dump (object));
}
else
json_node_init_null (retval);
}
break;
case G_TYPE_NONE:
retval = json_node_new (JSON_NODE_NULL);
break;
default:
g_warning ("Unsupported type `%s'", g_type_name (G_VALUE_TYPE (real_value)));
break;
}
return retval;
}
static GObject *
json_gobject_new (GType gtype,
JsonObject *object)
{
JsonSerializableIface *iface = NULL;
JsonSerializable *serializable = NULL;
gboolean find_property;
gboolean deserialize_property;
gboolean set_property;
GList *members, *members_left, *l;
guint n_members;
GObjectClass *klass;
GObject *retval;
GArray *construct_params;
gint i;
klass = g_type_class_ref (gtype);
n_members = json_object_get_size (object);
members = json_object_get_members (object);
members_left = NULL;
/* first pass: construct-only properties; here we cannot use Serializable
* because we don't have an instance yet; we use the default implementation
* of json_deserialize_pspec() to deserialize known types
*
* FIXME - find a way to allow deserialization for these properties
*/
construct_params = g_array_sized_new (FALSE, FALSE, sizeof (GParameter), n_members);
for (l = members; l != NULL; l = l->next)
{
const gchar *member_name = l->data;
GParamSpec *pspec;
GParameter param = { NULL, };
JsonNode *val;
gboolean res = FALSE;
pspec = g_object_class_find_property (klass, member_name);
if (!pspec)
goto next_member;
/* we only apply construct-only properties here */
if ((pspec->flags & G_PARAM_CONSTRUCT_ONLY) == 0)
goto next_member;
if (!(pspec->flags & G_PARAM_WRITABLE))
goto next_member;
g_value_init (¶m.value, G_PARAM_SPEC_VALUE_TYPE (pspec));
val = json_object_get_member (object, member_name);
res = json_deserialize_pspec (¶m.value, pspec, val);
if (!res)
{
g_warning ("Failed to deserialize \"%s\" property of type \"%s\" for an object of type \"%s\"",
pspec->name, G_VALUE_TYPE_NAME (¶m.value), g_type_name (gtype));
g_value_unset (¶m.value);
}
else
{
param.name = g_strdup (pspec->name);
g_array_append_val (construct_params, param);
continue;
}
next_member:
members_left = g_list_prepend (members_left, l->data);
}
retval = g_object_newv (gtype,
construct_params->len,
(GParameter *) construct_params->data);
/* free the contents of the GArray */
for (i = 0; i < construct_params->len; i++)
{
GParameter *param = &g_array_index (construct_params, GParameter, i);
g_free ((gchar *) param->name);
g_value_unset (¶m->value);
}
g_array_free (construct_params, TRUE);
g_list_free (members);
/* we use g_list_prepend() above, but we want to maintain
* the ordering of json_object_get_members() here
*/
members = g_list_reverse (members_left);
/* do the Serializable type check once */
if (g_type_is_a (gtype, JSON_TYPE_SERIALIZABLE))
{
serializable = JSON_SERIALIZABLE (retval);
iface = JSON_SERIALIZABLE_GET_IFACE (serializable);
find_property = (iface->find_property != NULL);
deserialize_property = (iface->deserialize_property != NULL);
set_property = (iface->set_property != NULL);
}
else
{
find_property = FALSE;
deserialize_property = FALSE;
set_property = FALSE;
}
g_object_freeze_notify (retval);
for (l = members; l != NULL; l = l->next)
{
const gchar *member_name = l->data;
GParamSpec *pspec;
JsonNode *val;
GValue value = { 0, };
gboolean res = FALSE;
if (find_property)
pspec = json_serializable_find_property (serializable, member_name);
else
pspec = g_object_class_find_property (klass, member_name);
if (pspec == NULL)
continue;
/* we should have dealt with these above */
if (pspec->flags & G_PARAM_CONSTRUCT_ONLY)
continue;
if (!(pspec->flags & G_PARAM_WRITABLE))
continue;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
val = json_object_get_member (object, member_name);
if (deserialize_property)
{
JSON_NOTE (GOBJECT, "Using JsonSerializable for property '%s'", pspec->name);
res = json_serializable_deserialize_property (serializable,
pspec->name,
&value,
pspec,
val);
}
if (!res)
{
JSON_NOTE (GOBJECT, "Using json_deserialize_pspec for property '%s'", pspec->name);
res = json_deserialize_pspec (&value, pspec, val);
}
if (res)
{
JSON_NOTE (GOBJECT, "Calling set_property('%s', '%s')",
pspec->name,
g_type_name (G_VALUE_TYPE (&value)));
if (set_property)
json_serializable_set_property (serializable, pspec, &value);
else
g_object_set_property (retval, pspec->name, &value);
}
else
g_warning ("Failed to deserialize \"%s\" property of type \"%s\" for an object of type \"%s\"",
pspec->name, g_type_name (G_VALUE_TYPE (&value)), g_type_name (gtype));
g_value_unset (&value);
}
g_list_free (members);
g_object_thaw_notify (retval);
g_type_class_unref (klass);
return retval;
}
/*
* the @ps struct is modified and transferred to the new data model created in
* this function
*/
GdaDataModel *
gda_oracle_recordset_new (GdaConnection *cnc, GdaOraclePStmt *ps, GdaSet *exec_params,
GdaDataModelAccessFlags flags, GType *col_types)
{
GdaOracleRecordset *model;
OracleConnectionData *cdata;
gint i;
GdaDataModelAccessFlags rflags;
gint nb_rows = -1;
g_return_val_if_fail (GDA_IS_CONNECTION (cnc), NULL);
g_return_val_if_fail (ps != NULL, NULL);
cdata = (OracleConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);
if (!cdata)
return NULL;
/* make sure @ps reports the correct number of columns using the API */
if (_GDA_PSTMT (ps)->ncols < 0) {
ub4 ncolumns;
int result;
/* get the number of columns in the result set */
result = OCIAttrGet ((dvoid *) ps->hstmt,
(ub4) OCI_HTYPE_STMT,
(dvoid *) &ncolumns,
(ub4 *) 0,
(ub4) OCI_ATTR_PARAM_COUNT,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the number of columns in the result set")))
return NULL;
_GDA_PSTMT (ps)->ncols = ncolumns;
}
/* completing @ps if not yet done */
if (!_GDA_PSTMT (ps)->types && (_GDA_PSTMT (ps)->ncols > 0)) {
/* create prepared statement's columns */
GSList *list;
GList *ora_values = NULL;
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->tmpl_columns = g_slist_prepend (_GDA_PSTMT (ps)->tmpl_columns,
gda_column_new ());
_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
/* create prepared statement's types, all types are initialized to GDA_TYPE_NULL */
_GDA_PSTMT (ps)->types = g_new (GType, _GDA_PSTMT (ps)->ncols);
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->types [i] = GDA_TYPE_NULL;
if (col_types) {
for (i = 0; ; i++) {
if (col_types [i] > 0) {
if (col_types [i] == G_TYPE_NONE)
break;
if (i >= _GDA_PSTMT (ps)->ncols) {
g_warning (_("Column %d out of range (0-%d), ignoring its specified type"), i,
_GDA_PSTMT (ps)->ncols - 1);
break;
}
else
_GDA_PSTMT (ps)->types [i] = col_types [i];
}
}
}
/* fill GdaColumn's data and define the GdaOracleValue structures */
for (i=0, list = _GDA_PSTMT (ps)->tmpl_columns;
i < GDA_PSTMT (ps)->ncols;
i++, list = list->next) {
GdaColumn *column;
int result;
GdaOracleValue *ora_value;
gboolean use_callback = FALSE;
ora_value = g_new0 (GdaOracleValue, 1);
ora_values = g_list_prepend (ora_values, ora_value);
/* parameter to get attributes */
result = OCIParamGet (ps->hstmt,
OCI_HTYPE_STMT,
cdata->herr,
(dvoid **) &(ora_value->pard),
(ub4) i+1);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the Oracle parameter descripter in the result set"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
/* data size */
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->defined_size),
0,
(ub4) OCI_ATTR_DATA_SIZE,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the parameter defined size"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
ora_value->defined_size++;
/* data type */
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->sql_type),
0,
OCI_ATTR_DATA_TYPE,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the parameter data type"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->precision),
0,
OCI_ATTR_PRECISION,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the type's precision"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->scale),
0,
OCI_ATTR_SCALE,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the type's scale"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
/* column's name */
text *name;
ub4 name_len;
column = GDA_COLUMN (list->data);
result = OCIAttrGet ((dvoid *) (ora_value->pard),
(ub4) OCI_DTYPE_PARAM,
(dvoid **) &name,
(ub4 *) &name_len,
(ub4) OCI_ATTR_NAME,
(OCIError *) cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get column name in the result set"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
gchar *name_buffer;
name_buffer = g_new (gchar, name_len + 1);
memcpy (name_buffer, name, name_len);
name_buffer [name_len] = '\0';
gda_column_set_name (column, name_buffer);
gda_column_set_description (column, name_buffer);
g_free (name_buffer);
/* for data fetching */
if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
ora_value->sql_type = _g_type_to_oracle_sqltype (_GDA_PSTMT (ps)->types [i]);
switch (ora_value->sql_type) {
case SQLT_CHR: /* for G_TYPE_STRING => request SQLT_CHR */
case SQLT_STR:
case SQLT_VCS:
case SQLT_RID:
case SQLT_AVC:
case SQLT_AFC:
ora_value->sql_type = SQLT_CHR;
if (ora_value->defined_size == 1)
use_callback = TRUE;
break;
case SQLT_INT:
ora_value->defined_size = sizeof (gint);
break;
case SQLT_FLT:
case SQLT_BFLOAT:
ora_value->defined_size = sizeof (gfloat);
break;
case SQLT_BDOUBLE:
ora_value->defined_size = sizeof (gdouble);
break;
case SQLT_DAT: /* request OCIDate */
ora_value->sql_type = SQLT_ODT;
break;
case SQLT_NUM: /* for GDA_TYPE_NUMERIC => request SQLT_CHR */
case SQLT_VNU:
ora_value->sql_type = SQLT_CHR;
break;
case SQLT_LBI:
case SQLT_LVB:
case SQLT_LVC:
case SQLT_LNG:
case SQLT_VBI:
case SQLT_BIN:
use_callback = TRUE;
break;
default:
use_callback = TRUE;
break;
}
if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
ora_value->g_type = _GDA_PSTMT (ps)->types [i];
else
ora_value->g_type = _oracle_sqltype_to_g_type (ora_value->sql_type, ora_value->precision,
ora_value->scale);
if (ora_value->g_type == GDA_TYPE_BLOB) {
/* allocate a Lob locator */
OCILobLocator *lob;
result = OCIDescriptorAlloc ((dvoid *) cdata->henv, (dvoid **) &lob,
(ub4) gda_oracle_blob_type (ora_value->sql_type),
(size_t) 0, (dvoid **) 0);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not allocate Lob locator"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
ora_value->value = lob;
ora_value->defined_size = 0;
}
else if (use_callback) {
ora_value->value = NULL;
ora_value->defined_size = 33554432; /* 32M */
}
else
ora_value->value = g_malloc0 (ora_value->defined_size);
ora_value->s_type = gda_g_type_to_static_type (ora_value->g_type);
if (_GDA_PSTMT (ps)->types [i] == GDA_TYPE_NULL)
_GDA_PSTMT (ps)->types [i] = ora_value->g_type;
gda_column_set_g_type (column, ora_value->g_type);
#ifdef GDA_DEBUG_NO
g_print ("**COL type is %d, GType is %s, ORA defined size is %d%s\n",
ora_value->sql_type,
g_type_name (ora_value->g_type),
ora_value->defined_size - 1,
use_callback ? " using callback": "");
#endif
ora_value->hdef = (OCIDefine *) 0;
ora_value->indicator = 0;
result = OCIDefineByPos ((OCIStmt *) ps->hstmt,
(OCIDefine **) &(ora_value->hdef),
(OCIError *) cdata->herr,
(ub4) i + 1,
ora_value->value,
ora_value->defined_size,
ora_value->sql_type,
(dvoid *) &(ora_value->indicator),
&(ora_value->rlen),
&(ora_value->rcode),
(ub4) (use_callback ? OCI_DYNAMIC_FETCH : OCI_DEFAULT));
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not define by position"))) {
OCIDescriptorFree ((dvoid *) ora_value->pard, OCI_DTYPE_PARAM);
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
if (use_callback) {
result = OCIDefineDynamic ((OCIDefine *) (ora_value->hdef),
(OCIError *) (cdata->herr),
(dvoid*) (ora_value),
(OCICallbackDefine) ora_def_callback);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not define by position"))) {
OCIDescriptorFree ((dvoid *) ora_value->pard, OCI_DTYPE_PARAM);
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
}
ora_value->use_callback = use_callback;
}
ps->ora_values = g_list_reverse (ora_values);
}
/* determine access mode: RANDOM or CURSOR FORWARD are the only supported; if CURSOR BACKWARD
* is requested, then we need RANDOM mode */
if (flags & GDA_DATA_MODEL_ACCESS_RANDOM)
rflags = GDA_DATA_MODEL_ACCESS_RANDOM;
else if (flags & GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD)
rflags = GDA_DATA_MODEL_ACCESS_RANDOM;
else
rflags = GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD;
ub4 prefetch;
prefetch = (ub4) (100);
OCIAttrSet (ps->hstmt, OCI_HTYPE_STMT,
&prefetch, 0,
OCI_ATTR_PREFETCH_ROWS, cdata->herr);
/* create data model */
model = g_object_new (GDA_TYPE_ORACLE_RECORDSET,
"connection", cnc,
"prepared-stmt", ps,
"model-usage", rflags,
"exec-params", exec_params, NULL);
GDA_DATA_SELECT (model)->advertized_nrows = nb_rows;
return GDA_DATA_MODEL (model);
}
gboolean
ibus_message_get_args_valist (IBusMessage *message,
IBusError **error,
GType first_arg_type,
va_list va_args)
{
g_assert (message != NULL);
gboolean retval;
IBusMessageIter iter;
GType type;
gpointer value;
va_list backup_args;
gint i;
retval = ibus_message_iter_init (message, &iter);
if (!retval) {
if (error) {
*error = ibus_error_new_from_printf (DBUS_ERROR_INVALID_ARGS,
"Message does not have arguments!");
}
return FALSE;
}
va_copy (backup_args, va_args);
i = 0;
type = first_arg_type;
while (type != G_TYPE_INVALID) {
value = va_arg (va_args, gpointer);
retval = ibus_message_iter_get (&iter, type, value);
if (!retval)
goto _failed;
ibus_message_iter_next (&iter);
i ++;
type = va_arg (va_args, GType);
}
va_end (backup_args);
return TRUE;
_failed:
*error = ibus_error_new_from_printf (DBUS_ERROR_INVALID_ARGS,
"The argument %d is not %s",
i,
g_type_name (type));
/* release resources */
type = first_arg_type;
while (i > 0) {
gpointer *value = va_arg (backup_args, gpointer *);
if (g_type_is_a (type, G_TYPE_BOXED)) {
g_boxed_free (type, *value);
}
else if (g_type_is_a (type, G_TYPE_OBJECT)) {
g_object_unref (*value);
}
i --;
type = va_arg (backup_args, GType);
}
va_end (backup_args);
return FALSE;
}
static void
print_state_variables (GUPnPServiceIntrospection *introspection)
{
const GList *variables;
variables =
gupnp_service_introspection_list_state_variables (
introspection);
if (variables) {
const GList *iter;
g_print ("state variables:\n");
for (iter = variables; iter; iter = iter->next) {
GUPnPServiceStateVariableInfo *variable;
GValue default_value;
const char * default_value_str;
variable = (GUPnPServiceStateVariableInfo *) iter->data;
g_print ("\tname: %s\n"
"\ttype: %s\n"
"\tsend events: %s\n",
variable->name,
g_type_name (variable->type),
variable->send_events? "yes": "no");
memset (&default_value, 0, sizeof (GValue));
g_value_init (&default_value, G_TYPE_STRING);
g_value_transform (&variable->default_value,
&default_value);
default_value_str = g_value_get_string (&default_value);
if (default_value_str) {
g_print ("\tdefault value: %s\n",
default_value_str);
}
g_value_unset (&default_value);
if (variable->is_numeric) {
GValue min, max, step;
memset (&min, 0, sizeof (GValue));
memset (&max, 0, sizeof (GValue));
memset (&step, 0, sizeof (GValue));
g_value_init (&min, G_TYPE_STRING);
g_value_init (&max, G_TYPE_STRING);
g_value_init (&step, G_TYPE_STRING);
g_value_transform (&variable->minimum, &min);
g_value_transform (&variable->maximum, &max);
g_value_transform (&variable->step, &step);
g_print ("\tminimum: %s\n"
"\tmaximum: %s\n"
"\tstep: %s\n",
g_value_get_string (&min),
g_value_get_string (&max),
g_value_get_string (&step));
g_value_unset (&min);
g_value_unset (&max);
g_value_unset (&step);
}
if (variable->allowed_values) {
GList *value_iter;
g_print ("\tallowed values: ");
for (value_iter = variable->allowed_values;
value_iter;
value_iter = value_iter->next) {
g_print ("\"%s\" ",
(gchar *) value_iter->data);
}
}
g_print ("\n");
}
g_print ("\n");
}
}
/**
* gimp_config_deserialize_property:
* @config: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level: the nest level
*
* This function deserializes a single property of @config. You
* shouldn't need to call this function directly. If possible, use
* gimp_config_deserialize_properties() instead.
*
* Return value: %G_TOKEN_RIGHT_PAREN on success, otherwise the
* expected #GTokenType or %G_TOKEN_NONE if the expected token was
* found but couldn't be parsed.
*
* Since: GIMP 2.4
**/
GTokenType
gimp_config_deserialize_property (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GimpConfigInterface *config_iface = NULL;
GimpConfigInterface *parent_iface = NULL;
GParamSpec *prop_spec;
GTokenType token = G_TOKEN_RIGHT_PAREN;
GValue value = { 0, };
guint old_scope_id;
old_scope_id = g_scanner_set_scope (scanner, 0);
prop_spec = G_PARAM_SPEC (scanner->value.v_symbol);
g_value_init (&value, prop_spec->value_type);
if (G_TYPE_IS_OBJECT (prop_spec->owner_type))
{
GTypeClass *owner_class = g_type_class_peek (prop_spec->owner_type);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
*
* Therefore, we ask param_spec->owner_type's immediate parent class
* for it's GimpConfigInterface and check if we get a different
* pointer.
*
* (if the pointers are the same, param_spec->owner_type's
* GimpConfigInterface is inherited from one of it's parent classes
* and thus not able to handle param_spec->owner_type's properties).
*/
if (config_iface)
{
GTypeClass *owner_parent_class;
owner_parent_class = g_type_class_peek_parent (owner_class);
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG);
}
}
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->deserialize_property &&
config_iface->deserialize_property (config,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
{
/* nop */
}
else
{
if (G_VALUE_HOLDS_OBJECT (&value))
token = gimp_config_deserialize_object (&value,
config, prop_spec,
scanner, nest_level);
else
token = gimp_config_deserialize_value (&value,
config, prop_spec, scanner);
}
if (token == G_TOKEN_RIGHT_PAREN &&
g_scanner_peek_next_token (scanner) == token)
{
if (! (G_VALUE_HOLDS_OBJECT (&value) &&
(prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE)))
g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
}
#ifdef CONFIG_DEBUG
else
{
g_warning ("%s: couldn't deserialize property %s::%s of type %s",
G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (config)),
prop_spec->name,
g_type_name (prop_spec->value_type));
}
#endif
g_value_unset (&value);
g_scanner_set_scope (scanner, old_scope_id);
return token;
}
/* Syncs a value from GConf to an object property */
static void
prop_binding_sync_pref_to_prop (PropBinding *binding,
GConfValue *pref_value)
{
GValue src_value, value;
/* Make sure we don't enter an infinite synchronizing loop */
g_signal_handler_block (binding->object, binding->prop_notify_id);
memset (&src_value, 0, sizeof (GValue));
/* First, convert GConfValue to GValue */
switch (pref_value->type) {
case GCONF_VALUE_STRING:
g_value_init (&src_value, G_TYPE_STRING);
g_value_set_string (&src_value,
gconf_value_get_string (pref_value));
break;
case GCONF_VALUE_INT:
g_value_init (&src_value, G_TYPE_INT);
g_value_set_int (&src_value,
gconf_value_get_int (pref_value));
break;
case GCONF_VALUE_BOOL:
g_value_init (&src_value, G_TYPE_BOOLEAN);
g_value_set_boolean (&src_value,
gconf_value_get_bool (pref_value));
break;
case GCONF_VALUE_FLOAT:
g_value_init (&src_value, G_TYPE_FLOAT);
g_value_set_float (&src_value,
gconf_value_get_float (pref_value));
break;
default:
g_warning ("prop_binding_sync_pref_to_prop: Unhandled value "
"type '%d'.\n", pref_value->type);
return;
}
/* Then convert to the type expected by the object, if necessary */
memset (&value, 0, sizeof (GValue));
g_value_init (&value,
G_PARAM_SPEC_VALUE_TYPE (binding->prop));
if (src_value.g_type != value.g_type) {
if (!g_value_transform (&src_value, &value)) {
g_warning ("prop_binding_sync_pref_to_prop: Failed to "
"transform a \"%s\" to a \"%s\".",
g_type_name (src_value.g_type),
g_type_name (value.g_type));
goto done;
}
g_object_set_property (binding->object,
binding->prop->name, &value);
} else {
g_object_set_property (binding->object,
binding->prop->name, &src_value);
}
done:
g_value_unset (&src_value);
g_value_unset (&value);
g_signal_handler_unblock (binding->object, binding->prop_notify_id);
}
static void
print_plugin_features (GstPlugin * plugin)
{
GList *features, *origlist;
gint num_features = 0;
gint num_elements = 0;
gint num_tracers = 0;
gint num_typefinders = 0;
gint num_devproviders = 0;
gint num_other = 0;
origlist = features =
gst_registry_get_feature_list_by_plugin (gst_registry_get (),
gst_plugin_get_name (plugin));
while (features) {
GstPluginFeature *feature;
feature = GST_PLUGIN_FEATURE (features->data);
if (GST_IS_ELEMENT_FACTORY (feature)) {
GstElementFactory *factory;
factory = GST_ELEMENT_FACTORY (feature);
n_print (" %s: %s\n", GST_OBJECT_NAME (factory),
gst_element_factory_get_metadata (factory,
GST_ELEMENT_METADATA_LONGNAME));
num_elements++;
} else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
GstTypeFindFactory *factory;
const gchar *const *extensions;
factory = GST_TYPE_FIND_FACTORY (feature);
extensions = gst_type_find_factory_get_extensions (factory);
if (extensions) {
guint i = 0;
g_print (" %s: %s: ", gst_plugin_get_name (plugin),
gst_plugin_feature_get_name (feature));
while (extensions[i]) {
g_print ("%s%s", i > 0 ? ", " : "", extensions[i]);
i++;
}
g_print ("\n");
} else
g_print (" %s: %s: no extensions\n", gst_plugin_get_name (plugin),
gst_plugin_feature_get_name (feature));
num_typefinders++;
} else if (GST_IS_DEVICE_PROVIDER_FACTORY (feature)) {
GstDeviceProviderFactory *factory;
factory = GST_DEVICE_PROVIDER_FACTORY (feature);
n_print (" %s: %s\n", GST_OBJECT_NAME (factory),
gst_device_provider_factory_get_metadata (factory,
GST_ELEMENT_METADATA_LONGNAME));
num_devproviders++;
} else if (GST_IS_TRACER_FACTORY (feature)) {
n_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)),
g_type_name (G_OBJECT_TYPE (feature)));
num_tracers++;
} else if (feature) {
n_print (" %s (%s)\n", gst_object_get_name (GST_OBJECT (feature)),
g_type_name (G_OBJECT_TYPE (feature)));
num_other++;
}
num_features++;
features = g_list_next (features);
}
gst_plugin_feature_list_free (origlist);
n_print ("\n");
n_print (" %d features:\n", num_features);
if (num_elements > 0)
n_print (" +-- %d elements\n", num_elements);
if (num_typefinders > 0)
n_print (" +-- %d typefinders\n", num_typefinders);
if (num_devproviders > 0)
n_print (" +-- %d device providers\n", num_devproviders);
if (num_tracers > 0)
n_print (" +-- %d tracers\n", num_tracers);
if (num_other > 0)
n_print (" +-- %d other objects\n", num_other);
n_print ("\n");
}
/* Syncs an object property to GConf */
static void
prop_binding_sync_prop_to_pref (PropBinding *binding)
{
GValue value;
GConfValue *gconf_value;
memset (&value, 0, sizeof (GValue));
g_value_init (&value,
G_PARAM_SPEC_VALUE_TYPE (binding->prop));
g_object_get_property (binding->object,
binding->prop->name,
&value);
switch (value.g_type) {
case G_TYPE_STRING:
gconf_value = gconf_value_new (GCONF_VALUE_STRING);
gconf_value_set_string (gconf_value,
g_value_get_string (&value));
break;
case G_TYPE_INT:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_int (&value));
break;
case G_TYPE_UINT:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_uint (&value));
break;
case G_TYPE_LONG:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_long (&value));
break;
case G_TYPE_ULONG:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_ulong (&value));
break;
case G_TYPE_INT64:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_int64 (&value));
break;
case G_TYPE_UINT64:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_uint64 (&value));
break;
case G_TYPE_CHAR:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_char (&value));
break;
case G_TYPE_UCHAR:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_uchar (&value));
break;
case G_TYPE_ENUM:
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_enum (&value));
break;
case G_TYPE_BOOLEAN:
gconf_value = gconf_value_new (GCONF_VALUE_BOOL);
gconf_value_set_bool (gconf_value,
g_value_get_boolean (&value));
break;
case G_TYPE_DOUBLE:
gconf_value = gconf_value_new (GCONF_VALUE_FLOAT);
#ifdef HAVE_CORBA_GCONF
/* FIXME we cast to a float explicitly as CORBA GConf
* uses doubles in its API, but treats them as floats
* when transporting them over CORBA. See #322837 */
gconf_value_set_float (gconf_value,
(float) g_value_get_double (&value));
#else
gconf_value_set_float (gconf_value,
g_value_get_double (&value));
#endif
break;
case G_TYPE_FLOAT:
gconf_value = gconf_value_new (GCONF_VALUE_FLOAT);
gconf_value_set_float (gconf_value,
g_value_get_float (&value));
break;
default:
if (g_type_is_a (value.g_type, G_TYPE_ENUM)) {
gconf_value = gconf_value_new (GCONF_VALUE_INT);
gconf_value_set_int (gconf_value,
g_value_get_enum (&value));
} else {
g_warning ("prop_binding_sync_prop_to_pref: "
"Unhandled value type '%s'.\n",
g_type_name (value.g_type));
goto done;
}
break;
}
/* Set to GConf */
gconf_client_set (bridge->client, binding->key, gconf_value, NULL);
/* Store until change notification comes in, so that we are able
* to ignore it */
binding->val_changes = g_slist_append (binding->val_changes,
gconf_value);
done:
g_value_unset (&value);
}
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);
}
}
}
// Until the glib bug https://bugzilla.gnome.org/show_bug.cgi?id=465631
// is fixed, get_properties() must be called for a GObject before it's
// called for a GInterface.
std::string
get_properties(GType gtype)
{
std::string strResult;
std::string strObjectName = g_type_name(gtype);
// Get the list of properties:
GParamSpec** ppParamSpec = nullptr;
guint iCount = 0;
if (G_TYPE_IS_OBJECT(gtype))
{
GObjectClass* pGClass = G_OBJECT_CLASS(g_type_class_ref(gtype));
ppParamSpec = g_object_class_list_properties(pGClass, &iCount);
g_type_class_unref(pGClass);
if (!ppParamSpec)
{
strResult += ";; Warning: g_object_class_list_properties() returned NULL for " +
std::string(g_type_name(gtype)) + "\n";
}
}
else if (G_TYPE_IS_INTERFACE(gtype))
{
gpointer pGInterface = g_type_default_interface_ref(gtype);
if (pGInterface)
{
ppParamSpec = g_object_interface_list_properties(pGInterface, &iCount);
g_type_default_interface_unref(pGInterface);
if (!ppParamSpec)
{
strResult += ";; Warning: g_object_interface_list_properties() returned NULL for " +
std::string(g_type_name(gtype)) + "\n";
}
}
else
strResult += ";; Warning: g_type_default_interface_ref() returned NULL for " +
std::string(g_type_name(gtype)) + "\n";
}
// This extra check avoids an occasional crash
if (!ppParamSpec)
iCount = 0;
for (guint i = 0; i < iCount; i++)
{
GParamSpec* pParamSpec = ppParamSpec[i];
// Generate the property if the specified gtype actually owns the property.
// (Generally all properties, including any base classes' properties are
// retrieved by g_object_interface_list_properties() for a given gtype.
// The base classes' properties should not be generated).
if (pParamSpec && pParamSpec->owner_type == gtype)
{
strResult += get_property_with_node_name(pParamSpec, strObjectName, "define-property");
}
}
g_free(ppParamSpec);
return strResult;
}
static void
_check_object (AtkObject *obj)
{
AtkRole role;
static G_CONST_RETURN char *name = NULL;
static gboolean first_time = TRUE;
role = atk_object_get_role (obj);
if (role == ATK_ROLE_FRAME)
/*
* Find the specified menu item
*/
{
AtkRole valid_roles[NUM_VALID_ROLES];
AtkObject *atk_menu_item;
GtkWidget *widget;
if (name == NULL)
{
valid_roles[0] = ATK_ROLE_MENU_ITEM;
name = g_getenv ("TEST_ACCESSIBLE_NAME");
if (name == NULL)
name = "foo";
}
atk_menu_item = find_object_by_accessible_name_and_role (obj, name,
valid_roles, NUM_VALID_ROLES);
if (atk_menu_item == NULL)
{
g_print ("Object not found for %s\n", name);
return;
}
g_assert (GTK_IS_ACCESSIBLE (atk_menu_item));
widget = GTK_ACCESSIBLE (atk_menu_item)->widget;
g_assert (GTK_IS_MENU_ITEM (widget));
if (first_time)
first_time = FALSE;
else
return;
/*
* This action opens the menu whose name is "foo" or whatever
* was specified in the environment variable TEST_ACCESSIBLE_NAME
*/
atk_action_do_action (ATK_ACTION (atk_menu_item), 0);
}
else if ((role == ATK_ROLE_MENU_ITEM) ||
(role == ATK_ROLE_CHECK_MENU_ITEM) ||
(role == ATK_ROLE_RADIO_MENU_ITEM) ||
(role == ATK_ROLE_TEAR_OFF_MENU_ITEM))
{
G_CONST_RETURN char *keybinding;
G_CONST_RETURN char *accessible_name;
accessible_name = atk_object_get_name (obj);
if (accessible_name)
g_print ("Name: %s\n", accessible_name);
g_print ("Action: %s\n", atk_action_get_name (ATK_ACTION (obj), 0));
keybinding = atk_action_get_keybinding (ATK_ACTION (obj), 0);
if (keybinding)
g_print ("KeyBinding: %s\n", keybinding);
/*
* Do the action associated with the menu item once, otherwise
* we get into a loop
*/
if (strcmp (name, accessible_name) == 0)
{
if (first_time)
first_time = FALSE;
else
return;
if (g_getenv ("TEST_ACCESSIBLE_AUTO"))
{
gtk_idle_add (_do_menu_item_action, obj);
}
}
}
else
{
G_CONST_RETURN char *accessible_name;
accessible_name = atk_object_get_name (obj);
if (accessible_name)
g_print ("Name: %s\n", accessible_name);
else if (GTK_IS_ACCESSIBLE (obj))
{
GtkWidget *widget = GTK_ACCESSIBLE (obj)->widget;
g_print ("Type: %s\n", g_type_name (G_OBJECT_TYPE (widget)));
}
}
}
std::string
get_signals(GType gtype, GTypeIsAPointerFunc is_a_pointer_func)
{
std::string strResult;
std::string strObjectName = g_type_name(gtype);
gpointer gclass_ref = nullptr;
gpointer ginterface_ref = nullptr;
if (G_TYPE_IS_OBJECT(gtype))
gclass_ref = g_type_class_ref(gtype); // Ensures that class_init() is called.
else if (G_TYPE_IS_INTERFACE(gtype))
ginterface_ref = g_type_default_interface_ref(gtype); // install signals.
// Get the list of signals:
guint iCount = 0;
guint* pIDs = g_signal_list_ids(gtype, &iCount);
// Loop through the list of signals:
if (pIDs)
{
for (guint i = 0; i < iCount; i++)
{
guint signal_id = pIDs[i];
// Name:
std::string strName = g_signal_name(signal_id);
strResult += "(define-signal " + strName + "\n";
strResult += " (of-object \"" + strObjectName + "\")\n";
// Other information about the signal:
GSignalQuery signalQuery = {
0, nullptr, 0, GSignalFlags(0), 0, 0, nullptr,
};
g_signal_query(signal_id, &signalQuery);
// Return type:
std::string strReturnTypeName =
get_type_name_signal(signalQuery.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE,
is_a_pointer_func); // The type is mangled with a flag. Hacky.
// bool bReturnTypeHasStaticScope = (signalQuery.return_type & G_SIGNAL_TYPE_STATIC_SCOPE) ==
// G_SIGNAL_TYPE_STATIC_SCOPE;
strResult += " (return-type \"" + strReturnTypeName + "\")\n";
// Flags:
std::string strFlags;
add_signal_flag_if(strFlags, "Run First", signalQuery, G_SIGNAL_RUN_FIRST);
add_signal_flag_if(strFlags, "Run Last", signalQuery, G_SIGNAL_RUN_LAST);
add_signal_flag_if(strFlags, "Run Cleanup", signalQuery, G_SIGNAL_RUN_CLEANUP);
add_signal_flag_if(strFlags, "No Recurse", signalQuery, G_SIGNAL_NO_RECURSE);
add_signal_flag_if(strFlags, "Action", signalQuery, G_SIGNAL_ACTION);
add_signal_flag_if(strFlags, "No Hooks", signalQuery, G_SIGNAL_NO_HOOKS);
add_signal_flag_if(strFlags, "Must Collect", signalQuery, G_SIGNAL_MUST_COLLECT);
strResult += " (flags \"" + strFlags + "\")\n";
if (signalQuery.signal_flags & G_SIGNAL_DETAILED)
strResult += " (detailed #t)\n"; // Default: not detailed
if (signalQuery.signal_flags & G_SIGNAL_DEPRECATED)
strResult += " (deprecated #t)\n"; // Default: not deprecated
// Loop through the list of parameters:
const GType* pParameters = signalQuery.param_types;
if (pParameters)
{
strResult += " (parameters\n";
for (unsigned j = 0; j < signalQuery.n_params; j++)
{
GType typeParamMangled = pParameters[j];
// Parameter name:
// We can't get the real parameter name from the GObject system. It's not registered with
// g_signal_new().
gchar* pchNum = g_strdup_printf("%d", j);
std::string strParamName = "p" + std::string(pchNum);
g_free(pchNum);
pchNum = nullptr;
// Just like above, for the return type:
std::string strTypeName =
get_type_name_signal(typeParamMangled & ~G_SIGNAL_TYPE_STATIC_SCOPE,
is_a_pointer_func); // The type is mangled with a flag. Hacky.
// bool bTypeHasStaticScope = (typeParamMangled & G_SIGNAL_TYPE_STATIC_SCOPE) ==
// G_SIGNAL_TYPE_STATIC_SCOPE;
strResult += " '(\"" + strTypeName + "\" \"" + strParamName + "\")\n";
}
strResult += " )\n"; // close (parameters
}
strResult += ")\n\n"; // close (define-signal
}
}
g_free(pIDs);
if (gclass_ref)
g_type_class_unref(gclass_ref); // to match the g_type_class_ref() above.
else if (ginterface_ref)
g_type_default_interface_unref(ginterface_ref); // for interface ref above.
return strResult;
}
static gboolean
peas_extension_seed_call (PeasExtensionWrapper *exten,
const gchar *method_name,
GIArgument *args,
GIArgument *retval)
{
PeasExtensionSeed *sexten = PEAS_EXTENSION_SEED (exten);
GType exten_type;
SeedValue js_method;
GICallableInfo *func_info;
gint n_args, i;
SeedValue *js_in_args;
OutArg *out_args;
SeedValue js_ret, val;
SeedException exc = NULL;
gchar *exc_string;
gint n_in_args = 0;
gint n_out_args = 0;
GIArgument argument;
g_return_val_if_fail (sexten->js_context != NULL, FALSE);
g_return_val_if_fail (sexten->js_object != NULL, FALSE);
exten_type = peas_extension_wrapper_get_extension_type (exten);
/* Fetch the JS method we want to call */
js_method = seed_object_get_property (sexten->js_context,
sexten->js_object,
method_name);
if (seed_value_is_undefined (sexten->js_context, js_method))
{
g_warning ("Method '%s.%s' is not defined",
g_type_name (exten_type), method_name);
return FALSE;
}
/* We want to display an error if the method is defined but is not a function. */
if (!seed_value_is_function (sexten->js_context, js_method))
{
g_warning ("Method '%s.%s' is not a function",
g_type_name (exten_type), method_name);
return FALSE;
}
/* Prepare the arguments */
func_info = peas_gi_get_method_info (exten_type, method_name);
if (func_info == NULL)
return FALSE;
n_args = g_callable_info_get_n_args (func_info);
g_return_val_if_fail (n_args >= 0, FALSE);
js_in_args = g_newa (SeedValue, n_args);
out_args = g_newa (OutArg, n_args + 1);
/* We put the return value first in the out tuple, as it seems to be
* the common behaviour for GI-based bindings */
g_callable_info_load_return_type (func_info, &out_args[0].type_info);
if (g_type_info_get_tag (&out_args[0].type_info) != GI_TYPE_TAG_VOID)
out_args[n_out_args++].ptr = &retval->v_pointer;
/* Handle the other arguments */
for (i = 0; i < n_args && exc == NULL; i++)
{
GIArgInfo arg_info;
GIDirection direction;
g_callable_info_load_arg (func_info, i, &arg_info);
direction = g_arg_info_get_direction (&arg_info);
g_arg_info_load_type (&arg_info, &out_args[n_out_args].type_info);
if (direction == GI_DIRECTION_IN)
{
js_in_args[n_in_args++] = seed_value_from_gi_argument (sexten->js_context,
&args[i],
&out_args[n_out_args].type_info,
&exc);
}
if (direction == GI_DIRECTION_INOUT)
{
GIArgument arg;
peas_gi_pointer_to_argument (&out_args[n_out_args].type_info,
args[i].v_pointer, &arg);
js_in_args[n_in_args++] = seed_value_from_gi_argument (sexten->js_context,
&arg,
&out_args[n_out_args].type_info,
&exc);
}
if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT)
out_args[n_out_args++].ptr = args[i].v_pointer;
}
if (exc != NULL)
goto cleanup;
js_ret = seed_object_call (sexten->js_context,
js_method,
sexten->js_object,
n_in_args,
js_in_args,
&exc);
if (exc != NULL)
goto cleanup;
if (n_out_args == 1)
{
if (seed_value_to_gi_argument (sexten->js_context, js_ret,
&out_args[0].type_info, &argument, &exc))
{
peas_gi_argument_to_pointer (&out_args[0].type_info,
&argument, out_args[0].ptr);
}
}
else if (n_out_args > 0 && seed_value_is_object (sexten->js_context, js_ret))
{
for (i = 0; i < n_out_args && exc == NULL; i++)
{
val = seed_object_get_property_at_index (sexten->js_context, js_ret,
i, exc);
if (exc == NULL &&
seed_value_to_gi_argument (sexten->js_context, val,
&out_args[i].type_info,
&argument, &exc))
{
peas_gi_argument_to_pointer (&out_args[i].type_info,
&argument, out_args[i].ptr);
}
}
}
cleanup:
g_base_info_unref ((GIBaseInfo *) func_info);
if (exc == NULL)
return TRUE;
exc_string = seed_exception_to_string (sexten->js_context, exc);
g_warning ("Seed Exception: %s", exc_string);
g_free (exc_string);
return FALSE;
}
gboolean
json_deserialize_pspec (GValue *value,
GParamSpec *pspec,
JsonNode *node)
{
GValue node_value = { 0, };
gboolean retval = FALSE;
if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOXED)
{
JsonNodeType node_type = json_node_get_node_type (node);
GType boxed_type = G_VALUE_TYPE (value);
if (json_boxed_can_deserialize (boxed_type, node_type))
{
gpointer boxed = json_boxed_deserialize (boxed_type, node);
g_value_take_boxed (value, boxed);
return TRUE;
}
}
switch (JSON_NODE_TYPE (node))
{
case JSON_NODE_OBJECT:
if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT))
{
GObject *object;
object = json_gobject_new (G_VALUE_TYPE (value), json_node_get_object (node));
if (object != NULL)
g_value_take_object (value, object);
else
g_value_set_object (value, NULL);
retval = TRUE;
}
break;
case JSON_NODE_ARRAY:
if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
JsonArray *array = json_node_get_array (node);
guint i, array_len = json_array_get_length (array);
GPtrArray *str_array = g_ptr_array_sized_new (array_len + 1);
for (i = 0; i < array_len; i++)
{
JsonNode *val = json_array_get_element (array, i);
if (JSON_NODE_TYPE (val) != JSON_NODE_VALUE)
continue;
if (json_node_get_string (val) != NULL)
g_ptr_array_add (str_array, (gpointer) json_node_get_string (val));
}
g_ptr_array_add (str_array, NULL);
g_value_set_boxed (value, str_array->pdata);
g_ptr_array_free (str_array, TRUE);
retval = TRUE;
}
break;
case JSON_NODE_VALUE:
json_node_get_value (node, &node_value);
#if 0
{
gchar *node_str = g_strdup_value_contents (&node_value);
g_debug ("%s: value type '%s' := node value type '%s' -> '%s'",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (&node_value)),
node_str);
g_free (node_str);
}
#endif
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)))
{
case G_TYPE_BOOLEAN:
case G_TYPE_INT64:
case G_TYPE_DOUBLE:
case G_TYPE_STRING:
g_value_copy (&node_value, value);
retval = TRUE;
break;
case G_TYPE_INT:
g_value_set_int (value, (gint) g_value_get_int64 (&node_value));
retval = TRUE;
break;
case G_TYPE_CHAR:
g_value_set_char (value, (gchar) g_value_get_int64 (&node_value));
retval = TRUE;
break;
case G_TYPE_UINT:
g_value_set_uint (value, (guint) g_value_get_int64 (&node_value));
retval = TRUE;
break;
case G_TYPE_UCHAR:
g_value_set_uchar (value, (guchar) g_value_get_int64 (&node_value));
retval = TRUE;
break;
case G_TYPE_FLOAT:
g_value_set_float (value, (gfloat) g_value_get_double (&node_value));
retval = TRUE;
break;
case G_TYPE_ENUM:
{
gint enum_value = 0;
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
enum_value = g_value_get_int64 (&node_value);
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING))
{
retval = enum_from_string (G_VALUE_TYPE (value),
g_value_get_string (&node_value),
&enum_value);
}
if (retval)
g_value_set_enum (value, enum_value);
}
break;
case G_TYPE_FLAGS:
{
gint flags_value = 0;
if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64))
{
flags_value = g_value_get_int64 (&node_value);
retval = TRUE;
}
else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING))
{
retval = flags_from_string (G_VALUE_TYPE (value),
g_value_get_string (&node_value),
&flags_value);
}
if (retval)
g_value_set_flags (value, flags_value);
}
break;
default:
retval = FALSE;
break;
}
g_value_unset (&node_value);
break;
case JSON_NODE_NULL:
retval = FALSE;
break;
}
return retval;
}
static GtkWidget *
attribute_editor (GObject *object,
GParamSpec *spec,
GtkInspectorPropEditor *editor)
{
gpointer layout;
GtkCellArea *area;
GtkTreeModel *model = NULL;
gint col = -1;
GtkWidget *label;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *box;
GtkWidget *combo;
gchar *text;
gint i;
gboolean sensitive;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkTreeIter iter;
layout = g_object_get_data (object, "gtk-inspector-cell-layout");
if (GTK_IS_CELL_LAYOUT (layout))
{
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (layout));
col = gtk_cell_area_attribute_get_column (area,
GTK_CELL_RENDERER (object),
editor->priv->name);
model = gtk_cell_layout_get_model (GTK_CELL_LAYOUT (layout));
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
label = gtk_label_new (_("Attribute mapping"));
gtk_widget_set_margin_top (label, 10);
gtk_container_add (GTK_CONTAINER (vbox), label);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Model:")));
text = g_strdup_printf (_("%p (%s)"), model, g_type_name (G_TYPE_FROM_INSTANCE (model)));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (text));
g_free (text);
button = gtk_button_new_with_label (_("Properties"));
g_object_set_data (G_OBJECT (button), "model", model);
g_signal_connect (button, "clicked", G_CALLBACK (model_properties), editor);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_container_add (GTK_CONTAINER (vbox), box);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Column:")));
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", 0,
"sensitive", 1,
NULL);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, _("None"), 1, TRUE, -1);
for (i = 0; i < gtk_tree_model_get_n_columns (model); i++)
{
text = g_strdup_printf ("%d", i);
sensitive = g_value_type_transformable (gtk_tree_model_get_column_type (model, i),
spec->value_type);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, text, 1, sensitive, -1);
g_free (text);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), col + 1);
attribute_mapping_changed (GTK_COMBO_BOX (combo), editor);
g_signal_connect (combo, "changed",
G_CALLBACK (attribute_mapping_changed), editor);
gtk_container_add (GTK_CONTAINER (box), combo);
gtk_container_add (GTK_CONTAINER (vbox), box);
gtk_widget_show_all (vbox);
return vbox;
}
JsonNode *
json_serialize_pspec (const GValue *real_value,
GParamSpec *pspec)
{
JsonNode *retval = NULL;
GValue value = { 0, };
JsonNodeType node_type;
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (real_value)))
{
case G_TYPE_INT64:
case G_TYPE_BOOLEAN:
case G_TYPE_DOUBLE:
/* JSON native types */
retval = json_node_new (JSON_NODE_VALUE);
g_value_init (&value, G_VALUE_TYPE (real_value));
g_value_copy (real_value, &value);
json_node_set_value (retval, &value);
g_value_unset (&value);
break;
case G_TYPE_STRING:
/* strings might be NULL, so we handle it differently */
if (!g_value_get_string (real_value))
retval = json_node_new (JSON_NODE_NULL);
else
{
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_string (retval, g_value_get_string (real_value));
break;
}
break;
case G_TYPE_INT:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_int (real_value));
break;
case G_TYPE_FLOAT:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_double (retval, g_value_get_float (real_value));
break;
case G_TYPE_BOXED:
if (G_VALUE_HOLDS (real_value, G_TYPE_STRV))
{
gchar **strv = g_value_get_boxed (real_value);
gint i, strv_len;
JsonArray *array;
strv_len = g_strv_length (strv);
array = json_array_sized_new (strv_len);
for (i = 0; i < strv_len; i++)
{
JsonNode *str = json_node_new (JSON_NODE_VALUE);
json_node_set_string (str, strv[i]);
json_array_add_element (array, str);
}
retval = json_node_new (JSON_NODE_ARRAY);
json_node_take_array (retval, array);
}
else if (json_boxed_can_serialize (G_VALUE_TYPE (real_value), &node_type))
{
gpointer boxed = g_value_get_boxed (real_value);
retval = json_boxed_serialize (G_VALUE_TYPE (real_value), boxed);
}
else
g_warning ("Boxed type '%s' is not handled by JSON-GLib",
g_type_name (G_VALUE_TYPE (real_value)));
break;
case G_TYPE_UINT:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_uint (real_value));
break;
case G_TYPE_LONG:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_long (real_value));
break;
case G_TYPE_ULONG:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_long (real_value));
break;
case G_TYPE_CHAR:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_char (real_value));
break;
case G_TYPE_UCHAR:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_uchar (real_value));
break;
case G_TYPE_ENUM:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_enum (real_value));
break;
case G_TYPE_FLAGS:
retval = json_node_new (JSON_NODE_VALUE);
json_node_set_int (retval, g_value_get_flags (real_value));
break;
case G_TYPE_OBJECT:
{
GObject *object = g_value_get_object (real_value);
if (object != NULL)
{
retval = json_node_new (JSON_NODE_OBJECT);
json_node_take_object (retval, json_gobject_dump (object));
}
else
retval = json_node_new (JSON_NODE_NULL);
}
break;
case G_TYPE_NONE:
retval = json_node_new (JSON_NODE_NULL);
break;
default:
g_warning ("Unsupported type `%s'", g_type_name (G_VALUE_TYPE (real_value)));
break;
}
return retval;
}
/**
* gst_element_register:
* @plugin: (allow-none): #GstPlugin to register the element with, or NULL for
* a static element.
* @name: name of elements of this type
* @rank: rank of element (higher rank means more importance when autoplugging)
* @type: GType of element to register
*
* Create a new elementfactory capable of instantiating objects of the
* @type and add the factory to @plugin.
*
* Returns: TRUE, if the registering succeeded, FALSE on error
*/
gboolean
gst_element_register (GstPlugin * plugin, const gchar * name, guint rank,
GType type)
{
GstPluginFeature *existing_feature;
GstRegistry *registry;
GstElementFactory *factory;
GType *interfaces;
guint n_interfaces, i;
GstElementClass *klass;
GList *item;
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (g_type_is_a (type, GST_TYPE_ELEMENT), FALSE);
registry = gst_registry_get ();
/* check if feature already exists, if it exists there is no need to update it
* when the registry is getting updated, outdated plugins and all their
* features are removed and readded.
*/
existing_feature = gst_registry_lookup_feature (registry, name);
if (existing_feature) {
GST_DEBUG_OBJECT (registry, "update existing feature %p (%s)",
existing_feature, name);
factory = GST_ELEMENT_FACTORY_CAST (existing_feature);
factory->type = type;
existing_feature->loaded = TRUE;
g_type_set_qdata (type, __gst_elementclass_factory, factory);
gst_object_unref (existing_feature);
return TRUE;
}
factory =
GST_ELEMENT_FACTORY_CAST (g_object_newv (GST_TYPE_ELEMENT_FACTORY, 0,
NULL));
gst_plugin_feature_set_name (GST_PLUGIN_FEATURE_CAST (factory), name);
GST_LOG_OBJECT (factory, "Created new elementfactory for type %s",
g_type_name (type));
/* provide info needed during class structure setup */
g_type_set_qdata (type, __gst_elementclass_factory, factory);
klass = GST_ELEMENT_CLASS (g_type_class_ref (type));
CHECK_METADATA_FIELD (klass, name, GST_ELEMENT_METADATA_LONGNAME);
CHECK_METADATA_FIELD (klass, name, GST_ELEMENT_METADATA_KLASS);
CHECK_METADATA_FIELD (klass, name, GST_ELEMENT_METADATA_DESCRIPTION);
CHECK_METADATA_FIELD (klass, name, GST_ELEMENT_METADATA_AUTHOR);
factory->type = type;
factory->metadata = gst_structure_copy ((GstStructure *) klass->metadata);
for (item = klass->padtemplates; item; item = item->next) {
GstPadTemplate *templ = item->data;
GstStaticPadTemplate *newt;
gchar *caps_string = gst_caps_to_string (templ->caps);
newt = g_slice_new (GstStaticPadTemplate);
newt->name_template = g_intern_string (templ->name_template);
newt->direction = templ->direction;
newt->presence = templ->presence;
newt->static_caps.caps = NULL;
newt->static_caps.string = g_intern_string (caps_string);
factory->staticpadtemplates =
g_list_append (factory->staticpadtemplates, newt);
g_free (caps_string);
}
factory->numpadtemplates = klass->numpadtemplates;
/* special stuff for URI handling */
if (g_type_is_a (type, GST_TYPE_URI_HANDLER)) {
GstURIHandlerInterface *iface = (GstURIHandlerInterface *)
g_type_interface_peek (klass, GST_TYPE_URI_HANDLER);
if (!iface || !iface->get_type || !iface->get_protocols)
goto urierror;
if (iface->get_type)
factory->uri_type = iface->get_type (factory->type);
if (!GST_URI_TYPE_IS_VALID (factory->uri_type))
goto urierror;
if (iface->get_protocols) {
const gchar *const *protocols;
protocols = iface->get_protocols (factory->type);
factory->uri_protocols = g_strdupv ((gchar **) protocols);
}
if (!factory->uri_protocols)
goto urierror;
}
interfaces = g_type_interfaces (type, &n_interfaces);
for (i = 0; i < n_interfaces; i++) {
__gst_element_factory_add_interface (factory, g_type_name (interfaces[i]));
}
g_free (interfaces);
if (plugin && plugin->desc.name) {
GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = plugin->desc.name;
GST_PLUGIN_FEATURE_CAST (factory)->plugin = plugin;
g_object_add_weak_pointer ((GObject *) plugin,
(gpointer *) & GST_PLUGIN_FEATURE_CAST (factory)->plugin);
} else {
GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = "NULL";
GST_PLUGIN_FEATURE_CAST (factory)->plugin = NULL;
}
gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE_CAST (factory), rank);
GST_PLUGIN_FEATURE_CAST (factory)->loaded = TRUE;
gst_registry_add_feature (registry, GST_PLUGIN_FEATURE_CAST (factory));
return TRUE;
/* ERRORS */
urierror:
{
GST_WARNING_OBJECT (factory, "error with uri handler!");
gst_element_factory_cleanup (factory);
return FALSE;
}
detailserror:
{
gst_element_factory_cleanup (factory);
return FALSE;
}
}
/**
* fo_property_writing_mode_validate:
* @datatype: #FoDatatype to be validated against allowed datatypes and
* values for current property.
* @context: #FoContext object from which to possibly inherit values.
* @error: Information about any error that has occurred.
*
* Validates @datatype against allowed values. Returns @datatype, a
* replacement datatype value, or NULL if validation failed.
*
* Return value: Valid datatype value or NULL.
**/
FoDatatype*
fo_property_writing_mode_validate (FoDatatype *datatype,
FoContext *context,
GError **error)
{
FoDatatype *new_datatype;
GError *tmp_error = NULL;
gchar *token;
g_return_val_if_fail (datatype != NULL, NULL);
g_return_val_if_fail (FO_IS_DATATYPE (datatype), NULL);
g_return_val_if_fail (context != NULL, NULL);
g_return_val_if_fail (FO_IS_CONTEXT (context), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (FO_IS_ENUM (datatype))
{
FoEnumEnum value = fo_enum_get_value (datatype);
if ((value == FO_ENUM_ENUM_LR_TB) ||
(value == FO_ENUM_ENUM_RL_TB) ||
(value == FO_ENUM_ENUM_TB_RL))
{
return datatype;
}
else if (value == FO_ENUM_ENUM_LR)
{
new_datatype = g_object_ref (fo_enum_factory_get_enum_by_nick ("lr-tb"));
g_object_unref (datatype);
return new_datatype;
}
else if (value == FO_ENUM_ENUM_RL)
{
new_datatype = g_object_ref (fo_enum_factory_get_enum_by_nick ("rl-tb"));
g_object_unref (datatype);
return new_datatype;
}
else if (value == FO_ENUM_ENUM_TB)
{
new_datatype = g_object_ref (fo_enum_factory_get_enum_by_nick ("tb-rl"));
g_object_unref (datatype);
return new_datatype;
}
else
{
gchar *datatype_sprintf = fo_object_sprintf (datatype);
g_set_error (error,
FO_FO_ERROR,
FO_FO_ERROR_ENUMERATION_TOKEN,
_(fo_fo_error_messages[FO_FO_ERROR_ENUMERATION_TOKEN]),
class_name,
datatype_sprintf,
g_type_name (G_TYPE_FROM_INSTANCE (datatype)));
g_object_unref (datatype);
g_free (datatype_sprintf);
return NULL;
}
}
else if (FO_IS_STRING (datatype))
{
token = fo_string_get_value (datatype);
new_datatype =
fo_property_writing_mode_resolve_enum (token, context, &tmp_error);
g_object_unref (datatype);
fo_propagate_and_return_val_if_error (error, tmp_error, NULL);
return new_datatype;
}
else if (FO_IS_NAME (datatype))
{
token = fo_name_get_value (datatype);
new_datatype =
fo_property_writing_mode_resolve_enum (token, context, &tmp_error);
g_object_unref (datatype);
fo_propagate_and_return_val_if_error (error, tmp_error, NULL);
return new_datatype;
}
else
{
gchar *datatype_sprintf = fo_object_sprintf (datatype);
g_set_error (error,
FO_FO_ERROR,
FO_FO_ERROR_DATATYPE,
_(fo_fo_error_messages[FO_FO_ERROR_DATATYPE]),
class_name,
datatype_sprintf,
g_type_name (G_TYPE_FROM_INSTANCE (datatype)));
g_object_unref (datatype);
g_free (datatype_sprintf);
return NULL;
}
}
