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; }