static GtkWidget*
param_toggle_create (GxkParam *param,
const gchar *tooltip,
guint variant)
{
GtkWidget *widget;
GType type = GTK_TYPE_CHECK_BUTTON;
if (variant == PARAM_TOGGLE_WITH_LABEL ||
g_param_spec_check_option (param->pspec, "trigger"))
type = GTK_TYPE_TOGGLE_BUTTON;
else if (g_param_spec_check_option (param->pspec, "radio"))
type = GXK_TYPE_FREE_RADIO_BUTTON;
widget = g_object_new (type, "visible", TRUE, NULL);
g_object_connect (widget,
"signal::clicked", param_toggle_change_value, param,
NULL);
gxk_widget_set_tooltip (widget, tooltip);
if (variant == PARAM_TOGGLE_WITH_LABEL)
g_object_new (GTK_TYPE_LABEL,
"visible", TRUE,
"use-underline", FALSE,
"label", g_param_spec_get_nick (param->pspec),
"parent", widget,
NULL);
else
g_object_new (GXK_TYPE_SIMPLE_LABEL,
"visible", TRUE,
"use-underline", FALSE,
"label", g_param_spec_get_nick (param->pspec),
"parent", widget,
"auto-cut", TRUE,
NULL);
return widget;
}
static GParamSpec *
copy_param_spec(GParamSpec *in, const gchar *name) {
const gchar * blurb = g_param_spec_get_blurb(in);
GParamSpec *out = NULL;
GParamFlags flags = G_PARAM_READWRITE;
// TODO: handle more things
if (G_IS_PARAM_SPEC_FLOAT(in)) {
GParamSpecFloat *f = G_PARAM_SPEC_FLOAT(in);
out = g_param_spec_double(name, name, blurb, f->minimum, f->maximum, f->default_value, flags);
} else if (G_IS_PARAM_SPEC_DOUBLE(in)) {
GParamSpecDouble *d = G_PARAM_SPEC_DOUBLE(in);
out = g_param_spec_double(name, name, blurb, d->minimum, d->maximum, d->default_value, flags);
} else if (G_IS_PARAM_SPEC_INT(in)) {
GParamSpecInt *i = G_PARAM_SPEC_INT(in);
out = g_param_spec_int(name, name, blurb, i->minimum, i->maximum, i->default_value, flags);
} else if (G_IS_PARAM_SPEC_UINT(in)) {
GParamSpecUInt *u = G_PARAM_SPEC_UINT(in);
out = g_param_spec_int(name, name, blurb, u->minimum, u->maximum, u->default_value, flags);
} else if (G_IS_PARAM_SPEC_LONG(in)) {
GParamSpecLong *l = G_PARAM_SPEC_LONG(in);
out = g_param_spec_int(name, name, blurb, l->minimum, l->maximum, l->default_value, flags);
} else if (GEGL_IS_PARAM_SPEC_COLOR(in)) {
GeglColor *default_value = gegl_param_spec_color_get_default(in);
out = gegl_param_spec_color(name, name, blurb, default_value, flags);
} else {
g_critical("json: Unknown param spec type for property %s", g_param_spec_get_nick(in));
}
return out;
}
static GObject*
base_object_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
/* The constructor is the one place where a GParamSpecOverride is visible
* to the outside world, so we do a bunch of checks here
*/
GValue value1 = { 0, };
GValue value2 = { 0, };
GParamSpec *pspec;
g_assert (n_construct_properties == 1);
pspec = construct_properties->pspec;
/* Check we got the param spec we expected
*/
g_assert (G_IS_PARAM_SPEC_OVERRIDE (pspec));
g_assert (pspec->param_id == BASE_PROP1);
g_assert (strcmp (g_param_spec_get_name (pspec), "prop1") == 0);
g_assert (g_param_spec_get_redirect_target (pspec) == iface_spec1);
/* Test redirection of the nick and blurb to the redirect target
*/
g_assert (strcmp (g_param_spec_get_nick (pspec), "Prop1") == 0);
g_assert (strcmp (g_param_spec_get_blurb (pspec), "Property 1") == 0);
/* Test forwarding of the various GParamSpec methods to the redirect target
*/
g_value_init (&value1, G_TYPE_INT);
g_value_init (&value2, G_TYPE_INT);
g_param_value_set_default (pspec, &value1);
g_assert (g_value_get_int (&value1) == 42);
g_value_reset (&value1);
g_value_set_int (&value1, 0x10000);
g_assert (g_param_value_validate (pspec, &value1));
g_assert (g_value_get_int (&value1) == 0xFFFF);
g_assert (!g_param_value_validate (pspec, &value1));
g_value_reset (&value1);
g_value_set_int (&value1, 1);
g_value_set_int (&value2, 2);
g_assert (g_param_values_cmp (pspec, &value1, &value2) < 0);
g_assert (g_param_values_cmp (pspec, &value2, &value1) > 0);
g_value_unset (&value1);
g_value_unset (&value2);
return base_parent_class->constructor (type,
n_construct_properties,
construct_properties);
}
static void
my_object_get_property(GObject *gobject,
guint prop_id, GValue * value, GParamSpec *pspec)
{
MyObject *myobj = (MyObject *) gobject;
GObjectWrapper *context =
static_cast<GObjectWrapper *>(myobj->context);
(*context->get_get_method_pointer(prop_id)) (value,
context->property_get_user_data
(g_param_spec_get_nick
(pspec)));
}
static gboolean
gst_egueb_demux_install_property (GObjectClass * klass, GObjectClass * from,
guint id, const gchar *name)
{
GParamSpec *pspec;
GParamSpec *npspec;
pspec = g_object_class_find_property(from, name);
if (!pspec) return FALSE;
npspec = g_param_spec_internal (G_PARAM_SPEC_TYPE (pspec), pspec->name,
g_param_spec_get_nick (pspec), g_param_spec_get_blurb (pspec), pspec->flags);
g_object_class_install_property (klass, id, npspec);
return TRUE;
}
static void
param_item_seq_popup_editor (GtkWidget *widget,
GxkParam *param)
{
SfiProxy proxy = bst_param_get_proxy (param);
if (proxy)
{
BsePropertyCandidates *pc = bse_item_get_property_candidates (proxy, param->pspec->name);
SfiSeq *seq = g_value_get_boxed (¶m->value);
BseItemSeq *iseq = bse_item_seq_from_seq (seq);
bst_item_seq_dialog_popup (widget, proxy,
pc->label, pc->tooltip, pc->items,
g_param_spec_get_nick (param->pspec), g_param_spec_get_blurb (param->pspec), iseq,
param_item_seq_changed,
param, NULL);
bse_item_seq_free (iseq);
}
}
static void
distribution_changed_cb (GtkComboBox *box, DistPrefs *prefs)
{
GODistribution *dist = NULL;
int i, j, n;
GtkTreeIter iter;
GODistributionType dist_type;
GParamSpec **props;
GtkTreeModel *model = gtk_combo_box_get_model (box);
gtk_combo_box_get_active_iter (box, &iter);
gtk_tree_model_get (model, &iter, 1, &dist_type, -1);
dist = go_distribution_new (dist_type);
g_object_set (prefs->client, "distribution", dist, NULL);
props = g_object_class_list_properties (G_OBJECT_GET_CLASS (dist), &n);
for (j = i = 0; j < n; j++)
if (props[j]->flags & GO_PARAM_PERSISTENT) {
char *lbl = g_strconcat (_(g_param_spec_get_nick (props[j])), _(":"), NULL);
if (!prefs->labels[i]) {
GtkWidget *w = gtk_label_new (lbl);
g_free (lbl);
g_object_set (w, "xalign", 0., NULL);
gtk_grid_attach (prefs->grid, w, 0, i + 1, 1, 1);
prefs->labels[i] = w;
} else
gtk_label_set_text (GTK_LABEL (prefs->labels[i]), lbl);
if (!prefs->data[i]) {
GtkWidget *w = GTK_WIDGET (gog_data_allocator_editor (prefs->dalloc, GOG_DATASET (prefs->client), i, GOG_DATA_SCALAR));
gtk_grid_attach (prefs->grid, w, 1, i + 1, 1, 1);
prefs->data[i] = w;
}
gtk_widget_show (prefs->labels[i]);
gtk_widget_show (prefs->data[i]);
prefs->props[i++] = props[j];
}
while (i < 2) {
if (prefs->labels[i])
gtk_widget_hide (prefs->labels[i]);
if (prefs->data[i])
gtk_widget_hide (prefs->data[i]);
prefs->props[i++] = NULL;
}
g_free (props);
g_object_unref (dist);
}
gint64
gimp_g_param_spec_get_memsize (GParamSpec *pspec)
{
gint64 memsize = 0;
if (! pspec)
return 0;
if (! (pspec->flags & G_PARAM_STATIC_NAME))
memsize += gimp_string_get_memsize (g_param_spec_get_name (pspec));
if (! (pspec->flags & G_PARAM_STATIC_NICK))
memsize += gimp_string_get_memsize (g_param_spec_get_nick (pspec));
if (! (pspec->flags & G_PARAM_STATIC_BLURB))
memsize += gimp_string_get_memsize (g_param_spec_get_blurb (pspec));
return memsize + gimp_g_type_instance_get_memsize ((GTypeInstance *) pspec);
}
static void
test_param_spec_char (void)
{
GParamSpec *pspec;
GValue value = { 0, };
gboolean modified;
pspec = g_param_spec_char ("char", "nick", "blurb",
20, 40, 30, G_PARAM_READWRITE);
//g_param_spec_ref_force_floating(pspec);
//g_assert(g_param_spec_is_floating(pspec));
g_param_spec_ref_sink(pspec);
g_assert (strcmp (g_param_spec_get_name (pspec), "char") == 0);
g_assert (strcmp (g_param_spec_get_nick (pspec), "nick") == 0);
g_assert (strcmp (g_param_spec_get_blurb (pspec), "blurb") == 0);
g_value_init (&value, G_TYPE_CHAR);
g_value_set_char (&value, 30);
g_assert (g_param_value_defaults (pspec, &value));
g_value_set_char (&value, 0);
modified = g_param_value_validate (pspec, &value);
g_assert (modified && g_value_get_char (&value) == 20);
g_value_set_char (&value, 20);
modified = g_param_value_validate (pspec, &value);
g_assert (!modified && g_value_get_char (&value) == 20);
g_value_set_char (&value, 40);
modified = g_param_value_validate (pspec, &value);
g_assert (!modified && g_value_get_char (&value) == 40);
g_value_set_char (&value, 60);
modified = g_param_value_validate (pspec, &value);
g_assert (modified && g_value_get_char (&value) == 40);
g_param_spec_unref (pspec);
}
static void
constructed (GObject *object)
{
GtkInspectorPropEditor *editor = GTK_INSPECTOR_PROP_EDITOR (object);
GParamSpec *spec;
GtkWidget *label;
gboolean can_modify;
spec = find_property (editor);
label = gtk_label_new (g_param_spec_get_nick (spec));
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (editor), label);
can_modify = ((spec->flags & G_PARAM_WRITABLE) != 0 &&
(spec->flags & G_PARAM_CONSTRUCT_ONLY) == 0);
if (!can_modify)
return;
editor->priv->editor = property_editor (editor->priv->object, spec, editor);
gtk_widget_show (editor->priv->editor);
gtk_container_add (GTK_CONTAINER (editor), editor->priv->editor);
if (GTK_IS_CELL_RENDERER (editor->priv->object))
gtk_container_add (GTK_CONTAINER (editor),
attribute_editor (editor->priv->object, spec, editor));
if (GTK_IS_ACTIONABLE (editor->priv->object) &&
g_strcmp0 (editor->priv->name, "action-name") == 0)
gtk_container_add (GTK_CONTAINER (editor),
action_editor (editor->priv->object, editor));
add_binding_info (editor);
add_settings_info (editor);
add_gtk_settings_info (editor);
}
GtkWidget *
gimp_prop_table_new (GObject *config,
GType owner_type,
GimpContext *context,
GimpCreatePickerFunc create_picker_func,
gpointer picker_creator)
{
GtkWidget *table;
GtkSizeGroup *size_group;
GParamSpec **param_specs;
guint n_param_specs;
gint i;
gint row = 0;
GParamSpec *last_pspec = NULL;
GtkAdjustment *last_x_adj = NULL;
gint last_x_row = 0;
g_return_val_if_fail (G_IS_OBJECT (config), NULL);
g_return_val_if_fail (context == NULL || GIMP_IS_CONTEXT (context), NULL);
param_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (config),
&n_param_specs);
size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
table = gtk_table_new (3, 1, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
for (i = 0; i < n_param_specs; i++)
{
GParamSpec *pspec = param_specs[i];
GtkWidget *widget = NULL;
const gchar *label = NULL;
/* ignore properties of parent classes of owner_type */
if (! g_type_is_a (pspec->owner_type, owner_type))
continue;
if (G_IS_PARAM_SPEC_STRING (pspec))
{
static GQuark multiline_quark = 0;
if (! multiline_quark)
multiline_quark = g_quark_from_static_string ("multiline");
if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec))
{
widget = gimp_prop_file_chooser_button_new (config,
pspec->name,
g_param_spec_get_nick (pspec),
GTK_FILE_CHOOSER_ACTION_OPEN);
}
else if (g_param_spec_get_qdata (pspec, multiline_quark))
{
GtkTextBuffer *buffer;
GtkWidget *view;
buffer = gimp_prop_text_buffer_new (config, pspec->name, -1);
view = gtk_text_view_new_with_buffer (buffer);
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (widget), view);
gtk_widget_show (view);
}
else
{
widget = gimp_prop_entry_new (config, pspec->name, -1);
}
label = g_param_spec_get_nick (pspec);
}
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
{
widget = gimp_prop_check_button_new (config, pspec->name,
g_param_spec_get_nick (pspec));
}
else if (G_IS_PARAM_SPEC_ENUM (pspec))
{
widget = gimp_prop_enum_combo_box_new (config, pspec->name, 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (widget),
g_param_spec_get_nick (pspec));
}
else if (GEGL_IS_PARAM_SPEC_SEED (pspec))
{
GtkAdjustment *adj;
GtkWidget *scale;
GtkWidget *button;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
scale = gimp_prop_spin_scale_new (config, pspec->name,
g_param_spec_get_nick (pspec),
1.0, 10.0, 0);
gtk_box_pack_start (GTK_BOX (widget), scale, TRUE, TRUE, 0);
gtk_widget_show (scale);
button = gtk_button_new_with_label (_("New Seed"));
gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0);
gtk_widget_show (button);
adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (scale));
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_prop_table_new_seed_clicked),
adj);
}
else if (G_IS_PARAM_SPEC_INT (pspec) ||
G_IS_PARAM_SPEC_UINT (pspec) ||
G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec))
{
GtkAdjustment *adj;
gdouble value;
gdouble lower;
gdouble upper;
gdouble step = 1.0;
gdouble page = 10.0;
gint digits = (G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)) ? 2 : 0;
if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec))
{
GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec);
lower = gspec->ui_minimum;
upper = gspec->ui_maximum;
}
else if (GEGL_IS_PARAM_SPEC_INT (pspec))
{
GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec);
lower = gspec->ui_minimum;
upper = gspec->ui_maximum;
}
else
{
_gimp_prop_widgets_get_numeric_values (config, pspec,
&value, &lower, &upper,
G_STRFUNC);
}
if ((upper - lower < 10.0) &&
(G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)))
{
step = 0.1;
page = 1.0;
digits = 3;
}
widget = gimp_prop_spin_scale_new (config, pspec->name,
g_param_spec_get_nick (pspec),
step, page, digits);
adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
if (g_str_has_suffix (pspec->name, "x") ||
g_str_has_suffix (pspec->name, "width"))
{
last_pspec = pspec;
last_x_adj = adj;
last_x_row = row;
}
else if ((g_str_has_suffix (pspec->name, "y") ||
g_str_has_suffix (pspec->name, "height")) &&
last_pspec != NULL &&
last_x_adj != NULL &&
last_x_row == row - 1)
{
GtkWidget *chain = gimp_chain_button_new (GIMP_CHAIN_RIGHT);
gtk_table_attach (GTK_TABLE (table), chain,
3, 4, last_x_row, row + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL,
0, 0);
gtk_widget_show (chain);
if (gtk_adjustment_get_value (last_x_adj) ==
gtk_adjustment_get_value (adj))
{
GBinding *binding;
gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain), TRUE);
binding = g_object_bind_property (last_x_adj, "value",
adj, "value",
G_BINDING_BIDIRECTIONAL);
g_object_set_data (G_OBJECT (chain), "binding", binding);
}
g_signal_connect (chain, "toggled",
G_CALLBACK (gimp_prop_table_chain_toggled),
last_x_adj);
g_object_set_data (G_OBJECT (last_x_adj), "y-adjustment", adj);
if (create_picker_func)
{
GtkWidget *button;
gchar *pspec_name;
pspec_name = g_strconcat (last_pspec->name, ":",
pspec->name, NULL);
button = create_picker_func (picker_creator,
pspec_name,
GIMP_STOCK_CURSOR,
_("Pick coordinates from the image"));
gtk_table_attach (GTK_TABLE (table), button,
4, 5, last_x_row, row + 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL,
0, 0);
gtk_widget_show (button);
g_object_weak_ref (G_OBJECT (button),
(GWeakNotify) g_free, pspec_name);
}
}
}
else if (GIMP_IS_PARAM_SPEC_RGB (pspec))
{
GtkWidget *button;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
button = gimp_prop_color_button_new (config, pspec->name,
g_param_spec_get_nick (pspec),
128, 24,
GIMP_COLOR_AREA_SMALL_CHECKS);
gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE);
gimp_color_panel_set_context (GIMP_COLOR_PANEL (button), context);
gtk_box_pack_start (GTK_BOX (widget), button, TRUE, TRUE, 0);
gtk_widget_show (button);
if (create_picker_func)
{
button = create_picker_func (picker_creator,
pspec->name,
GIMP_STOCK_COLOR_PICKER_GRAY,
_("Pick color from the image"));
gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
label = g_param_spec_get_nick (pspec);
}
else
{
g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name);
}
if (widget)
{
if (label)
{
gimp_table_attach_aligned (GTK_TABLE (table), 0, row,
label, 0.0, 0.5,
widget, 2, FALSE);
}
else
{
gtk_table_attach_defaults (GTK_TABLE (table), widget,
0, 3, row, row + 1);
gtk_widget_show (widget);
}
row++;
}
}
g_object_unref (size_group);
g_free (param_specs);
return table;
}
static void
impl_constructed (GObject *object)
{
RBObjectPropertyEditor *editor;
GObjectClass *klass;
int i;
int row;
RB_CHAIN_GOBJECT_METHOD (rb_object_property_editor_parent_class, constructed, object);
editor = RB_OBJECT_PROPERTY_EDITOR (object);
klass = G_OBJECT_GET_CLASS (editor->priv->object);
editor->priv->notify_id = g_signal_connect (editor->priv->object, "notify", G_CALLBACK (notify_cb), editor);
row = 0;
for (i = 0; editor->priv->properties[i] != NULL; i++) {
GParamSpec *pspec;
GtkWidget *label;
GtkWidget *control;
GType prop_type;
pspec = g_object_class_find_property (klass, editor->priv->properties[i]);
if (pspec == NULL) {
g_warning ("couldn't find property %s on object %s",
editor->priv->properties[i],
G_OBJECT_CLASS_NAME (klass));
continue;
}
prop_type = G_PARAM_SPEC_TYPE (pspec);
if (prop_type == G_TYPE_PARAM_BOOLEAN) {
control = create_boolean_editor (editor, editor->priv->properties[i], pspec);
} else if (prop_type == G_TYPE_PARAM_ENUM) {
control = create_enum_editor (editor, editor->priv->properties[i], pspec);
} else if (prop_type == G_TYPE_PARAM_INT) {
control = create_int_editor (editor, editor->priv->properties[i], pspec);
} else if (prop_type == G_TYPE_PARAM_FLOAT) {
control = create_float_editor (editor, editor->priv->properties[i], pspec);
} else if (prop_type == G_TYPE_PARAM_DOUBLE) {
control = create_double_editor (editor, editor->priv->properties[i], pspec);
} else {
/* can't do this */
g_warning ("don't know how to edit %s", g_type_name (prop_type));
continue;
}
g_signal_connect (control, "focus-out-event", G_CALLBACK (focus_out_cb), editor);
gtk_widget_set_hexpand (control, TRUE);
label = gtk_label_new (g_param_spec_get_nick (pspec));
gtk_widget_set_tooltip_text (label, g_param_spec_get_blurb (pspec));
gtk_grid_attach (GTK_GRID (editor),
label,
0, row, 1, 1);
gtk_grid_attach (GTK_GRID (editor),
control,
1, row, 1, 1);
row++;
}
}
GtkWidget *
gimp_prop_widget_new_from_pspec (GObject *config,
GParamSpec *pspec,
GimpContext *context,
GimpCreatePickerFunc create_picker_func,
gpointer picker_creator,
const gchar **label)
{
GtkWidget *widget = NULL;
g_return_val_if_fail (G_IS_OBJECT (config), NULL);
g_return_val_if_fail (pspec != NULL, NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (label != NULL, NULL);
*label = NULL;
if (GEGL_IS_PARAM_SPEC_SEED (pspec))
{
GtkAdjustment *adj;
GtkWidget *spin;
GtkWidget *button;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
spin = gimp_prop_spin_button_new (config, pspec->name,
1.0, 10.0, 0);
gtk_box_pack_start (GTK_BOX (widget), spin, TRUE, TRUE, 0);
gtk_widget_show (spin);
button = gtk_button_new_with_label (_("New Seed"));
gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0);
gtk_widget_show (button);
adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
g_signal_connect (button, "clicked",
G_CALLBACK (gimp_prop_widget_new_seed_clicked),
adj);
*label = g_param_spec_get_nick (pspec);
}
else if (G_IS_PARAM_SPEC_INT (pspec) ||
G_IS_PARAM_SPEC_UINT (pspec) ||
G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec))
{
gdouble lower;
gdouble upper;
gdouble step;
gdouble page;
gint digits;
if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec))
{
GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec);
lower = gspec->ui_minimum;
upper = gspec->ui_maximum;
step = gspec->ui_step_small;
page = gspec->ui_step_big;
digits = gspec->ui_digits;
}
else if (GEGL_IS_PARAM_SPEC_INT (pspec))
{
GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec);
lower = gspec->ui_minimum;
upper = gspec->ui_maximum;
step = gspec->ui_step_small;
page = gspec->ui_step_big;
digits = 0;
}
else
{
gdouble value;
_gimp_prop_widgets_get_numeric_values (config, pspec,
&value, &lower, &upper,
G_STRFUNC);
if ((upper - lower <= 1.0) &&
(G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)))
{
step = 0.01;
page = 0.1;
digits = 4;
}
else if ((upper - lower <= 10.0) &&
(G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)))
{
step = 0.1;
page = 1.0;
digits = 3;
}
else
{
step = 1.0;
page = 10.0;
digits = (G_IS_PARAM_SPEC_FLOAT (pspec) ||
G_IS_PARAM_SPEC_DOUBLE (pspec)) ? 2 : 0;
}
}
widget = gimp_prop_spin_scale_new (config, pspec->name, NULL,
step, page, digits);
if (HAS_KEY (pspec, "unit", "degree") &&
(upper - lower) == 360.0)
{
GtkWidget *hbox;
GtkWidget *dial;
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (widget), TRUE);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
dial = gimp_prop_angle_dial_new (config, pspec->name);
gtk_box_pack_start (GTK_BOX (hbox), dial, FALSE, FALSE, 0);
gtk_widget_show (dial);
widget = hbox;
}
else if (HAS_KEY (pspec, "unit", "kelvin"))
{
GtkWidget *hbox;
GtkWidget *button;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
button = gimp_prop_kelvin_presets_new (config, pspec->name);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
widget = hbox;
}
}
else if (G_IS_PARAM_SPEC_STRING (pspec))
{
static GQuark multiline_quark = 0;
if (! multiline_quark)
multiline_quark = g_quark_from_static_string ("multiline");
if (GIMP_IS_PARAM_SPEC_CONFIG_PATH (pspec))
{
widget =
gimp_prop_file_chooser_button_new (config, pspec->name,
g_param_spec_get_nick (pspec),
GTK_FILE_CHOOSER_ACTION_OPEN);
}
else if (g_param_spec_get_qdata (pspec, multiline_quark))
{
GtkTextBuffer *buffer;
GtkWidget *view;
buffer = gimp_prop_text_buffer_new (config, pspec->name, -1);
view = gtk_text_view_new_with_buffer (buffer);
g_object_unref (buffer);
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (widget),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (widget), view);
gtk_widget_show (view);
}
else
{
widget = gimp_prop_entry_new (config, pspec->name, -1);
}
*label = g_param_spec_get_nick (pspec);
}
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
{
widget = gimp_prop_check_button_new (config, pspec->name,
g_param_spec_get_nick (pspec));
}
else if (G_IS_PARAM_SPEC_ENUM (pspec))
{
widget = gimp_prop_enum_combo_box_new (config, pspec->name, 0, 0);
gimp_int_combo_box_set_label (GIMP_INT_COMBO_BOX (widget),
g_param_spec_get_nick (pspec));
}
else if (GIMP_IS_PARAM_SPEC_RGB (pspec))
{
GtkWidget *button;
widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
button = gimp_prop_color_button_new (config, pspec->name,
g_param_spec_get_nick (pspec),
128, 24,
GIMP_COLOR_AREA_SMALL_CHECKS);
gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE);
gimp_color_panel_set_context (GIMP_COLOR_PANEL (button), context);
gtk_box_pack_start (GTK_BOX (widget), button, TRUE, TRUE, 0);
gtk_widget_show (button);
if (create_picker_func)
{
button = create_picker_func (picker_creator,
pspec->name,
GIMP_STOCK_COLOR_PICKER_GRAY,
_("Pick color from the image"));
gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0);
gtk_widget_show (button);
}
*label = g_param_spec_get_nick (pspec);
}
else
{
g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name);
}
return widget;
}
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_pad_template (element_class,
gst_static_pad_template_get (&program_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&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
adg_adim_class_init(AdgADimClass *klass)
{
GObjectClass *gobject_class;
AdgEntityClass *entity_class;
AdgDimClass *dim_class;
GParamSpec *param, *old_param;
gobject_class = (GObjectClass *) klass;
entity_class = (AdgEntityClass *) klass;
dim_class = (AdgDimClass *) klass;
g_type_class_add_private(klass, sizeof(AdgADimPrivate));
gobject_class->dispose = _adg_dispose;
gobject_class->get_property = _adg_get_property;
gobject_class->set_property = _adg_set_property;
entity_class->global_changed = _adg_global_changed;
entity_class->local_changed = _adg_local_changed;
entity_class->invalidate = _adg_invalidate;
entity_class->arrange = _adg_arrange;
entity_class->render = _adg_render;
dim_class->default_value = _adg_default_value;
/* Override #AdgDim:value to append a degree symbol
* to the default set value template string */
old_param = g_object_class_find_property(gobject_class, "value");
param = g_param_spec_string(old_param->name,
g_param_spec_get_nick(old_param),
g_param_spec_get_blurb(old_param),
"<>" ADG_UTF8_DEGREE,
old_param->flags);
g_object_class_install_property(gobject_class, PROP_VALUE, param);
param = g_param_spec_boxed("org1",
P_("First Origin"),
P_("Where the first line comes from: this point is used toghether with \"ref1\" to align the first extension line"),
ADG_TYPE_POINT,
G_PARAM_READWRITE);
g_object_class_install_property(gobject_class, PROP_ORG1, param);
param = g_param_spec_boxed("org2",
P_("Second Origin"),
P_("Where the second line comes from: this point is used toghether with \"ref2\" to align the second extension line"),
ADG_TYPE_POINT,
G_PARAM_READWRITE);
g_object_class_install_property(gobject_class, PROP_ORG2, param);
param = g_param_spec_boolean("has-extension1",
P_("Has First Extension Line flag"),
P_("Show (TRUE) or hide (FALSE) the first extension line"),
TRUE, G_PARAM_READWRITE);
g_object_class_install_property(gobject_class, PROP_HAS_EXTENSION1, param);
param = g_param_spec_boolean("has-extension2",
P_("Has Second Extension Line flag"),
P_("Show (TRUE) or hide (FALSE) the second extension line"),
TRUE, G_PARAM_READWRITE);
g_object_class_install_property(gobject_class, PROP_HAS_EXTENSION2, param);
}
static void
print_element_properties (GstElement * element, gint pfx)
{
GParamSpec **property_specs;
guint num_properties;
gint i;
gboolean readable;
property_specs = g_object_class_list_properties
(G_OBJECT_GET_CLASS (element), &num_properties);
PUT_START_TAG (pfx, "element-properties");
for (i = 0; i < num_properties; i++) {
GValue value = { 0, };
GParamSpec *param = property_specs[i];
readable = FALSE;
g_value_init (&value, param->value_type);
if (param->flags & G_PARAM_READABLE) {
g_object_get_property (G_OBJECT (element), param->name, &value);
readable = TRUE;
}
PUT_START_TAG (pfx + 1, "element-property");
PUT_ESCAPED (pfx + 2, "name", g_param_spec_get_name (param));
PUT_ESCAPED (pfx + 2, "type", g_type_name (param->value_type));
PUT_ESCAPED (pfx + 2, "nick", g_param_spec_get_nick (param));
PUT_ESCAPED (pfx + 2, "blurb", g_param_spec_get_blurb (param));
if (readable) {
PUT_ESCAPED (pfx + 2, "flags", "RW");
} else {
PUT_ESCAPED (pfx + 2, "flags", "W");
}
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
case G_TYPE_BOOLEAN:
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
case G_TYPE_ULONG:
{
GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
PUT_STRING (pfx + 2, "<range min=\"%lu\" max=\"%lu\"/>",
pulong->minimum, pulong->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
case G_TYPE_LONG:
{
GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
PUT_STRING (pfx + 2, "<range min=\"%ld\" max=\"%ld\"/>",
plong->minimum, plong->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
case G_TYPE_UINT:
{
GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
PUT_STRING (pfx + 2, "<range min=\"%u\" max=\"%u\"/>",
puint->minimum, puint->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
case G_TYPE_INT:
{
GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
PUT_STRING (pfx + 2, "<range min=\"%d\" max=\"%d\"/>",
pint->minimum, pint->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
case G_TYPE_UINT64:
{
GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
PUT_STRING (pfx + 2,
"<range min=\"%" G_GUINT64_FORMAT "\" max=\"%" G_GUINT64_FORMAT
"\"/>", puint64->minimum, puint64->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
case G_TYPE_INT64:
{
GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
PUT_STRING (pfx + 2,
"<range min=\"%" G_GINT64_FORMAT "\" max=\"%" G_GINT64_FORMAT
"\"/>", pint64->minimum, pint64->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
case G_TYPE_FLOAT:
{
GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
PUT_STRING (pfx + 2, "<range min=\"%f\" max=\"%f\"/>",
pfloat->minimum, pfloat->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
case G_TYPE_DOUBLE:
{
GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
PUT_STRING (pfx + 2, "<range min=\"%g\" max=\"%g\"/>",
pdouble->minimum, pdouble->maximum);
PUT_ESCAPED (pfx + 2, "default", g_strdup_value_contents (&value));
break;
}
default:
if (param->value_type == GST_TYPE_CAPS) {
GstCaps *caps = g_value_peek_pointer (&value);
if (!caps)
PUT_ESCAPED (pfx + 2, "default", "NULL");
else {
print_caps (caps, 2);
}
} else if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
guint j = 0;
gint enum_value;
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)
break;
j++;
}
PUT_STRING (pfx + 2, "<default>%d</default>", values[j].value);
PUT_START_TAG (pfx + 2, "enum-values");
j = 0;
while (values[j].value_name) {
PUT_STRING (pfx + 3, "<value value=\"%d\" nick=\"%s\"/>",
values[j].value, values[j].value_nick);
j++;
}
PUT_END_TAG (pfx + 2, "enum-values");
} else if (G_IS_PARAM_SPEC_FLAGS (param)) {
GFlagsValue *values;
guint j = 0;
gint flags_value;
values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;
flags_value = g_value_get_flags (&value);
PUT_STRING (pfx + 2, "<default>%d</default>", flags_value);
PUT_START_TAG (pfx + 2, "flags");
j = 0;
while (values[j].value_name) {
PUT_STRING (pfx + 3, "<flag value=\"%d\" nick=\"%s\"/>",
values[j].value, values[j].value_nick);
j++;
}
PUT_END_TAG (pfx + 2, "flags");
} else if (G_IS_PARAM_SPEC_OBJECT (param)) {
PUT_ESCAPED (pfx + 2, "object-type", g_type_name (param->value_type));
}
break;
}
PUT_END_TAG (pfx + 1, "element-property");
}
PUT_END_TAG (pfx, "element-properties");
g_free (property_specs);
}
GtkWidget *
go_distribution_pref_new (GObject *obj, GogDataAllocator *dalloc, G_GNUC_UNUSED GOCmdContext *cc)
{
GtkListStore *model;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GParamSpec **props;
int n, i, j;
DistPrefs *prefs = g_new0 (DistPrefs, 1);
GtkWidget *res = gtk_grid_new ();
GtkWidget *w = gtk_label_new (_("Distribution:"));
GODistribution *dist = NULL;
GODistributionType dist_type;
prefs->dalloc = dalloc;
prefs->grid = GTK_GRID (res);
g_object_get (obj, "distribution", &dist, NULL);
g_return_val_if_fail (GO_IS_DISTRIBUTION (dist), NULL);
dist_type = go_distribution_get_distribution_type (dist);
g_object_set (res, "border-width", 12, "row-spacing", 12, "column-spacing", 24, NULL);
g_object_set (w, "xalign", 0., NULL);
gtk_grid_attach (prefs->grid, w, 0, 0, 1, 1);
g_signal_connect_swapped (res, "destroy", G_CALLBACK (destroy_cb), prefs);
prefs->client = obj;
/* add the list of known distributions in a combobox */
model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
w = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
g_object_unref (model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (w), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (w), renderer,
"text", 0,
NULL);
for (i = 0; i < GO_DISTRIBUTION_MAX; i++) {
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _(go_distribution_type_to_string (i)), 1, i, -1);
if (i == dist_type)
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (w), &iter);
}
g_signal_connect (w, "changed", G_CALLBACK (distribution_changed_cb), prefs);
gtk_grid_attach (prefs->grid, w, 1, 0, 1, 1);
/* other persistent properties */
i = 1;
props = g_object_class_list_properties (G_OBJECT_GET_CLASS (dist), &n);
for (j = 0; j < n; j++)
if (props[j]->flags & GO_PARAM_PERSISTENT) {
char *lbl = g_strconcat (_(g_param_spec_get_nick (props[j])), _(":"), NULL);
w = gtk_label_new (lbl);
g_free (lbl);
g_object_set (w, "xalign", 0., NULL);
gtk_grid_attach (prefs->grid, w, 0, i, 1, 1);
prefs->labels[i-1] = w;
prefs->props[i-1] = props[n];
w = GTK_WIDGET (gog_data_allocator_editor (dalloc, GOG_DATASET (obj), i - 1, GOG_DATA_SCALAR));
gtk_grid_attach (prefs->grid, w, 1, i, 1, 1);
prefs->data[i] = w;
i++;
}
g_free (props);
gtk_widget_show_all (res);
return res;
}
GParamSpec *
gimp_param_spec_duplicate (GParamSpec *pspec)
{
GParamSpec *copy = NULL;
GParamFlags flags;
g_return_val_if_fail (pspec != NULL, NULL);
flags = pspec->flags | GIMP_CONFIG_PARAM_SERIALIZE;
if (G_IS_PARAM_SPEC_STRING (pspec))
{
GParamSpecString *spec = G_PARAM_SPEC_STRING (pspec);
if (GEGL_IS_PARAM_SPEC_FILE_PATH (pspec))
{
copy = gimp_param_spec_config_path (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
GIMP_CONFIG_PATH_FILE,
spec->default_value,
flags);
}
else
{
static GQuark multiline_quark = 0;
if (! multiline_quark)
multiline_quark = g_quark_from_static_string ("multiline");
copy = g_param_spec_string (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->default_value,
flags);
if (GEGL_IS_PARAM_SPEC_MULTILINE (pspec))
{
g_param_spec_set_qdata (copy, multiline_quark,
GINT_TO_POINTER (TRUE));
}
}
}
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
{
GParamSpecBoolean *spec = G_PARAM_SPEC_BOOLEAN (pspec);
copy = g_param_spec_boolean (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->default_value,
flags);
}
else if (G_IS_PARAM_SPEC_ENUM (pspec))
{
GParamSpecEnum *spec = G_PARAM_SPEC_ENUM (pspec);
copy = g_param_spec_enum (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
G_TYPE_FROM_CLASS (spec->enum_class),
spec->default_value,
flags);
}
else if (GEGL_IS_PARAM_SPEC_DOUBLE (pspec))
{
GeglParamSpecDouble *gspec = GEGL_PARAM_SPEC_DOUBLE (pspec);
GParamSpecDouble *spec = G_PARAM_SPEC_DOUBLE (pspec);
copy = gegl_param_spec_double (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
gspec->ui_minimum,
gspec->ui_maximum,
gspec->ui_gamma,
flags);
}
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
{
GParamSpecDouble *spec = G_PARAM_SPEC_DOUBLE (pspec);
copy = g_param_spec_double (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (G_IS_PARAM_SPEC_FLOAT (pspec))
{
GParamSpecFloat *spec = G_PARAM_SPEC_FLOAT (pspec);
copy = g_param_spec_float (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (GEGL_IS_PARAM_SPEC_INT (pspec))
{
GeglParamSpecInt *gspec = GEGL_PARAM_SPEC_INT (pspec);
GParamSpecInt *spec = G_PARAM_SPEC_INT (pspec);
copy = gegl_param_spec_int (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
gspec->ui_minimum,
gspec->ui_maximum,
gspec->ui_gamma,
flags);
}
else if (GEGL_IS_PARAM_SPEC_SEED (pspec))
{
copy = gegl_param_spec_seed (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
pspec->flags |
GIMP_CONFIG_PARAM_SERIALIZE);
}
else if (G_IS_PARAM_SPEC_INT (pspec))
{
GParamSpecInt *spec = G_PARAM_SPEC_INT (pspec);
copy = g_param_spec_int (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (G_IS_PARAM_SPEC_UINT (pspec))
{
GParamSpecUInt *spec = G_PARAM_SPEC_UINT (pspec);
copy = g_param_spec_uint (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
spec->minimum,
spec->maximum,
spec->default_value,
flags);
}
else if (GIMP_IS_PARAM_SPEC_RGB (pspec))
{
GValue value = G_VALUE_INIT;
GimpRGB color;
g_value_init (&value, GIMP_TYPE_RGB);
g_param_value_set_default (pspec, &value);
gimp_value_get_rgb (&value, &color);
g_value_unset (&value);
copy = gimp_param_spec_rgb (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
gimp_param_spec_rgb_has_alpha (pspec),
&color,
flags);
}
else if (GEGL_IS_PARAM_SPEC_COLOR (pspec))
{
GeglColor *gegl_color;
GimpRGB gimp_color;
gdouble r = 0.0;
gdouble g = 0.0;
gdouble b = 0.0;
gdouble a = 1.0;
GValue value = { 0, };
g_value_init (&value, GEGL_TYPE_COLOR);
g_param_value_set_default (pspec, &value);
gegl_color = g_value_get_object (&value);
if (gegl_color)
gegl_color_get_rgba (gegl_color, &r, &g, &b, &a);
gimp_rgba_set (&gimp_color, r, g, b, a);
g_value_unset (&value);
copy = gimp_param_spec_rgb (pspec->name,
g_param_spec_get_nick (pspec),
g_param_spec_get_blurb (pspec),
TRUE,
&gimp_color,
flags);
}
else if (G_IS_PARAM_SPEC_OBJECT (pspec) ||
G_IS_PARAM_SPEC_POINTER (pspec))
{
/* silently ignore object properties */
}
else
{
g_warning ("%s: not supported: %s (%s)\n", G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (pspec)), pspec->name);
}
if (copy)
{
GQuark quark = g_quark_from_static_string ("gegl-property-keys");
GHashTable *keys = g_param_spec_get_qdata (pspec, quark);
if (keys)
g_param_spec_set_qdata (copy, quark, g_hash_table_ref (keys));
}
return copy;
}
void
gss_config_append_config_block (GObject * object, GssTransaction * t,
gboolean show)
{
GString *s = t->s;
GParamSpec **pspecs;
guint n_pspecs;
int i;
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (object),
&n_pspecs);
for (i = 0; i < (int) n_pspecs; i++) {
if (!(pspecs[i]->flags & G_PARAM_READABLE)) {
if (pspecs[i]->value_type == G_TYPE_BOOLEAN) {
gss_html_append_button (s, g_param_spec_get_nick (pspecs[i]),
pspecs[i]->name, "on");
}
}
}
if (!(t->resource->flags & GSS_RESOURCE_ADMIN)) {
g_string_append (s, "<div class='accordion' id='accordion-config'>\n");
g_string_append (s, "<div class='accordion-group'>\n");
g_string_append (s, "<div class='accordion-heading'>\n");
g_string_append (s, "<div class='accordion-toggle'>\n");
g_string_append (s, "<button class='btn btn-mini' data-toggle='collapse' "
"data-parent='#accordion-config' href='#collapse-config'>\n");
g_string_append (s, "<b class='caret'></b> Edit\n");
g_string_append (s, "</button>\n");
g_string_append (s, "</div>\n");
g_string_append_printf (s,
"<div id='collapse-config' class='accordion-body collapse %s'>\n",
show ? "in" : "out");
g_string_append (s, "<div class='accordion-inner'>\n");
}
g_string_append_printf (s,
"<form class='form-horizontal' method='post' enctype='multipart/form-data' >\n");
if (t->session) {
g_string_append_printf (s,
"<input name='session_id' type='hidden' value='%s'>\n",
t->session->session_id);
}
for (i = 0; i < (int) n_pspecs; i++) {
char *value;
const char *blurb;
if (!(pspecs[i]->flags & G_PARAM_READABLE))
continue;
if (pspecs[i]->flags & GSS_PARAM_HIDE)
continue;
if (strcmp (pspecs[i]->name, "name") == 0)
continue;
if (strcmp (pspecs[i]->name, "width") == 0) {
int width, height;
g_object_get (object, "width", &width, "height", &height, NULL);
g_string_append (s, "<div class='control-group'>\n");
g_string_append_printf (s,
"<label class='control-label' for='size'>Size</label>\n");
g_string_append (s, "<div class='controls'>\n");
g_string_append (s, "<div class='input-append'>\n");
g_string_append_printf (s,
"<input type='text' class='input-small' id='width' name='width' "
"value='%d'>", width);
g_string_append (s, "<span class='add-on'>×</span>");
g_string_append_printf (s,
"<input type='text' class='input-small' id='height' name='height' "
"value='%d'>", height);
g_string_append (s,
"<div class='btn-toolbar'>"
"<div class='btn-group'>"
"<button class='btn dropdown-toggle' data-toggle='dropdown' href='#'><b class='caret'></b> Common Sizes</button>"
"<ul class='dropdown-menu'>"
"<li><a href='javascript:void(0)' onclick='setsize(320,240)'>320x240</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(400,300)'>400x300</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(480,360)'>480x360</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(640,480)'>640x480</a></li>"
"<li class='divider'></li>"
"<li><a href='javascript:void(0)' onclick='setsize(320,180)'>320x180</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(400,224)'>400x224</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(480,270)'>480x270</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(640,360)'>640x360</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(800,450)'>800x450</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(960,540)'>960x540</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(1280,720)'>1280x720</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(1600,900)'>1600x900</a></li>"
"<li><a href='javascript:void(0)' onclick='setsize(1920,1080)'>1920x1080</a></li>"
"</ul>" "</div>" "</div>\n");
g_string_append (s, "<script>function setsize(width,height) {\n"
"document.getElementById('width').value=width;"
"document.getElementById('height').value=height;"
"return false;" "}</script>\n");
g_string_append_printf (s, "</div>");
g_string_append_printf (s, "</div>");
g_string_append_printf (s, "</div>");
continue;
}
if (strcmp (pspecs[i]->name, "height") == 0)
continue;
value = g_object_get_as_string (object, pspecs[i]);
g_string_append (s, "<div class='control-group'>\n");
if (g_object_property_is_default (object, pspecs[i])) {
g_string_append_printf (s,
"<label class='control-label' for='%s'>%s</label>\n",
pspecs[i]->name, g_param_spec_get_nick (pspecs[i]));
} else {
g_string_append_printf (s,
"<label class='control-label' for='%s'><b>%s</b></label>\n",
pspecs[i]->name, g_param_spec_get_nick (pspecs[i]));
}
g_string_append (s, "<div class='controls'>\n");
if (pspecs[i]->flags & GSS_PARAM_SECURE) {
g_string_append_printf (s, "<div id='hide-%s'>\n", pspecs[i]->name);
g_string_append_printf (s,
"<button class='btn' type='button' onclick=\""
"document.getElementById('show-%s').style.display='block';"
"document.getElementById('hide-%s').style.display='none';"
"\">Show</button>\n", pspecs[i]->name, pspecs[i]->name);
g_string_append (s, "</div>\n");
g_string_append_printf (s, "<div id='show-%s' style='display: none;'>\n",
pspecs[i]->name);
}
blurb = g_param_spec_get_blurb (pspecs[i]);
if (blurb[0] == '[') {
g_string_append_printf (s, "<div class='input-append'>");
}
if (!(pspecs[i]->flags & G_PARAM_WRITABLE)) {
char *safe;
safe = gss_html_sanitize_attribute (value);
g_string_append_printf (s,
"<span class='input uneditable-input'>%s</span>", safe);
g_free (safe);
} else if (G_TYPE_IS_ENUM (pspecs[i]->value_type)) {
GEnumClass *eclass;
int value;
int j;
eclass = G_ENUM_CLASS (g_type_class_peek (pspecs[i]->value_type));
g_object_get (object, pspecs[i]->name, &value, NULL);
g_string_append_printf (s, "<select id='%s' name='%s'>\n",
pspecs[i]->name, pspecs[i]->name);
for (j = 0; j < (int) eclass->n_values; j++) {
GEnumValue *ev = eclass->values + j;
g_string_append_printf (s, "<option value=\"%s\" %s>%s</option>\n",
ev->value_name,
(ev->value == value) ? "selected=\"selected\"" : "",
ev->value_nick);
}
g_string_append_printf (s, "</select>");
} else if (pspecs[i]->value_type == G_TYPE_BOOLEAN) {
gboolean selected = TRUE;
g_object_get (object, pspecs[i]->name, &selected, NULL);
g_string_append_printf (s,
"<input type='hidden' name='%s' value='0'>"
"<input type='checkbox' class='input' "
"id='%s' name='%s' value='1' %s>",
pspecs[i]->name,
pspecs[i]->name, pspecs[i]->name, selected ? "checked='on'" : "");
} else if ((pspecs[i]->value_type == G_TYPE_STRING) &&
pspecs[i]->flags & GSS_PARAM_FILE_UPLOAD) {
g_string_append_printf (s, "<input type='file' class='input-xlarge' "
"id='%s' name='%s' value=''>", pspecs[i]->name, pspecs[i]->name);
} else if (pspecs[i]->value_type == G_TYPE_INT) {
g_string_append_printf (s,
"<input type='text' class='input-medium' id='%s' name='%s' "
"value='%s'>", pspecs[i]->name, pspecs[i]->name, value);
} else {
char *u;
u = gss_html_sanitize_attribute (value);
if (pspecs[i]->flags & GSS_PARAM_MULTILINE) {
g_string_append_printf (s,
"<textarea rows='4' class='input-large' id='%s' name='%s'>"
"%s</textarea>", pspecs[i]->name, pspecs[i]->name, u);
} else {
g_string_append_printf (s,
"<input type='text' class='input-large' id='%s' name='%s' "
"value='%s'>", pspecs[i]->name, pspecs[i]->name, u);
}
g_free (u);
}
if (blurb[0] == '[') {
const char *end = strchr (blurb + 1, ']');
int len = end - blurb - 1;
g_string_append_printf (s, "<span class='add-on'>%.*s</span>",
len, blurb + 1);
g_string_append (s, "</div>\n");
blurb = end + 1;
}
if (pspecs[i]->flags & GSS_PARAM_SECURE) {
g_string_append (s, "</div>\n");
}
g_string_append_printf (s, "<span class='help-inline'>%s</span>", blurb);
g_string_append (s, "</div>\n");
g_string_append (s, "</div>\n");
g_free (value);
}
g_string_append (s, "<div class='form-actions'>\n");
g_string_append (s,
"<button type='submit' class='btn btn-primary'>Save changes</button>\n");
//g_string_append (s, "<button class='btn'>Cancel</button>");
g_string_append (s, "</div>\n");
g_free (pspecs);
g_string_append (s, "</form>\n");
if (!(t->resource->flags & GSS_RESOURCE_ADMIN)) {
g_string_append (s, "</div>\n");
g_string_append (s, "</div>\n");
g_string_append (s, "</div>\n");
g_string_append (s, "</div>\n");
g_string_append (s, "</div>\n");
}
}
static VALUE
get_nick(VALUE self)
{
const gchar* str = g_param_spec_get_nick(rbgobj_get_param_spec(self));
return str ? rb_str_new2(str) : Qnil;
}
static void
dvb_base_bin_class_init (DvbBaseBinClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *element_class;
GstBinClass *bin_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"},
{PROP_BANDWIDTH, "bandwidth"},
{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"},
{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;
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;
/* install dvbsrc properties */
dvbsrc_factory = gst_element_factory_find ("dvbsrc");
dvbsrc_class = g_type_class_ref (dvbsrc_factory->type);
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_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 %d for property %s",
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));
}
/* XXX Historical note, originally I tried (ab)using override properties
* in ESourceCamel, which redirected to the equivalent CamelSettings
* property. Seemed to work at first, and I was proud of my clever
* hack, but it turns out g_object_class_list_properties() excludes
* override properties. So the ESourceCamel properties were being
* skipped in source_load_from_key_file() (e-source.c). */
static GParamSpec *
param_spec_clone (GParamSpec *pspec)
{
GParamSpec *clone;
GParamFlags flags;
const gchar *name, *nick, *blurb;
name = g_param_spec_get_name (pspec);
nick = g_param_spec_get_nick (pspec);
blurb = g_param_spec_get_blurb (pspec);
flags = (pspec->flags & ~(G_PARAM_STATIC_STRINGS));
if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) {
GParamSpecBoolean *pspec_boolean = G_PARAM_SPEC_BOOLEAN (pspec);
clone = g_param_spec_boolean (name, nick, blurb,
pspec_boolean->default_value,
flags);
} else if (G_IS_PARAM_SPEC_CHAR (pspec)) {
GParamSpecChar *pspec_char = G_PARAM_SPEC_CHAR (pspec);
clone = g_param_spec_char (name, nick, blurb,
pspec_char->minimum,
pspec_char->maximum,
pspec_char->default_value,
flags);
} else if (G_IS_PARAM_SPEC_UCHAR (pspec)) {
GParamSpecUChar *pspec_uchar = G_PARAM_SPEC_UCHAR (pspec);
clone = g_param_spec_uchar (name, nick, blurb,
pspec_uchar->minimum,
pspec_uchar->maximum,
pspec_uchar->default_value,
flags);
} else if (G_IS_PARAM_SPEC_INT (pspec)) {
GParamSpecInt *pspec_int = G_PARAM_SPEC_INT (pspec);
clone = g_param_spec_int (name, nick, blurb,
pspec_int->minimum,
pspec_int->maximum,
pspec_int->default_value,
flags);
} else if (G_IS_PARAM_SPEC_UINT (pspec)) {
GParamSpecUInt *pspec_uint = G_PARAM_SPEC_UINT (pspec);
clone = g_param_spec_uint (name, nick, blurb,
pspec_uint->minimum,
pspec_uint->maximum,
pspec_uint->default_value,
flags);
} else if (G_IS_PARAM_SPEC_LONG (pspec)) {
GParamSpecLong *pspec_long = G_PARAM_SPEC_LONG (pspec);
clone = g_param_spec_long (name, nick, blurb,
pspec_long->minimum,
pspec_long->maximum,
pspec_long->default_value,
flags);
} else if (G_IS_PARAM_SPEC_ULONG (pspec)) {
GParamSpecULong *pspec_ulong = G_PARAM_SPEC_ULONG (pspec);
clone = g_param_spec_ulong (name, nick, blurb,
pspec_ulong->minimum,
pspec_ulong->maximum,
pspec_ulong->default_value,
flags);
} else if (G_IS_PARAM_SPEC_INT64 (pspec)) {
GParamSpecInt64 *pspec_int64 = G_PARAM_SPEC_INT64 (pspec);
clone = g_param_spec_int64 (name, nick, blurb,
pspec_int64->minimum,
pspec_int64->maximum,
pspec_int64->default_value,
flags);
} else if (G_IS_PARAM_SPEC_UINT64 (pspec)) {
GParamSpecUInt64 *pspec_uint64 = G_PARAM_SPEC_UINT64 (pspec);
clone = g_param_spec_uint64 (name, nick, blurb,
pspec_uint64->minimum,
pspec_uint64->maximum,
pspec_uint64->default_value,
flags);
} else if (G_IS_PARAM_SPEC_FLOAT (pspec)) {
GParamSpecFloat *pspec_float = G_PARAM_SPEC_FLOAT (pspec);
clone = g_param_spec_float (name, nick, blurb,
pspec_float->minimum,
pspec_float->maximum,
pspec_float->default_value,
flags);
} else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) {
GParamSpecDouble *pspec_double = G_PARAM_SPEC_DOUBLE (pspec);
clone = g_param_spec_double (name, nick, blurb,
pspec_double->minimum,
pspec_double->maximum,
pspec_double->default_value,
flags);
} else if (G_IS_PARAM_SPEC_ENUM (pspec)) {
GParamSpecEnum *pspec_enum = G_PARAM_SPEC_ENUM (pspec);
clone = g_param_spec_enum (name, nick, blurb,
pspec->value_type,
pspec_enum->default_value,
flags);
} else if (G_IS_PARAM_SPEC_FLAGS (pspec)) {
GParamSpecFlags *pspec_flags = G_PARAM_SPEC_FLAGS (pspec);
clone = g_param_spec_flags (name, nick, blurb,
pspec->value_type,
pspec_flags->default_value,
flags);
} else if (G_IS_PARAM_SPEC_STRING (pspec)) {
GParamSpecString *pspec_string = G_PARAM_SPEC_STRING (pspec);
clone = g_param_spec_string (name, nick, blurb,
pspec_string->default_value,
flags);
} else if (G_IS_PARAM_SPEC_PARAM (pspec)) {
clone = g_param_spec_param (name, nick, blurb,
pspec->value_type,
flags);
} else if (G_IS_PARAM_SPEC_BOXED (pspec)) {
clone = g_param_spec_boxed (name, nick, blurb,
pspec->value_type,
flags);
} else if (G_IS_PARAM_SPEC_POINTER (pspec)) {
clone = g_param_spec_pointer (name, nick, blurb, flags);
} else if (G_IS_PARAM_SPEC_OBJECT (pspec)) {
clone = g_param_spec_object (name, nick, blurb,
pspec->value_type,
flags);
} else if (G_IS_PARAM_SPEC_UNICHAR (pspec)) {
GParamSpecUnichar *pspec_unichar = G_PARAM_SPEC_UNICHAR (pspec);
clone = g_param_spec_unichar (name, nick, blurb,
pspec_unichar->default_value,
flags);
} else if (G_IS_PARAM_SPEC_GTYPE (pspec)) {
GParamSpecGType *pspec_gtype = G_PARAM_SPEC_GTYPE (pspec);
clone = g_param_spec_gtype (name, nick, blurb,
pspec_gtype->is_a_type,
flags);
} else if (G_IS_PARAM_SPEC_VARIANT (pspec)) {
GParamSpecVariant *pspec_variant = G_PARAM_SPEC_VARIANT (pspec);
clone = g_param_spec_variant (name, nick, blurb,
pspec_variant->type,
pspec_variant->default_value,
flags);
} else {
g_warn_if_reached ();
}
return clone;
}
static void
json_list_properties (GType type, const gchar *opname)
{
GParamSpec **self;
GParamSpec **parent;
guint n_self;
guint n_parent;
gint prop_no;
gboolean first_prop = TRUE;
g_print (",'properties':[\n");
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]));
if (first_prop)
{
first_prop = FALSE;
g_print(" { 'name':'%s'\n", g_param_spec_get_name (self[prop_no]));
}
else
g_print(",{'name':'%s'\n", g_param_spec_get_name (self[prop_no]));
g_print(" ,'label':\"");
json_escape_string (g_param_spec_get_nick (self[prop_no]));
g_print ("\"\n");
if(strstr (type_name, "Param"))
{
type_name = strstr (type_name, "Param");
type_name+=5;
}
g_print(" ,'type':'");
{
for (const char *p = type_name; *p; p++)
g_print("%c", g_ascii_tolower (*p));
}
g_print("'\n");
if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_DOUBLE))
{
gdouble default_value = 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;
if (default_value<-10000000)
g_print (" ,'default':'-inf'\n");
else if (default_value>10000000)
g_print (" ,'default':'+inf'\n");
else
g_print (" ,'default':'%2.2f'\n", default_value);
if (min<-10000000)
g_print (" ,'minimum':'-inf'\n");
else
g_print (" ,'minimum':'%2.2f'\n", min);
if (max>10000000)
g_print (" ,'maximum':'+inf'\n");
else
g_print (" ,'maximum':'%2.2f'\n", max);
if (GEGL_IS_PARAM_SPEC_DOUBLE (self[prop_no]))
{
GeglParamSpecDouble *pspec =
GEGL_PARAM_SPEC_DOUBLE (self[prop_no]);
if (pspec->ui_minimum < -10000000)
g_print (" ,'ui-minimum':'-inf'\n");
else
g_print (" ,'ui-minimum':'%2.2f'\n", pspec->ui_minimum);
if (pspec->ui_maximum > 10000000)
g_print (" ,'ui-maximum':'+inf'\n");
else
g_print (" ,'ui-maximum':'%2.2f'\n", pspec->ui_maximum);
g_print (" ,'ui-gamma':'%2.2f'\n", pspec->ui_gamma);
g_print (" ,'ui-step-small':'%2.2f'\n", pspec->ui_step_small);
g_print (" ,'ui-step-big':'%2.2f'\n", pspec->ui_step_big);
g_print (" ,'ui-digits':'%i'\n", pspec->ui_digits);
}
}
else if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_INT))
{
gint default_value = 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;
if (default_value<-10000000)
g_print (" ,'default':'-inf'\n");
else if (default_value>10000000)
g_print (" ,'default':'+inf'\n");
else
g_print (" ,'default':'%i'\n", default_value);
if (min<-10000000)
g_print (" ,'minimum':'-inf'\n");
else
g_print (" ,'minimum':'%i'\n", min);
if (max>10000000)
g_print (" ,'maximum':'+inf'\n");
else
g_print (" ,'maximum':'%i'\n", max);
if (GEGL_IS_PARAM_SPEC_INT (self[prop_no]))
{
GeglParamSpecInt *pspec =
GEGL_PARAM_SPEC_INT (self[prop_no]);
if (pspec->ui_minimum < -10000000)
g_print (" ,'ui-minimum':'-inf'\n");
else
g_print (" ,'ui-minimum':'%i'\n", pspec->ui_minimum);
if (pspec->ui_maximum > 10000000)
g_print (" ,'ui-maximum':'+inf'\n");
else
g_print (" ,'ui-maximum':'%i'\n", pspec->ui_maximum);
g_print (" ,'ui-gamma':'%2.2f'\n", pspec->ui_gamma);
g_print (" ,'ui-step-small':'%i'\n", pspec->ui_step_small);
g_print (" ,'ui-step-big':'%i'\n", pspec->ui_step_big);
}
}
else if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (self[prop_no]), G_TYPE_BOOLEAN))
{
g_print (" ,'default':'%s'\n", 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;
g_print (" ,'default':\"");
json_escape_string (string);
g_print ("\"\n");
}
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 (" ,'default':\"");
json_escape_string (string);
g_print ("\"\n");
g_free (string);
}
}
else
{
}
if (g_param_spec_get_blurb (self[prop_no]) &&
g_param_spec_get_blurb (self[prop_no])[0]!='\0')
{
g_print (" ,'description':\"");
json_escape_string (g_param_spec_get_blurb (self[prop_no]));
g_print ("\"\n");
}
{
guint count;
gchar **property_keys = gegl_operation_list_property_keys (
opname,
g_param_spec_get_name (self[prop_no]),
&count);
if (property_keys)
{
int i;
if (property_keys[0])
{
/* XXX: list is in reverse order */
for (i = 0; property_keys[i]; i++)
{
g_print (" ,'%s':'%s'\n",
property_keys[i],
gegl_operation_get_property_key (opname,
g_param_spec_get_name (self[prop_no]),
property_keys[i]));
}
}
g_free (property_keys);
}
}
g_print(" }");
}
}
if (self)
g_free (self);
if (parent)
g_free (parent);
g_print ("]");
}
static void test_xml_parser(void) {
GError *error = NULL; ZCloudStorePlugin *pl;
load_xml("<zcloud-module basename=\"disk\">"
"<store-plugin prefix=\"disk\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_clear(&error, "XML: single plugin in a simple module");
ok(NULL != zcloud_get_store_plugin_by_prefix("disk"), "plugin found");
load_xml("<zcloud-module foo=\"bar\" basename=\"myext\">"
"<store-plugin prefix=\"myext\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_set(&error, "*'zcloud-module' attribute 'foo' not recognized",
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, "bogus zcloud-module attribute");
load_xml("<zcloud-module basename=\"myext\">"
"<store-plugin foo=\"bar\" prefix=\"myext\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_set(&error, "*'store-plugin' attribute 'foo' not recognized",
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, "bogus store-plugin attribute");
load_xml("<zcloud-module>"
"<store-plugin prefix=\"myext\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_set(&error, "*'zcloud-module' attribute 'basename' is required",
G_MARKUP_ERROR_INVALID_CONTENT, "missing basename attribute");
load_xml("<zcloud-module basename=\"foo\">"
"<store-plugin></store-plugin>"
"</zcloud-module>", &error);
gerror_is_set(&error, "*'store-plugin' attribute 'prefix' is required",
G_MARKUP_ERROR_INVALID_CONTENT, "missing prefix attribute");
load_xml("<zcloud-module basename=\"myext\">"
"random text"
"</zcloud-module>", &error);
gerror_is_set(&error, "*unexpected text",
G_MARKUP_ERROR_INVALID_CONTENT, "unexpected text");
load_xml("<zcloud-module basename=\"myext\">"
"<blink>hi mom</blink>"
"</zcloud-module>", &error);
gerror_is_set(&error, "*element 'blink' not recognized",
G_MARKUP_ERROR_UNKNOWN_ELEMENT, "bogus element");
load_xml("<store-plugin></store-plugin>", &error);
gerror_is_set(&error, "*element 'store-plugin' must appear in a 'zcloud-module' element",
G_MARKUP_ERROR_INVALID_CONTENT, "store-plugin with no module");
load_xml("<zcloud-module basename=\"myext\">"
"<zcloud-module>", &error);
gerror_is_set(&error, "*element 'zcloud-module' cannot be nested",
G_MARKUP_ERROR_INVALID_CONTENT, "nested zcloud-module");
load_xml("<zcloud-module basename=\"myext\">"
"<store-plugin prefix=\"myext\">"
"<store-plugin prefix=\"myext\">", &error);
gerror_is_set(&error, "*element 'store-plugin' cannot be nested",
G_MARKUP_ERROR_INVALID_CONTENT, "nested store-plugin");
load_xml("<zcloud-module basename=\"myext\">"
"<store-plugin prefix=\"myext\">"
"<store-plugin prefix=\"myext\">", &error);
gerror_is_set(&error, "*element 'store-plugin' cannot be nested",
G_MARKUP_ERROR_INVALID_CONTENT, "nested store-plugin");
load_xml("<parameter name=\"foo\" type=\"string\" blurb=\"bar\" />",
&error);
gerror_is_set(&error, "*element 'parameter' must appear in a 'store-plugin' element",
G_MARKUP_ERROR_INVALID_CONTENT, "property with no module");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter type=\"string\" blurb=\"bar\" />", &error);
gerror_is_set(&error, "*'parameter' attribute 'name' is required",
G_MARKUP_ERROR_INVALID_CONTENT, "missing name attribute");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"foo\" blurb=\"bar\" />", &error);
gerror_is_set(&error, "*'parameter' attribute 'type' is required",
G_MARKUP_ERROR_INVALID_CONTENT, "missing type attribute");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"foo\" type=\"string\" />", &error);
gerror_is_set(&error, "*'parameter' attribute 'blurb' is required",
G_MARKUP_ERROR_INVALID_CONTENT, "missing blurb attribute");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"foo\" hype=\"string\" />", &error);
gerror_is_set(&error, "*'parameter' attribute 'hype' not recognized",
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, "bad property attribute");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"foo\" type=\"rectangle\" blurb=\"bar\"/>", &error);
gerror_is_set(&error, "*invalid parameter type 'rectangle'",
G_MARKUP_ERROR_INVALID_CONTENT, "bad parameter type");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"1foo\" type=\"string\" blurb=\"bar\"/>", &error);
gerror_is_set(&error, "*invalid parameter name '1foo'",
G_MARKUP_ERROR_INVALID_CONTENT, "bad parameter name (starts with number)");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"f_o_o\" type=\"string\" blurb=\"bar\"/>", &error);
gerror_is_set(&error, "*invalid parameter name 'f_o_o'",
G_MARKUP_ERROR_INVALID_CONTENT, "bad parameter name (non-alphanumeric)");
load_xml("<zcloud-module basename=\"mod\">"
"<store-plugin prefix=\"withprop\">"
" <parameter name=\"ver-bose\" type=\"string\" blurb=\"lots to say\" />"
"</store-plugin>"
"</zcloud-module>", &error);
gerror_is_clear(&error, "no error loading a plugin with a property with dashes in its name");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"foo\" type=\"sTrInG\" blurb=\"bar\">"
"<foo>"
"</parameter>", &error);
gerror_is_set(&error, "*'parameter' element must be empty",
G_MARKUP_ERROR_INVALID_CONTENT, "non-empty property");
load_xml("<zcloud-module basename=\"myext\"><store-plugin prefix=\"foo\">"
"<parameter name=\"foo\" type=\"string\" blurb=\"bar\" />"
"<parameter name=\"foo\" type=\"string\" blurb=\"bar\" />", &error);
gerror_is_set(&error, "*duplicate parameter name 'foo'",
G_MARKUP_ERROR_INVALID_CONTENT, "duplicate property");
load_xml("<zcloud-module basename=\"myext\">"
"<store-plugin prefix=\"myext1\"></store-plugin>"
"<store-plugin prefix=\"myext2\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_clear(&error, "no error loading a module with two store plugins");
ok(NULL != zcloud_get_store_plugin_by_prefix("myext1"), "one of two plugins exists");
ok(NULL != zcloud_get_store_plugin_by_prefix("myext2"), ".. as does the other");
load_xml("<zcloud-module basename=\"myext\">"
"<store-plugin prefix=\"dupe\"></store-plugin>"
"<store-plugin prefix=\"dupe\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_set(&error, "*store plugin prefix 'dupe' is already defined",
G_MARKUP_ERROR_INVALID_CONTENT, "duplicate prefixes generate an error");
load_xml("<zcloud-module basename=\"myext1\">"
"<store-plugin prefix=\"one\"></store-plugin>"
"</zcloud-module><zcloud-module basename=\"myext2\">"
"<store-plugin prefix=\"two\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_clear(&error, "no error loading two modules");
pl = zcloud_get_store_plugin_by_prefix("one");
ok(pl != NULL, "prefix one exists");
ok(0 == strcmp(pl->module->basename, "myext1"),
"..and has the right module name");
pl = zcloud_get_store_plugin_by_prefix("two");
ok(pl != NULL, "prefix two exists");
ok(0 == strcmp(pl->module->basename, "myext2"),
"..and has the right module name");
load_xml("<zcloud-module basename=\"mod\">"
"<store-plugin prefix=\"withprop\">"
" <parameter name=\"verbose\" type=\"string\" blurb=\"talkative; wordy\" />"
"</store-plugin>"
"</zcloud-module>", &error);
gerror_is_clear(&error, "no error loading a plugin with a property without a nick");
pl = zcloud_get_store_plugin_by_prefix("withprop");
is_string(get_paramspec(pl, 0)->name, "verbose",
"..name is set correctly");
is_string(g_param_spec_get_blurb(get_paramspec(pl, 0)), "talkative; wordy",
"..blurb is set correctly");
is_int(get_paramspec(pl, 0)->value_type, G_TYPE_STRING,
"..type is set correctly");
is_string(g_param_spec_get_nick(get_paramspec(pl, 0)), "verbose",
"..and the nick defaults correctly");
load_xml("<zcloud-module basename=\"mod\">"
"<store-plugin prefix=\"withprop\">"
" <parameter name=\"verbose\" type=\"string\" nick=\"loud\" blurb=\"talkative; wordy\" />"
"</store-plugin>"
"</zcloud-module>", &error);
gerror_is_clear(&error, "no error loading a plugin with a property with a nick");
pl = zcloud_get_store_plugin_by_prefix("withprop");
is_string(g_param_spec_get_nick(get_paramspec(pl, 0)), "loud",
"..and the nick defaults correctly");
load_xml("<zcloud-module basename=\"foo\">"
"<store-plugin prefix=\"one\"></store-plugin>"
"</zcloud-module><zcloud-module basename=\"foo\">"
"<store-plugin prefix=\"another\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_set(&error, "*zcloud-module with basename 'foo' is already defined",
G_MARKUP_ERROR_INVALID_CONTENT,
"two extensions with the same basename generate an error");
load_xml("<zcloud-module basename=\"myext\">"
"<store-plugin prefix=\"one\"></store-plugin>"
"<store-plugin prefix=\"two\"></store-plugin>"
"</zcloud-module>", &error);
gerror_is_clear(&error, "no error loading two plugins");
{
GSList *iter, *all;
gboolean seen_one = FALSE, seen_two = FALSE;
/* evaluate all of the fields in the structs to make sure they're set
* correctly */
all = zcloud_get_all_store_plugins();
for (iter = all; iter; iter = iter->next) {
pl = (ZCloudStorePlugin *)iter->data;
if (0 == strcmp(pl->prefix, "one"))
seen_one = TRUE;
if (0 == strcmp(pl->prefix, "two"))
seen_two = TRUE;
is_string(pl->module->basename, "myext",
"module basename is correct");
is_string(pl->module->xml_path, "(string)",
"module xml_path is correct");
ok(pl->module->module_path != NULL,
"module module_path is non-NULL");
}
ok(g_slist_length(all) == 2 && seen_one && seen_two,
"saw the correct two plugins");
}
}