/**
* moto_enum_store_new_with_range:
* @enum_type: the #GType of an enum.
* @minimum: the minimum value to include
* @maximum: the maximum value to include
*
* Creates a new #MotoEnumStore like moto_enum_store_new() but allows
* to limit the enum values to a certain range. Values smaller than
* @minimum or larger than @maximum are not added to the store.
*
* Return value: a new #MotoEnumStore.
*
* Since: MOTO 2.4
**/
GtkListStore *
moto_enum_store_new_with_range(GType enum_type,
gint minimum,
gint maximum)
{
GtkListStore *store;
GEnumValue *value;
g_return_val_if_fail(G_TYPE_IS_ENUM(enum_type), NULL);
store = g_object_new(MOTO_TYPE_ENUM_STORE,
"enum-type", enum_type,
NULL);
for(value = MOTO_ENUM_STORE (store)->enum_class->values;
value->value_name;
value++)
{
if (value->value < minimum || value->value > maximum)
continue;
moto_enum_store_add_value (store, value);
}
return store;
}
static gboolean
enum_from_string (GType type,
const gchar *string,
gint *enum_value)
{
GEnumClass *eclass;
GEnumValue *ev;
gchar *endptr;
gint value;
gboolean retval = TRUE;
g_return_val_if_fail (G_TYPE_IS_ENUM (type), 0);
g_return_val_if_fail (string != NULL, 0);
value = strtoul (string, &endptr, 0);
if (endptr != string) /* parsed a number */
*enum_value = value;
else
{
eclass = g_type_class_ref (type);
ev = g_enum_get_value_by_name (eclass, string);
if (!ev)
ev = g_enum_get_value_by_nick (eclass, string);
if (ev)
*enum_value = ev->value;
else
retval = FALSE;
g_type_class_unref (eclass);
}
return retval;
}
/**
* moto_enum_store_new_with_values_valist:
* @enum_type: the #GType of an enum.
* @n_values: the number of enum values to include
* @args: a va_list of enum values (exactly @n_values)
*
* See moto_enum_store_new_with_values().
*
* Return value: a new #MotoEnumStore.
*
* Since: MOTO 2.4
**/
GtkListStore *
moto_enum_store_new_with_values_valist(GType enum_type,
gint n_values,
va_list args)
{
GtkListStore *store;
GEnumValue *value;
gint i;
g_return_val_if_fail(G_TYPE_IS_ENUM (enum_type), NULL);
g_return_val_if_fail(n_values > 1, NULL);
store = g_object_new(MOTO_TYPE_ENUM_STORE,
"enum-type", enum_type,
NULL);
for(i = 0; i < n_values; i++)
{
value = g_enum_get_value(MOTO_ENUM_STORE (store)->enum_class,
va_arg (args, gint));
if(value)
moto_enum_store_add_value(store, value);
}
return store;
}
/**
* gimp_enum_radio_frame_new_with_range:
* @enum_type: the #GType of an enum.
* @minimum: the minimum enum value
* @maximum: the maximum enum value
* @label_widget: a widget to put into the frame that will hold the radio box.
* @callback: a callback to connect to the "toggled" signal of each
* #GtkRadioButton that is created.
* @callback_data: data to pass to the @callback.
* @first_button: returns the first button in the created group.
*
* Calls gimp_enum_radio_box_new_with_range() and puts the resulting
* vbox into a #GtkFrame.
*
* Return value: a new #GtkFrame holding a group of #GtkRadioButtons.
*
* Since: GIMP 2.4
**/
GtkWidget *
gimp_enum_radio_frame_new_with_range (GType enum_type,
gint minimum,
gint maximum,
GtkWidget *label_widget,
GCallback callback,
gpointer callback_data,
GtkWidget **first_button)
{
GtkWidget *frame;
GtkWidget *radio_box;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
g_return_val_if_fail (label_widget == NULL || GTK_IS_WIDGET (label_widget),
NULL);
frame = gimp_frame_new (NULL);
if (label_widget)
{
gtk_frame_set_label_widget (GTK_FRAME (frame), label_widget);
gtk_widget_show (label_widget);
}
radio_box = gimp_enum_radio_box_new_with_range (enum_type,
minimum,
maximum,
callback, callback_data,
first_button);
gtk_container_add (GTK_CONTAINER (frame), radio_box);
gtk_widget_show (radio_box);
return frame;
}
/**
* gimp_enum_icon_box_new:
* @enum_type: the #GType of an enum.
* @icon_prefix: the prefix of the group of icon names to use.
* @icon_size: the icon size for the icons
* @callback: a callback to connect to the "toggled" signal of each
* #GtkRadioButton that is created.
* @callback_data: data to pass to the @callback.
* @first_button: returns the first button in the created group.
*
* Creates a horizontal box of radio buttons with named icons. The
* icon name for each icon is created by appending the enum_value's
* nick to the given @icon_prefix.
*
* Return value: a new #GtkHBox holding a group of #GtkRadioButtons.
*
* Since: GIMP 2.10
**/
GtkWidget *
gimp_enum_icon_box_new (GType enum_type,
const gchar *icon_prefix,
GtkIconSize icon_size,
GCallback callback,
gpointer callback_data,
GtkWidget **first_button)
{
GEnumClass *enum_class;
GtkWidget *box;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
enum_class = g_type_class_ref (enum_type);
box = gimp_enum_icon_box_new_with_range (enum_type,
enum_class->minimum,
enum_class->maximum,
icon_prefix, icon_size,
callback, callback_data,
first_button);
g_type_class_unref (enum_class);
return box;
}
GParamSpec*
g_param_spec_enum (const gchar *name,
const gchar *nick,
const gchar *blurb,
GType enum_type,
gint default_value,
GParamFlags flags)
{
GParamSpecEnum *espec;
GEnumClass *enum_class;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
enum_class = g_type_class_ref (enum_type);
g_return_val_if_fail (g_enum_get_value (enum_class, default_value) != NULL, NULL);
espec = g_param_spec_internal (G_TYPE_PARAM_ENUM,
name,
nick,
blurb,
flags);
espec->enum_class = enum_class;
espec->default_value = default_value;
G_PARAM_SPEC (espec)->value_type = enum_type;
return G_PARAM_SPEC (espec);
}
/**
* gimp_enum_radio_box_new_with_range:
* @minimum: the minimum enum value
* @maximum: the maximum enum value
* @enum_type: the #GType of an enum.
* @callback: a callback to connect to the "toggled" signal of each
* #GtkRadioButton that is created.
* @callback_data: data to pass to the @callback.
* @first_button: returns the first button in the created group.
*
* Just like gimp_enum_radio_box_new(), this function creates a group
* of radio buttons, but additionally it supports limiting the range
* of available enum values.
*
* Return value: a new #GtkVBox holding a group of #GtkRadioButtons.
*
* Since: GIMP 2.4
**/
GtkWidget *
gimp_enum_radio_box_new_with_range (GType enum_type,
gint minimum,
gint maximum,
GCallback callback,
gpointer callback_data,
GtkWidget **first_button)
{
GtkWidget *vbox;
GtkWidget *button;
GEnumClass *enum_class;
GEnumValue *value;
GSList *group = NULL;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
enum_class = g_type_class_ref (enum_type);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 1);
g_object_weak_ref (G_OBJECT (vbox),
(GWeakNotify) g_type_class_unref, enum_class);
if (first_button)
*first_button = NULL;
for (value = enum_class->values; value->value_name; value++)
{
const gchar *desc;
if (value->value < minimum || value->value > maximum)
continue;
desc = gimp_enum_value_get_desc (enum_class, value);
button = gtk_radio_button_new_with_mnemonic (group, desc);
if (first_button && *first_button == NULL)
*first_button = button;
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (value->value));
if (callback)
g_signal_connect (button, "toggled",
callback,
callback_data);
}
return vbox;
}
static GstElement *
create_payloader_for_caps (const GstCaps * caps)
{
GList *payloader_list, *filtered_list, *l;
GstElementFactory *payloader_factory = NULL;
GstElement *payloader = NULL;
payloader_list =
gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_PAYLOADER,
GST_RANK_NONE);
filtered_list =
gst_element_factory_list_filter (payloader_list, caps, GST_PAD_SRC,
FALSE);
for (l = filtered_list; l != NULL && payloader_factory == NULL; l = l->next) {
payloader_factory = GST_ELEMENT_FACTORY (l->data);
if (gst_element_factory_get_num_pad_templates (payloader_factory) != 2)
payloader_factory = NULL;
}
if (payloader_factory != NULL) {
payloader = gst_element_factory_create (payloader_factory, NULL);
}
if (payloader) {
GParamSpec *pspec;
pspec =
g_object_class_find_property (G_OBJECT_GET_CLASS (payloader),
"config-interval");
if (pspec != NULL && G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_UINT) {
g_object_set (payloader, "config-interval", 1, NULL);
}
pspec =
g_object_class_find_property (G_OBJECT_GET_CLASS (payloader),
"picture-id-mode");
if (pspec != NULL && G_TYPE_IS_ENUM (G_PARAM_SPEC_VALUE_TYPE (pspec))) {
/* Set picture id so that remote peer can determine continuity if */
/* there are lost FEC packets and if it has to NACK them */
g_object_set (payloader, "picture-id-mode", PICTURE_ID_15_BIT, NULL);
}
}
gst_plugin_feature_list_free (filtered_list);
gst_plugin_feature_list_free (payloader_list);
return payloader;
}
const char *gvir_config_genum_get_nick (GType enum_type, gint value)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
enum_class = g_type_class_ref(enum_type);
enum_value = g_enum_get_value(enum_class, value);
g_type_class_unref(enum_class);
if (enum_value != NULL)
return enum_value->value_nick;
g_return_val_if_reached(NULL);
}
/**
* g_enum_complete_type_info:
* @g_enum_type: the type identifier of the type being completed
* @info: (out callee-allocates): the #GTypeInfo struct to be filled in
* @const_values: An array of #GEnumValue structs for the possible
* enumeration values. The array is terminated by a struct with all
* members being 0.
*
* This function is meant to be called from the <literal>complete_type_info</literal>
* function of a #GTypePlugin implementation, as in the following
* example:
*
* |[
* static void
* my_enum_complete_type_info (GTypePlugin *plugin,
* GType g_type,
* GTypeInfo *info,
* GTypeValueTable *value_table)
* {
* static const GEnumValue values[] = {
* { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
* { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
* { 0, NULL, NULL }
* };
*
* g_enum_complete_type_info (type, info, values);
* }
* ]|
*/
void
g_enum_complete_type_info (GType g_enum_type,
GTypeInfo *info,
const GEnumValue *const_values)
{
g_return_if_fail (G_TYPE_IS_ENUM (g_enum_type));
g_return_if_fail (info != NULL);
g_return_if_fail (const_values != NULL);
info->class_size = sizeof (GEnumClass);
info->base_init = NULL;
info->base_finalize = NULL;
info->class_init = (GClassInitFunc) g_enum_class_init;
info->class_finalize = NULL;
info->class_data = const_values;
}
static GVariant *
serialize_pspec(GvsSerializer *self, GParamSpec *pspec, const GValue *value)
{
GvsPropertySerializeFunc func = NULL;
GVariant *variant = NULL;
GType type = pspec->value_type;
/* Try to find the right serialization function */
func = g_param_spec_get_qdata(pspec, gvs_property_serialize_func_quark());
if (func == NULL)
{
if (G_TYPE_IS_FUNDAMENTAL(type))
{
func = serialize_fundamental;
}
else if (G_TYPE_IS_ENUM(type))
{
func = serialize_enum;
}
else if (G_TYPE_IS_FLAGS(type))
{
func = serialize_flags;
}
else if (G_TYPE_IS_OBJECT(type) || G_TYPE_IS_INTERFACE (type))
{
func = serialize_object_property;
}
else if (g_type_is_a(type, G_TYPE_BOXED))
{
func = serialize_boxed_property;
}
}
if (func)
{
variant = func(self, value, NULL);
}
else
{
g_warning("Could not serialize property %s of type %s\n"
"Use gvs_register_property_serialize_func() in your class_init function\n",
pspec->name, g_type_name(pspec->value_type));
}
return variant;
}
static gchar *
enum_value_to_string (GType enum_type,
gint enum_value)
{
gpointer enum_class;
GEnumValue *val;
gchar* result;
g_assert (G_TYPE_IS_ENUM (enum_type));
enum_class = g_type_class_ref (enum_type);
val = g_enum_get_value (G_ENUM_CLASS (enum_class), enum_value);
result = g_strdup (val ? val->value_nick : "undefined");
g_type_class_unref (enum_class);
return result;
}
/**
* gimp_enum_combo_box_new:
* @enum_type: the #GType of an enum.
*
* Creates a #GtkComboBox readily filled with all enum values from a
* given @enum_type. The enum needs to be registered to the type
* system. It should also have %GimpEnumDesc descriptions registered
* that contain translatable value names. This is the case for the
* enums used in the GIMP PDB functions.
*
* This is just a convenience function. If you need more control over
* the enum values that appear in the combo_box, you can create your
* own #GimpEnumStore and use gimp_enum_combo_box_new_with_model().
*
* Return value: a new #GimpEnumComboBox.
*
* Since: GIMP 2.4
**/
GtkWidget *
gimp_enum_combo_box_new (GType enum_type)
{
GtkListStore *store;
GtkWidget *combo_box;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
store = gimp_enum_store_new (enum_type);
combo_box = g_object_new (GIMP_TYPE_ENUM_COMBO_BOX,
"model", store,
NULL);
g_object_unref (store);
return combo_box;
}
/**
* moto_enum_store_new:
* @enum_type: the #GType of an enum.
*
* Creates a new #MotoEnumStore, derived from #GtkListStore and fills
* it with enum values. The enum needs to be registered to the type
* system and should have translatable value names.
*
* Return value: a new #MotoEnumStore.
*
* Since: MOTO 2.4
**/
GtkListStore *
moto_enum_store_new(GType enum_type)
{
GtkListStore *store;
GEnumClass *enum_class;
g_return_val_if_fail(G_TYPE_IS_ENUM(enum_type), NULL);
enum_class = g_type_class_ref(enum_type);
store = moto_enum_store_new_with_range(enum_type,
enum_class->minimum,
enum_class->maximum);
g_type_class_unref(enum_class);
return store;
}
/**
* Determine the type of the object
*
* @param p Pointer to the object
* @return A typespec_t which is zero on error.
*/
static typespec_t _determine_object_type(lua_State *L, void *p)
{
GType type_nr = G_TYPE_FROM_INSTANCE(p);
const char *type_name;
typespec_t ts = { 0 };
for (;;) {
// g_type_query might not succeed if the type isn't completely
// initialized. use g_type_name instead.
type_name = g_type_name(type_nr);
if (!type_name)
luaL_error(L, "invalid object at %p (type %d)", p, (int) type_nr);
// This actually refers to a GEnumClass - a collection of possible
// values of an ENUM, not to a specific value. So this is not useful!
if (G_TYPE_IS_ENUM(type_nr) || G_TYPE_IS_FLAGS(type_nr))
break;
ts = lg_find_struct(L, type_name, 1);
/* found? if so, perform an integrity check */
if (ts.value) {
const char *name = lg_get_type_name(ts);
if (strcmp(name, type_name))
luaL_error(L, "%s internal error: type names don't "
"match: %s - %s", msgprefix, name, type_name);
return ts; // find_struct already returns a normalized value.
}
/* This class is not known. Maybe a base class is known? */
GType parent_type = g_type_parent(type_nr);
if (!parent_type)
luaL_error(L, "%s g_type_parent failed on GType %s (%d)",
msgprefix, type_name, type_nr);
/* Parent found; try again with this. Happens with GdkGCX11,
* which is private, but can be used as GdkGC. */
type_nr = parent_type;
}
typespec_t zero = { 0 };
return zero;
}
G_GNUC_INTERNAL int
gvir_config_genum_get_value (GType enum_type, const char *nick,
gint default_value)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
g_return_val_if_fail(G_TYPE_IS_ENUM(enum_type), default_value);
g_return_val_if_fail(nick != NULL, default_value);
enum_class = g_type_class_ref(enum_type);
enum_value = g_enum_get_value_by_nick(enum_class, nick);
g_type_class_unref(enum_class);
if (enum_value != NULL)
return enum_value->value;
g_return_val_if_reached(default_value);
}
gboolean
g_settings_mapping_is_compatible (GType gvalue_type,
const GVariantType *variant_type)
{
gboolean ok = FALSE;
if (gvalue_type == G_TYPE_BOOLEAN)
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BOOLEAN);
else if (gvalue_type == G_TYPE_CHAR ||
gvalue_type == G_TYPE_UCHAR)
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BYTE);
else if (gvalue_type == G_TYPE_INT ||
gvalue_type == G_TYPE_UINT ||
gvalue_type == G_TYPE_INT64 ||
gvalue_type == G_TYPE_UINT64 ||
gvalue_type == G_TYPE_DOUBLE)
ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT16) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT16) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT32) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT32) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT64) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT64) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_HANDLE) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_DOUBLE));
else if (gvalue_type == G_TYPE_STRING)
ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE ("ay")) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal (variant_type, G_VARIANT_TYPE_SIGNATURE));
else if (gvalue_type == G_TYPE_STRV)
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
else if (G_TYPE_IS_ENUM (gvalue_type))
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING);
else if (G_TYPE_IS_FLAGS (gvalue_type))
ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
return ok;
}
/**
* gimp_enum_radio_box_new:
* @enum_type: the #GType of an enum.
* @callback: a callback to connect to the "toggled" signal of each
* #GtkRadioButton that is created.
* @callback_data: data to pass to the @callback.
* @first_button: returns the first button in the created group.
*
* Creates a new group of #GtkRadioButtons representing the enum
* values. A group of radiobuttons is a good way to represent enums
* with up to three or four values. Often it is better to use a
* #GimpEnumComboBox instead.
*
* Return value: a new #GtkVBox holding a group of #GtkRadioButtons.
*
* Since: GIMP 2.4
**/
GtkWidget *
gimp_enum_radio_box_new (GType enum_type,
GCallback callback,
gpointer callback_data,
GtkWidget **first_button)
{
GEnumClass *enum_class;
GtkWidget *vbox;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
enum_class = g_type_class_ref (enum_type);
vbox = gimp_enum_radio_box_new_with_range (enum_type,
enum_class->minimum,
enum_class->maximum,
callback, callback_data,
first_button);
g_type_class_unref (enum_class);
return vbox;
}
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");
}
}
/**
* gimp_enum_icon_box_new_with_range:
* @enum_type: the #GType of an enum.
* @minimum: the minumim enum value
* @maximum: the maximum enum value
* @icon_prefix: the prefix of the group of icon names to use.
* @icon_size: the icon size for the icons
* @callback: a callback to connect to the "toggled" signal of each
* #GtkRadioButton that is created.
* @callback_data: data to pass to the @callback.
* @first_button: returns the first button in the created group.
*
* Just like gimp_enum_icon_box_new(), this function creates a group
* of radio buttons, but additionally it supports limiting the range
* of available enum values.
*
* Return value: a new #GtkHBox holding a group of #GtkRadioButtons.
*
* Since: GIMP 2.10
**/
GtkWidget *
gimp_enum_icon_box_new_with_range (GType enum_type,
gint minimum,
gint maximum,
const gchar *icon_prefix,
GtkIconSize icon_size,
GCallback callback,
gpointer callback_data,
GtkWidget **first_button)
{
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *image;
GEnumClass *enum_class;
GEnumValue *value;
gchar *icon_name;
GSList *group = NULL;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), NULL);
g_return_val_if_fail (icon_prefix != NULL, NULL);
enum_class = g_type_class_ref (enum_type);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
g_object_weak_ref (G_OBJECT (hbox),
(GWeakNotify) g_type_class_unref, enum_class);
if (first_button)
*first_button = NULL;
for (value = enum_class->values; value->value_name; value++)
{
if (value->value < minimum || value->value > maximum)
continue;
button = gtk_radio_button_new (group);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE);
if (first_button && *first_button == NULL)
*first_button = button;
icon_name = g_strconcat (icon_prefix, "-", value->value_nick, NULL);
image = gtk_image_new_from_icon_name (icon_name, icon_size);
g_free (icon_name);
if (image)
{
gtk_container_add (GTK_CONTAINER (button), image);
gtk_widget_show (image);
}
gimp_help_set_help_data (button,
gimp_enum_value_get_desc (enum_class, value),
NULL);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button));
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_object_set_data (G_OBJECT (button), "gimp-item-data",
GINT_TO_POINTER (value->value));
if (callback)
g_signal_connect (button, "toggled",
callback,
callback_data);
}
return hbox;
}
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 (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;
int indent_len;
query = (GSignalQuery *) l->data;
indent_len = strlen (query->signal_name) +
strlen (g_type_name (query->return_type)) + 24;
indent = g_new0 (gchar, indent_len + 1);
memset (indent, ' ', indent_len);
n_print (" \"%s\" : %s user_function (%s* object",
query->signal_name,
g_type_name (query->return_type), g_type_name (type));
for (j = 0; j < query->n_params; j++) {
if (_name)
g_print ("%s", _name);
if (G_TYPE_IS_FUNDAMENTAL (query->param_types[j])) {
g_print (",\n%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else if (G_TYPE_IS_ENUM (query->param_types[j])) {
g_print (",\n%s%s arg%d", indent,
g_type_name (query->param_types[j]), j);
} else {
g_print (",\n%s%s* arg%d", indent,
g_type_name (query->param_types[j]), j);
}
}
if (k == 0) {
if (_name)
g_print ("%s", _name);
g_print (",\n%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);
}
}
}
void
GStreamerFilter::setCommandProperties (string rest_token)
{
std::vector<std::string> words;
std::vector<std::string>::iterator it;
gchar **elements;
GRegex *regex;
gint i;
GObjectClass *elementClass;
regex = g_regex_new ("([a-zA-Z0-9\\- ]*=[ ]*[a-zA-Z0-9\\-\\/\",=]+)",
G_REGEX_ANCHORED, G_REGEX_MATCH_ANCHORED, NULL);
elements = g_regex_split (regex, rest_token.c_str(),
G_REGEX_MATCH_NOTEMPTY_ATSTART);
g_regex_unref (regex);
i = 0;
while (elements[i] != NULL) {
if (g_strcmp0 (elements [i], "") == 0) {
i++;
continue;
}
std::string aux (elements[i]);
std::string::iterator end_pos = std::remove (aux.begin(), aux.end(), ' ');
aux.erase (end_pos, aux.end() );
words.push_back (aux);
i++;
}
g_strfreev (elements);
elementClass = G_OBJECT_GET_CLASS (this->filter);
regex = g_regex_new ("^([a-zA-Z0-9\\-]+)",
G_REGEX_OPTIMIZE, G_REGEX_MATCH_ANCHORED, NULL);
for (std::string aux : words) {
int i;
GParamSpec *pspec;
elements = g_regex_split (regex, aux.c_str(), G_REGEX_MATCH_NOTEMPTY_ATSTART);
i = 0;
while (elements[i] != NULL) {
i++;
}
if ( i != 3) {
g_strfreev (elements);
continue;
}
pspec = g_object_class_find_property (elementClass, elements[1]);
if (pspec == NULL) {
GST_ERROR ("Property %s not found", elements[1]);
g_strfreev (elements);
continue;
}
if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_STRING) {
g_object_set (G_OBJECT (this->filter), elements[1], (elements[2] + 1), NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( (G_PARAM_SPEC_VALUE_TYPE (pspec) ) == G_TYPE_BOOLEAN) {
if (g_ascii_strcasecmp ( (elements[2] + 1), "true") == 0 ) {
g_object_set (G_OBJECT (this->filter), elements[1], TRUE, NULL);
}
if (g_ascii_strcasecmp ( (elements[2] + 1), "false") == 0 ) {
g_object_set (G_OBJECT (this->filter), elements[1], FALSE, NULL);
}
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_INT) {
gint aux;
sscanf (elements[2] + 1, "%d", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_UINT) {
guint aux;
sscanf (elements[2] + 1, "%d", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_FLOAT) {
gfloat aux;
sscanf (elements[2] + 1, "%f", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_DOUBLE) {
gdouble aux;
sscanf (elements[2] + 1, "%lf", &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_INT64) {
gint64 aux;
sscanf (elements[2] + 1, "%" G_GINT64_FORMAT, &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_UINT64) {
guint64 aux;
sscanf (elements[2] + 1, "%" G_GUINT64_FORMAT, &aux);
g_object_set (G_OBJECT (this->filter), elements[1], aux, NULL);
GST_DEBUG ("Setting %s = %s as %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
} else if ( G_TYPE_IS_ENUM (G_PARAM_SPEC_VALUE_TYPE (pspec) ) ) {
GEnumValue *value;
GEnumClass *enumClass;
gint aux;
enumClass = G_ENUM_CLASS (g_type_class_ref (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
if (enumClass == NULL) {
g_strfreev (elements);
continue;
}
//try to get the enum value from its integer value.
sscanf (elements[2] + 1, "%d", &aux);
value = g_enum_get_value (enumClass, aux);
if (value != NULL) {
g_object_set (G_OBJECT (this->filter), elements[1], value->value, NULL);
GST_DEBUG ("Setting %s = %s as %s, %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ), value->value_nick);
} else {
//try to get the enum value from its name.
value = g_enum_get_value_by_nick (enumClass, elements[2] + 1);
if (value != NULL) {
g_object_set (G_OBJECT (this->filter), elements[1], value->value, NULL);
GST_DEBUG ("Setting %s = %s as %s, %s", elements[1], elements[2] + 1,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ), value->value_nick);
} else {
GST_ERROR ("Enum value not found");
}
}
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == GST_TYPE_CAPS) {
GstCaps *caps = gst_caps_from_string ( (elements[2] + 1) );
g_object_set (G_OBJECT (this->filter), elements[1], caps, NULL);
GST_DEBUG ("Setting %s = %" GST_PTR_FORMAT " as %s", elements[1], caps,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
gst_caps_unref (caps);
} else if ( G_PARAM_SPEC_VALUE_TYPE (pspec) == GST_TYPE_STRUCTURE) {
GstStructure *st = gst_structure_new_from_string ( (elements[2] + 1) );
g_object_set (G_OBJECT (this->filter), elements[1], st, NULL);
GST_DEBUG ("Setting %s = %" GST_PTR_FORMAT " as %s", elements[1], st,
g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
gst_structure_free (st);
} else {
GST_DEBUG ("Unknown param %s = %s as type %s", elements[1],
(elements[2] + 1), g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec) ) );
}
g_strfreev (elements);
}
g_regex_unref (regex);
words.clear ();
}
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);
}
}
}
/**
* gimp_enum_get_value:
* @enum_type: the #GType of a registered enum
* @value: an integer value
* @value_name: return location for the value's name (or %NULL)
* @value_nick: return location for the value's nick (or %NULL)
* @value_desc: return location for the value's translated description (or %NULL)
* @value_help: return location for the value's translated help (or %NULL)
*
* Checks if @value is valid for the enum registered as @enum_type.
* If the value exists in that enum, its name, nick and its translated
* description and help are returned (if @value_name, @value_nick,
* @value_desc and @value_help are not %NULL).
*
* Return value: %TRUE if @value is valid for the @enum_type,
* %FALSE otherwise
*
* Since: GIMP 2.2
**/
gboolean
gimp_enum_get_value (GType enum_type,
gint value,
const gchar **value_name,
const gchar **value_nick,
const gchar **value_desc,
const gchar **value_help)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
gboolean success = FALSE;
g_return_val_if_fail (G_TYPE_IS_ENUM (enum_type), FALSE);
enum_class = g_type_class_ref (enum_type);
enum_value = g_enum_get_value (enum_class, value);
if (enum_value)
{
if (value_name)
*value_name = enum_value->value_name;
if (value_nick)
*value_nick = enum_value->value_nick;
if (value_desc || value_help)
{
GimpEnumDesc *enum_desc;
enum_desc = gimp_enum_get_desc (enum_class, value);
if (value_desc)
{
if (enum_desc && enum_desc->value_desc)
{
const gchar *context;
context = gimp_type_get_translation_context (enum_type);
if (context) /* the new way, using NC_() */
*value_desc = g_dpgettext2 (gimp_type_get_translation_domain (enum_type),
context,
enum_desc->value_desc);
else /* for backward compatibility */
*value_desc = g_strip_context (enum_desc->value_desc,
dgettext (gimp_type_get_translation_domain (enum_type),
enum_desc->value_desc));
}
else
{
*value_desc = NULL;
}
}
if (value_help)
{
*value_help = ((enum_desc && enum_desc->value_help) ?
dgettext (gimp_type_get_translation_domain (enum_type),
enum_desc->value_help) :
NULL);
}
}
success = TRUE;
}
g_type_class_unref (enum_class);
return success;
}
static GtkTreeViewColumn *
eprop_model_generate_column (GladeEditorProperty * eprop,
gint colnum, GladeModelData * data)
{
GtkTreeViewColumn *column = gtk_tree_view_column_new ();
GtkCellRenderer *renderer = NULL;
GtkAdjustment *adjustment;
GtkListStore *store;
GType type = G_TYPE_INVALID;
gtk_tree_view_column_set_title (column, data->name);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_expand (column, TRUE);
type = G_VALUE_TYPE (&data->value);
/* Support enum and flag types, and a hardcoded list of fundamental types */
if (type == G_TYPE_CHAR ||
type == G_TYPE_UCHAR || type == G_TYPE_STRING || type == GDK_TYPE_PIXBUF)
{
/* Text renderer */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer),
"editable", TRUE,
"ellipsize", PANGO_ELLIPSIZE_END, "width", 90, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
if (type == G_TYPE_CHAR || type == G_TYPE_UCHAR)
{
/* XXX restrict to 1 char !! */
}
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_text_edited), eprop);
/* Trigger i18n dialog from here */
if (type == G_TYPE_STRING)
{
GtkCellRenderer *icon_renderer = glade_cell_renderer_icon_new ();
g_object_set (G_OBJECT (icon_renderer),
"activatable", TRUE,
"icon-name", "gtk-edit",
NULL);
gtk_tree_view_column_pack_start (column, icon_renderer, FALSE);
g_object_set_data (G_OBJECT (icon_renderer), "column-number",
GINT_TO_POINTER (colnum));
g_signal_connect (G_OBJECT (icon_renderer), "activate",
G_CALLBACK (value_i18n_activate), eprop);
}
}
else if (type == G_TYPE_BOOLEAN)
{
/* Toggle renderer */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"active", NUM_COLUMNS + colnum,
NULL);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_toggled), eprop);
}
/* Check renderer */
else if (type == G_TYPE_INT ||
type == G_TYPE_UINT ||
type == G_TYPE_LONG ||
type == G_TYPE_ULONG ||
type == G_TYPE_INT64 ||
type == G_TYPE_UINT64 ||
type == G_TYPE_FLOAT || type == G_TYPE_DOUBLE)
{
/* Spin renderer */
renderer = gtk_cell_renderer_spin_new ();
adjustment =
(GtkAdjustment *) gtk_adjustment_new (0, -G_MAXDOUBLE, G_MAXDOUBLE,
100, 100, 0);
g_object_set (G_OBJECT (renderer), "editable", TRUE, "adjustment",
adjustment, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
if (type == G_TYPE_FLOAT || type == G_TYPE_DOUBLE)
g_object_set (G_OBJECT (renderer), "digits", 2, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_text_edited), eprop);
}
else if (G_TYPE_IS_ENUM (type))
{
/* Combo renderer */
renderer = gtk_cell_renderer_combo_new ();
store = glade_utils_liststore_from_enum_type (type, FALSE);
g_object_set (G_OBJECT (renderer),
"editable", TRUE,
"text-column", 0, "has-entry", FALSE, "model", store, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (column),
renderer,
(GtkCellLayoutDataFunc)
enum_flags_format_cell_data, NULL,
NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_text_edited), eprop);
}
else if (G_TYPE_IS_FLAGS (type))
{
/* Export a flags dialog from glade-editor-property... */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
}
else /* All uneditable types at this point (currently we dont do object data here, TODO) */
{
/* text renderer and object dialog (or raw text for pixbuf) */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
}
g_signal_connect (G_OBJECT (renderer), "editing-started",
G_CALLBACK (data_editing_started), eprop);
g_signal_connect (G_OBJECT (renderer), "editing-canceled",
G_CALLBACK (data_editing_canceled), eprop);
g_object_set_data (G_OBJECT (renderer), "column-number",
GINT_TO_POINTER (colnum));
g_object_set_data_full (G_OBJECT (column), "column-type",
g_memdup (&type, sizeof (GType)), g_free);
return column;
}
gboolean _is_type_enum(GType t) {
return G_TYPE_IS_ENUM(t);
}
static void
egg_property_cell_renderer_set_renderer (EggPropertyCellRenderer *renderer,
const gchar *prop_name)
{
EggPropertyCellRendererPrivate *priv;
GParamSpec *pspec;
gchar *text = NULL;
gdouble number;
priv = EGG_PROPERTY_CELL_RENDERER_GET_PRIVATE (renderer);
pspec = get_pspec_from_object (priv->object, prop_name);
/*
* Set this renderers mode, so that any actions can be forwarded to our
* child renderers.
*/
switch (pspec->value_type) {
/* toggle renderers */
case G_TYPE_BOOLEAN:
priv->renderer = priv->toggle_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
break;
/* spin renderers */
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE:
priv->renderer = priv->spin_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
g_object_set (priv->renderer, "digits", 5, NULL);
break;
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_INT64:
case G_TYPE_UINT64:
priv->renderer = priv->spin_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
g_object_set (priv->renderer, "digits", 0, NULL);
break;
/* text renderers */
case G_TYPE_POINTER:
case G_TYPE_STRING:
priv->renderer = priv->text_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
break;
/* combo renderers */
default:
if (G_TYPE_IS_ENUM (pspec->value_type)) {
priv->renderer = priv->combo_renderer;
g_object_set (renderer, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, NULL);
}
break;
}
/*
* Set the content from the objects property.
*/
switch (pspec->value_type) {
case G_TYPE_BOOLEAN:
{
gboolean val;
g_object_get (priv->object, prop_name, &val, NULL);
g_object_set (priv->renderer,
"active", val,
"activatable", pspec->flags & G_PARAM_WRITABLE ? TRUE : FALSE,
NULL);
break;
}
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_INT64:
case G_TYPE_UINT64:
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE:
get_string_double_repr (priv->object, prop_name, &text, &number);
break;
case G_TYPE_STRING:
g_object_get (priv->object, prop_name, &text, NULL);
break;
case G_TYPE_POINTER:
{
gpointer val;
g_object_get (priv->object, prop_name, &val, NULL);
text = g_strdup_printf ("0x%x", GPOINTER_TO_INT (val));
}
break;
default:
if (G_TYPE_IS_ENUM (pspec->value_type)) {
GParamSpecEnum *pspec_enum;
GEnumClass *enum_class;
GtkTreeModel *combo_model;
GtkTreeIter iter;
gint value;
g_object_get (priv->object, prop_name, &value, NULL);
pspec_enum = G_PARAM_SPEC_ENUM (pspec);
enum_class = pspec_enum->enum_class;
combo_model = g_hash_table_lookup (priv->combo_models, prop_name);
if (combo_model == NULL) {
combo_model = GTK_TREE_MODEL (gtk_list_store_new (N_COMBO_COLUMNS, G_TYPE_STRING, G_TYPE_INT));
g_hash_table_insert (priv->combo_models, g_strdup (prop_name), combo_model);
for (guint i = 0; i < enum_class->n_values; i++) {
gtk_list_store_append (GTK_LIST_STORE (combo_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (combo_model), &iter,
COMBO_COLUMN_VALUE_NAME, enum_class->values[i].value_name,
COMBO_COLUMN_VALUE, enum_class->values[i].value,
-1);
}
}
for (guint i = 0; i < enum_class->n_values; i++) {
if (enum_class->values[i].value == value)
text = g_strdup (enum_class->values[i].value_name);
}
g_object_set (priv->renderer,
"model", combo_model,
"text-column", 0,
NULL);
}
break;
}
if (pspec->flags & G_PARAM_WRITABLE) {
if (GTK_IS_CELL_RENDERER_TOGGLE (priv->renderer))
g_object_set (priv->renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
else
g_object_set (priv->renderer, "foreground", "#000000", NULL);
if (GTK_IS_CELL_RENDERER_TEXT (priv->renderer)) {
g_object_set (priv->renderer,
"editable", TRUE,
"mode", GTK_CELL_RENDERER_MODE_EDITABLE,
NULL);
}
if (GTK_IS_CELL_RENDERER_SPIN (priv->renderer)) {
GtkObject *adjustment = NULL;
#define gtk_typed_adjustment_new(type, pspec, val, step_inc, page_inc) \
gtk_adjustment_new (val, ((type *) pspec)->minimum, ((type *) pspec)->maximum, step_inc, page_inc, 0)
switch (pspec->value_type) {
case G_TYPE_INT:
adjustment = gtk_typed_adjustment_new (GParamSpecInt, pspec, number, 1, 10);
break;
case G_TYPE_UINT:
adjustment = gtk_typed_adjustment_new (GParamSpecUInt, pspec, number, 1, 10);
break;
case G_TYPE_LONG:
adjustment = gtk_typed_adjustment_new (GParamSpecLong, pspec, number, 1, 10);
break;
case G_TYPE_ULONG:
adjustment = gtk_typed_adjustment_new (GParamSpecULong, pspec, number, 1, 10);
break;
case G_TYPE_INT64:
adjustment = gtk_typed_adjustment_new (GParamSpecInt64, pspec, number, 1, 10);
break;
case G_TYPE_UINT64:
adjustment = gtk_typed_adjustment_new (GParamSpecUInt64, pspec, number, 1, 10);
break;
case G_TYPE_FLOAT:
adjustment = gtk_typed_adjustment_new (GParamSpecFloat, pspec, number, 0.05, 10);
break;
case G_TYPE_DOUBLE:
adjustment = gtk_typed_adjustment_new (GParamSpecDouble, pspec, number, 0.05, 10);
break;
}
clear_adjustment (G_OBJECT (priv->renderer));
g_object_set (priv->renderer, "adjustment", adjustment, NULL);
}
}
else {
g_object_set (priv->renderer, "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
if (!GTK_IS_CELL_RENDERER_TOGGLE (priv->renderer))
g_object_set (priv->renderer, "foreground", "#aaaaaa", NULL);
}
if (text != NULL) {
g_object_set (priv->renderer, "text", text, NULL);
g_free (text);
}
}
