static void param_flags_finalize (GParamSpec *pspec) { GParamSpecFlags *fspec = G_PARAM_SPEC_FLAGS (pspec); GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_FLAGS)); if (fspec->flags_class) { g_type_class_unref (fspec->flags_class); fspec->flags_class = NULL; } parent_class->finalize (pspec); }
static void fixup_color_chooser_button (void) { static gboolean done = FALSE; if (!done) { GtkColorChooserDialogClass *klass; klass = g_type_class_ref (GTK_TYPE_COLOR_CHOOSER_DIALOG); g_assert (klass != NULL); GTK_WIDGET_CLASS (klass)->map = fixup_color_chooser_dialog_map; g_type_class_unref (klass); done = TRUE; } }
void totem_options_register_remote_commands (Totem *totem) { GEnumClass *klass; guint i; klass = (GEnumClass *) g_type_class_ref (TOTEM_TYPE_REMOTE_COMMAND); for (i = TOTEM_REMOTE_COMMAND_UNKNOWN + 1; i < klass->n_values; i++) { GEnumValue *val; val = g_enum_get_value (klass, i); unique_app_add_command (totem->app, val->value_name, i); } g_type_class_unref (klass); }
void gegl_operation_set_key (const gchar *operation_name, const gchar *key_name, const gchar *key_value) { GType type; GObjectClass *klass; type = gegl_operation_gtype_from_name (operation_name); if (!type) return; klass = g_type_class_ref (type); gegl_operation_class_set_key (GEGL_OPERATION_CLASS (klass), key_name, key_value); g_type_class_unref (klass); }
static void param_enum_finalize (GParamSpec *pspec) { GParamSpecEnum *espec = G_PARAM_SPEC_ENUM (pspec); GParamSpecClass *parent_class = g_type_class_peek (g_type_parent (G_TYPE_PARAM_ENUM)); if (espec->enum_class) { g_type_class_unref (espec->enum_class); espec->enum_class = NULL; } parent_class->finalize (pspec); }
static gboolean infinoted_plugin_dbus_mask_from_variant(InfAclMask* mask, GVariant* variant, GError** error) { GEnumClass* enum_class; GEnumValue* val; GVariantIter iter; const gchar* perm; inf_acl_mask_clear(mask); enum_class = G_ENUM_CLASS(g_type_class_ref(INF_TYPE_ACL_SETTING)); g_variant_iter_init(&iter, variant); while(g_variant_iter_next(&iter, "&s", &perm)) { val = g_enum_get_value_by_nick(enum_class, perm); if(val == NULL) { g_set_error( error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No such permission: \"%s\"", perm ); g_type_class_unref(enum_class); return FALSE; } inf_acl_mask_or1(mask, val->value); } g_type_class_unref(enum_class); return TRUE; }
int main(int argc, char **argv) { GEnumClass *xenum = g_type_class_ref(MESON_TYPE_THE_XENUM); GFlagsClass *flags_enum = g_type_class_ref(MESON_TYPE_THE_FLAGS_ENUM); if (g_enum_get_value_by_name(xenum, "MESON_THE_XVALUE")->value != MESON_THE_XVALUE) { fprintf(stderr, "Get MESON_THE_XVALUE by name failed.\n"); return 1; } if (g_enum_get_value_by_nick(xenum, "the-xvalue")->value != MESON_THE_XVALUE) { fprintf(stderr, "Get MESON_THE_XVALUE by nick failed.\n"); return 2; } if (g_flags_get_value_by_name(flags_enum, "MESON_THE_FIRST_VALUE")->value != MESON_THE_FIRST_VALUE) { fprintf(stderr, "Get MESON_THE_FIRST_VALUE by name failed.\n"); return 3; } if (g_flags_get_value_by_nick(flags_enum, "the-first-value")->value != MESON_THE_FIRST_VALUE) { fprintf(stderr, "Get MESON_THE_FIRST_VALUE by nick failed.\n"); return 4; } g_type_class_unref(xenum); g_type_class_unref(flags_enum); fprintf(stderr, "All ok.\n"); return 0; }
static void append_error_value (GString *string, GType enum_type, guint value) { GEnumClass *enum_class; GEnumValue *enum_value; enum_class = g_type_class_ref (enum_type); enum_value = g_enum_get_value (enum_class, value); g_string_append (string, enum_value->value_name); g_type_class_unref (enum_class); }
static void enum_print (int value, GType type, GString *string) { GEnumClass *enum_class; GEnumValue *enum_value; enum_class = g_type_class_ref (type); enum_value = g_enum_get_value (enum_class, value); g_string_append (string, enum_value->value_nick); g_type_class_unref (enum_class); }
static GVariant * g_notification_get_priority_nick (GNotification *notification) { GEnumClass *enum_class; GEnumValue *value; GVariant *nick; enum_class = g_type_class_ref (G_TYPE_NOTIFICATION_PRIORITY); value = g_enum_get_value (enum_class, g_notification_get_priority (notification)); g_assert (value != NULL); nick = g_variant_new_string (value->value_nick); g_type_class_unref (enum_class); return nick; }
static const gchar * enum_value_nick (GType type, gint value) { GEnumClass *eclass; GEnumValue *ev; eclass = g_type_class_ref (type); ev = g_enum_get_value (eclass, value); g_type_class_unref (eclass); if (ev) return ev->value_nick; else return "?"; }
static void enum_pref_create_widget (GOConfNode *node, GtkWidget *grid, gint row, GType enum_type, enum_conf_setter_t setter, enum_conf_getter_t getter, gchar const *default_label, char const *(*label_getter)(int)) { unsigned int i; GtkTreeIter iter; GtkCellRenderer *renderer; GEnumClass *enum_class = G_ENUM_CLASS (g_type_class_ref (enum_type)); GtkWidget *combo = gtk_combo_box_new (); GtkListStore *model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); gint current = getter (); gint current_index = -1; for (i = 0; i < enum_class->n_values ; i++) { gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, label_getter ((int) enum_class->values[i].value), 1, enum_class->values + i, -1); if (enum_class->values[i].value == current) current_index = i; } g_type_class_unref (enum_class); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (model)); g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", 0, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), current_index); gtk_grid_attach (GTK_GRID (grid), combo, 1, row, 1, 1); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (cb_enum_changed), (gpointer) setter); connect_notification (node, (GOConfMonitorFunc)enum_pref_conf_to_widget, combo, grid); pref_create_label (node, grid, row, default_label, combo); set_tip (node, combo); }
static void _disable_gst_object_deep_notify_recurse (GType type) { gint i; GType *types; GObjectClass *klass = g_type_class_ref (type); klass->dispatch_properties_changed = pitivi_disable_gst_object_dispatch_properties_changed; g_type_class_unref (klass); types = g_type_children (type, NULL); for (i=0; types[i]; i++) _disable_gst_object_deep_notify_recurse (types[i]); }
static char * enum_value_to_string (const GValue *value) { GEnumClass *enum_class; GEnumValue *enum_value; char *s; enum_class = g_type_class_ref (G_VALUE_TYPE (value)); enum_value = g_enum_get_value (enum_class, g_value_get_enum (value)); s = g_strdup (enum_value->value_nick); g_type_class_unref (enum_class); return s; }
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); }
gboolean gst_deinterlace_method_supported (GType type, GstVideoFormat format, gint width, gint height) { GstDeinterlaceMethodClass *klass = GST_DEINTERLACE_METHOD_CLASS (g_type_class_ref (type)); gboolean ret; if (format == GST_VIDEO_FORMAT_UNKNOWN) ret = TRUE; else ret = klass->supported (klass, format, width, height); g_type_class_unref (klass); return ret; }
GList * gimp_ui_managers_from_name (const gchar *name) { GimpUIManagerClass *manager_class; GList *list; g_return_val_if_fail (name != NULL, NULL); manager_class = g_type_class_ref (GIMP_TYPE_UI_MANAGER); list = g_hash_table_lookup (manager_class->managers, name); g_type_class_unref (manager_class); return list; }
GList * gimp_action_groups_from_name (const gchar *name) { GimpActionGroupClass *group_class; GList *list; g_return_val_if_fail (name != NULL, NULL); group_class = g_type_class_ref (GIMP_TYPE_ACTION_GROUP); list = g_hash_table_lookup (group_class->groups, name); g_type_class_unref (group_class); return list; }
const gchar * gimp_get_mod_separator (void) { static gchar *mod_separator = NULL; if (! mod_separator) { GtkAccelLabelClass *accel_label_class; accel_label_class = g_type_class_ref (GTK_TYPE_ACCEL_LABEL); mod_separator = g_strdup (accel_label_class->mod_separator); g_type_class_unref (accel_label_class); } return (const gchar *) mod_separator; }
const gchar * gimp_get_mod_name_control (void) { static gchar *mod_name_control = NULL; if (! mod_name_control) { GtkAccelLabelClass *accel_label_class; accel_label_class = g_type_class_ref (GTK_TYPE_ACCEL_LABEL); mod_name_control = g_strdup (accel_label_class->mod_name_control); g_type_class_unref (accel_label_class); } return (const gchar *) mod_name_control; }
gboolean _gtk_css_parser_try_enum (GtkCssParser *parser, GType enum_type, int *value) { GEnumClass *enum_class; gboolean result; const char *start; char *str; g_return_val_if_fail (GTK_IS_CSS_PARSER (parser), FALSE); g_return_val_if_fail (value != NULL, FALSE); result = FALSE; enum_class = g_type_class_ref (enum_type); start = parser->data; str = _gtk_css_parser_try_ident (parser, TRUE); if (str == NULL) return FALSE; if (enum_class->n_values) { GEnumValue *enum_value; for (enum_value = enum_class->values; enum_value->value_name; enum_value++) { if (enum_value->value_nick && g_ascii_strcasecmp (str, enum_value->value_nick) == 0) { *value = enum_value->value; result = TRUE; break; } } } g_free (str); g_type_class_unref (enum_class); if (!result) parser->data = start; return result; }
static void thunar_column_model_load_column_order (ThunarColumnModel *column_model) { ThunarColumn column; GEnumClass *klass; GEnumValue *value; gchar **column_order; gchar *tmp; gint i, j; /* determine the column order from the preferences */ g_object_get (G_OBJECT (column_model->preferences), "last-details-view-column-order", &tmp, NULL); column_order = g_strsplit (tmp, ",", -1); g_free (tmp); /* reset the column order to its default */ for (j = 0; j < THUNAR_N_VISIBLE_COLUMNS; ++j) column_model->order[j] = j; /* now rearrange the columns according to the preferences */ klass = g_type_class_ref (THUNAR_TYPE_COLUMN); for (i = 0; column_order[i] != NULL; ++i) { /* determine the enum value for the name */ value = g_enum_get_value_by_name (klass, column_order[i]); if (G_UNLIKELY (value == NULL || value->value == i)) continue; /* find the current position of the value */ for (j = 0; j < THUNAR_N_VISIBLE_COLUMNS; ++j) if (column_model->order[j] == value->value) break; /* check if valid */ if (G_LIKELY (j < THUNAR_N_VISIBLE_COLUMNS)) { /* exchange the positions of i and j */ column = column_model->order[i]; column_model->order[i] = column_model->order[j]; column_model->order[j] = column; } } g_type_class_unref (klass); /* release the column order */ g_strfreev (column_order); }
GtkWidget *dt_clist_get_widget(int error_context, struct formfill *form, GByteArray *data, GCallback *activatefunc, gpointer funcdata) { GQTypeDisplayClass* klass = g_type_class_ref(form->dt_handler); GtkWidget *w = dt_generic_binary_get_widget(error_context, form, data, activatefunc, funcdata); GtkWidget *menu = dt_generic_binary_retrieve_menu_widget(w); GtkWidget *item, *s; s = gtk_hseparator_new(); gtk_widget_show(s); item = gtk_menu_item_new(); gtk_widget_show(item); gtk_container_add(GTK_CONTAINER(item), s); gtk_menu_append(GTK_MENU(menu), item); item = gtk_menu_item_new_with_label(_("Details...")); gtk_widget_show(item); gtk_object_set_data(GTK_OBJECT(w), "details", GTK_WIDGET(item)); g_signal_connect(item, "activate", G_CALLBACK(dt_clist_details_button_clicked), w); /* gtk_widget_set_sensitive(item, FALSE); */ gtk_menu_append(GTK_MENU(menu), item); /* PSt: FIXME: hardcoded sizes are BAD */ if (data) { DT_CLIST(klass)->dt_generic.show_entries(form, w, TRUE); gtk_widget_set_usize(w, -1, DT_CLIST_FULL_HEIGHT); } else { DT_CLIST(klass)->dt_generic.show_entries(form, w, FALSE); gtk_widget_set_usize(w, -1, DT_CLIST_EMPTY_HEIGHT); } g_type_class_unref(klass); return w; }
static gboolean gui_exit_after_callback (Gimp *gimp, gboolean force) { if (gimp->be_verbose) g_print ("EXIT: %s\n", G_STRFUNC); g_signal_handlers_disconnect_by_func (gimp->config, gui_show_help_button_notify, gimp); g_signal_handlers_disconnect_by_func (gimp->config, gui_user_manual_notify, gimp); g_signal_handlers_disconnect_by_func (gimp->config, gui_show_tooltips_notify, gimp); gimp_action_history_exit (gimp); g_object_unref (image_ui_manager); image_ui_manager = NULL; g_object_unref (ui_configurer); ui_configurer = NULL; /* exit the clipboard before shutting down the GUI because it runs * a whole lot of code paths. See bug #731389. */ g_signal_handlers_disconnect_by_func (gimp, G_CALLBACK (gui_global_buffer_changed), NULL); gimp_clipboard_exit (gimp); session_exit (gimp); menus_exit (gimp); actions_exit (gimp); gimp_render_exit (gimp); gimp_controllers_exit (gimp); gimp_devices_exit (gimp); dialogs_exit (gimp); themes_exit (gimp); g_type_class_unref (g_type_class_peek (GIMP_TYPE_COLOR_SELECT)); return FALSE; /* continue exiting */ }
static const gchar * gimp_pdb_enum_value_get_nick (GType enum_type, gint value) { GEnumClass *enum_class; GEnumValue *enum_value; const gchar *nick; enum_class = g_type_class_ref (enum_type); enum_value = g_enum_get_value (enum_class, value); nick = enum_value->value_nick; g_type_class_unref (enum_class); return nick; }
const gchar * gegl_operation_get_key (const gchar *operation_name, const gchar *key_name) { GType type; GObjectClass *klass; const gchar *ret = NULL; type = gegl_operation_gtype_from_name (operation_name); if (!type) { return NULL; } klass = g_type_class_ref (type); ret = gegl_operation_class_get_key (GEGL_OPERATION_CLASS (klass), key_name); g_type_class_unref (klass); return ret; }
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; }
static void set_next_gravity (ClutterActor *actor) { ClutterGravity gravity = gravities[gindex]; GEnumClass *eclass; GEnumValue *evalue; clutter_actor_move_anchor_point_from_gravity (actor, gravities[gindex]); eclass = g_type_class_ref (CLUTTER_TYPE_GRAVITY); evalue = g_enum_get_value (eclass, gravity); clutter_text_set_text (CLUTTER_TEXT (label), evalue->value_nick); g_type_class_unref (eclass); if (++gindex >= G_N_ELEMENTS (gravities)) gindex = 0; }
/** * atk_get_root: * * Gets the root accessible container for the current application. * * Returns: (transfer none): the root accessible container for the current * application **/ AtkObject* atk_get_root (void) { AtkUtilClass *klass = g_type_class_ref (ATK_TYPE_UTIL); AtkObject *retval; if (klass->get_root) { retval = klass->get_root (); } else { retval = NULL; } g_type_class_unref (klass); return retval; }
/** * atk_get_toolkit_version: * * Gets version string for the GUI toolkit implementing ATK for this application. * * Returns: version string for the GUI toolkit implementing ATK for this application **/ const gchar* atk_get_toolkit_version (void) { const gchar *retval; AtkUtilClass *klass = g_type_class_ref (ATK_TYPE_UTIL); if (klass->get_toolkit_version) { retval = klass->get_toolkit_version (); } else { retval = NULL; } g_type_class_unref (klass); return retval; }