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