GParamSpec*
g_param_spec_flags (const gchar *name,
const gchar *nick,
const gchar *blurb,
GType flags_type,
guint default_value,
GParamFlags flags)
{
GParamSpecFlags *fspec;
GFlagsClass *flags_class;
g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), NULL);
flags_class = g_type_class_ref (flags_type);
g_return_val_if_fail ((default_value & flags_class->mask) == default_value, NULL);
fspec = g_param_spec_internal (G_TYPE_PARAM_FLAGS,
name,
nick,
blurb,
flags);
fspec->flags_class = flags_class;
fspec->default_value = default_value;
G_PARAM_SPEC (fspec)->value_type = flags_type;
return G_PARAM_SPEC (fspec);
}
/**
* gimp_flags_get_first_value:
* @flags_type: the #GType of registered flags
* @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 flags registered as @flags_type.
* If the value exists in that flags, 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 @flags_type,
* %FALSE otherwise
*
* Since: GIMP 2.2
**/
gboolean
gimp_flags_get_first_value (GType flags_type,
guint value,
const gchar **value_name,
const gchar **value_nick,
const gchar **value_desc,
const gchar **value_help)
{
GFlagsClass *flags_class;
GFlagsValue *flags_value;
g_return_val_if_fail (G_TYPE_IS_FLAGS (flags_type), FALSE);
flags_class = g_type_class_peek (flags_type);
flags_value = g_flags_get_first_value (flags_class, value);
if (flags_value)
{
if (value_name)
*value_name = flags_value->value_name;
if (value_nick)
*value_nick = flags_value->value_nick;
if (value_desc || value_help)
{
GimpFlagsDesc *flags_desc;
flags_desc = gimp_flags_get_first_desc (flags_class, value);
if (value_desc)
*value_desc = ((flags_desc && flags_desc->value_desc) ?
dgettext (gimp_type_get_translation_domain (flags_type),
flags_desc->value_desc) :
NULL);
if (value_help)
*value_help = ((flags_desc && flags_desc->value_desc) ?
dgettext (gimp_type_get_translation_domain (flags_type),
flags_desc->value_help) :
NULL);
}
return TRUE;
}
return FALSE;
}
/**
* g_flags_complete_type_info:
* @g_flags_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 #GFlagsValue 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 complete_type_info()
* function of a #GTypePlugin implementation, see the example for
* g_enum_complete_type_info() above.
*/
void
g_flags_complete_type_info (GType g_flags_type,
GTypeInfo *info,
const GFlagsValue *const_values)
{
g_return_if_fail (G_TYPE_IS_FLAGS (g_flags_type));
g_return_if_fail (info != NULL);
g_return_if_fail (const_values != NULL);
info->class_size = sizeof (GFlagsClass);
info->base_init = NULL;
info->base_finalize = NULL;
info->class_init = (GClassInitFunc) g_flags_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;
}
/**
* 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;
}
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;
}
gboolean _is_type_flags(GType t) {
return G_TYPE_IS_FLAGS(t);
}
static gboolean
flags_from_string (GType type,
const gchar *string,
gint *flags_value)
{
GFlagsClass *fclass;
gchar *endptr, *prevptr;
guint i, j, ret, value;
gchar *flagstr;
GFlagsValue *fv;
const gchar *flag;
gunichar ch;
gboolean eos;
g_return_val_if_fail (G_TYPE_IS_FLAGS (type), 0);
g_return_val_if_fail (string != 0, 0);
ret = TRUE;
value = strtoul (string, &endptr, 0);
if (endptr != string) /* parsed a number */
*flags_value = value;
else
{
fclass = g_type_class_ref (type);
flagstr = g_strdup (string);
for (value = i = j = 0; ; i++)
{
eos = flagstr[i] == '\0';
if (!eos && flagstr[i] != '|')
continue;
flag = &flagstr[j];
endptr = &flagstr[i];
if (!eos)
{
flagstr[i++] = '\0';
j = i;
}
/* trim spaces */
for (;;)
{
ch = g_utf8_get_char (flag);
if (!g_unichar_isspace (ch))
break;
flag = g_utf8_next_char (flag);
}
while (endptr > flag)
{
prevptr = g_utf8_prev_char (endptr);
ch = g_utf8_get_char (prevptr);
if (!g_unichar_isspace (ch))
break;
endptr = prevptr;
}
if (endptr > flag)
{
*endptr = '\0';
fv = g_flags_get_value_by_name (fclass, flag);
if (!fv)
fv = g_flags_get_value_by_nick (fclass, flag);
if (fv)
value |= fv->value;
else
{
ret = FALSE;
break;
}
}
if (eos)
{
*flags_value = value;
break;
}
}
g_free (flagstr);
g_type_class_unref (fclass);
}
return ret;
}
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;
}
