void side_set_application_mode(int type) { GSettings *theme = g_settings_new("org.jetspace.desktop.session"); GdkDisplay *display; GdkScreen *screen; display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); mode = type; if(g_variant_get_boolean(g_settings_get_value(theme, "use-custom-theme"))) { GtkCssProvider *provider; provider = gtk_css_provider_new (); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gsize bytes, read; const gchar* t = g_strdup_printf( "%s%s",g_variant_get_string(g_settings_get_value(theme, "custom-theme-path"), NULL), "/side-session/gtk.css"); if(access(t, F_OK) != 0) { system("side-notifier --theme-not-found &"); return; } gtk_css_provider_load_from_path (provider,g_filename_to_utf8(t, strlen(t), &read, &bytes, NULL),NULL); g_object_unref (provider); } }
static void init_gsettings (void) { #ifdef HAVE_GSETTINGS GVariant *val; const gchar *const *schemas; int schema_found = 0; #if ! GLIB_CHECK_VERSION (2, 36, 0) g_type_init (); #endif schemas = g_settings_list_schemas (); if (schemas == NULL) return; while (! schema_found && *schemas != NULL) schema_found = strcmp (*schemas++, GSETTINGS_SCHEMA) == 0; if (!schema_found) return; gsettings_client = g_settings_new (GSETTINGS_SCHEMA); if (!gsettings_client) return; g_object_ref_sink (G_OBJECT (gsettings_client)); g_signal_connect (G_OBJECT (gsettings_client), "changed", G_CALLBACK (something_changed_gsettingsCB), NULL); val = g_settings_get_value (gsettings_client, GSETTINGS_TOOL_BAR_STYLE); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) current_tool_bar_style = map_tool_bar_style (g_variant_get_string (val, NULL)); g_variant_unref (val); } #ifdef HAVE_XFT val = g_settings_get_value (gsettings_client, GSETTINGS_MONO_FONT); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) current_mono_font = xstrdup (g_variant_get_string (val, NULL)); g_variant_unref (val); } val = g_settings_get_value (gsettings_client, GSETTINGS_FONT_NAME); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) current_font = xstrdup (g_variant_get_string (val, NULL)); g_variant_unref (val); } #endif /* HAVE_XFT */ #endif /* HAVE_GSETTINGS */ }
static void something_changed_gsettingsCB (GSettings *settings, gchar *key, gpointer user_data) { GVariant *val; if (strcmp (key, GSETTINGS_TOOL_BAR_STYLE) == 0) { val = g_settings_get_value (settings, GSETTINGS_TOOL_BAR_STYLE); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) { const gchar *newstyle = g_variant_get_string (val, NULL); store_tool_bar_style_changed (newstyle, first_dpyinfo); } g_variant_unref (val); } } #ifdef HAVE_XFT else if (strcmp (key, GSETTINGS_MONO_FONT) == 0) { val = g_settings_get_value (settings, GSETTINGS_MONO_FONT); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) { const gchar *newfont = g_variant_get_string (val, NULL); store_monospaced_changed (newfont); } g_variant_unref (val); } } else if (strcmp (key, GSETTINGS_FONT_NAME) == 0) { val = g_settings_get_value (settings, GSETTINGS_FONT_NAME); if (val) { g_variant_ref_sink (val); if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) { const gchar *newfont = g_variant_get_string (val, NULL); store_font_name_changed (newfont); } g_variant_unref (val); } } #endif /* HAVE_XFT */ }
//! //! @brief Adds a preference change listener for the selected key //! @param settings The GSettings object to act on You will have to get it yourself using lw_preferences_get_settings_object //! @param key The preference key //! @param callback_function The function to call when the key changes //! @param data The userdata to pass to the callback function //! @returns A gulong used to remove a signal later if desired //! gulong lw_preferences_add_change_listener (GSettings *settings, const char *key, void (*callback_function) (GSettings*, gchar*, gpointer), gpointer data) { g_assert (key != NULL); //Declarations char *signal_name; gulong id; GVariant *value; //Set up the signal signal_name = g_strdup_printf ("changed::%s", key); id = g_signal_connect (G_OBJECT (settings), signal_name, G_CALLBACK (callback_function), data); //Trigger an initial fire of the change listener value = g_settings_get_value (settings, key); if (value != NULL) g_settings_set_value (settings, key, value); //Cleanup g_variant_unref (value); value = NULL; g_free (signal_name); signal_name = NULL; return id; }
static void ide_preferences_spin_button_setting_changed (IdePreferencesSpinButton *self, const gchar *key, GSettings *settings) { GtkAdjustment *adj; GVariant *value; g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self)); g_assert (key != NULL); g_assert (G_IS_SETTINGS (settings)); if (self->updating) return; self->updating = TRUE; adj = gtk_spin_button_get_adjustment (self->spin_button); value = g_settings_get_value (settings, key); apply_value (adj, value, "value"); g_variant_unref (value); self->updating = FALSE; }
void gb_project_tree_actions_init (GbProjectTree *self) { g_autoptr(GSettings) settings = NULL; g_autoptr(GSettings) tree_settings = NULL; g_autoptr(GSimpleActionGroup) actions = NULL; g_autoptr(GAction) action = NULL; g_autoptr(GVariant) show_icons = NULL; actions = g_simple_action_group_new (); settings = g_settings_new ("org.gtk.Settings.FileChooser"); action = g_settings_create_action (settings, "sort-directories-first"); g_action_map_add_action (G_ACTION_MAP (actions), action); g_action_map_add_action_entries (G_ACTION_MAP (actions), GbProjectTreeActions, G_N_ELEMENTS (GbProjectTreeActions), self); gtk_widget_insert_action_group (GTK_WIDGET (self), "project-tree", G_ACTION_GROUP (actions)); tree_settings = g_settings_new ("org.gnome.builder.project-tree"); show_icons = g_settings_get_value (tree_settings, "show-icons"); action_set (G_ACTION_GROUP (actions), "show-icons", "state", show_icons, NULL); gb_project_tree_actions_update (self); }
void deja_dup_simple_settings_set_value (DejaDupSimpleSettings* self, const gchar* k, GVariant* v) { const gchar* _tmp0_; GVariant* _tmp1_ = NULL; GVariant* _tmp2_; GVariant* _tmp3_; gboolean _tmp4_ = FALSE; gboolean _tmp5_; g_return_if_fail (self != NULL); g_return_if_fail (k != NULL); g_return_if_fail (v != NULL); _tmp0_ = k; _tmp1_ = g_settings_get_value ((GSettings*) self, _tmp0_); _tmp2_ = _tmp1_; _tmp3_ = v; _tmp4_ = g_variant_equal (_tmp2_, _tmp3_); _tmp5_ = !_tmp4_; _g_variant_unref0 (_tmp2_); if (_tmp5_) { const gchar* _tmp6_; GVariant* _tmp7_; _tmp6_ = k; _tmp7_ = v; g_settings_set_value (G_SETTINGS (self), _tmp6_, _tmp7_); } }
static void set_calibration (gint *cal, gsize ncal, GSettings *settings) { GVariant *current; /* current calibration */ GVariant *array; /* new calibration */ GVariant **tmp; gsize nvalues; int i; current = g_settings_get_value (settings, "area"); g_variant_get_fixed_array (current, &nvalues, sizeof (gint32)); if ((ncal != 4) || (nvalues != 4)) { g_warning("Unable set set device calibration property. Got %"G_GSIZE_FORMAT" items to put in %"G_GSIZE_FORMAT" slots; expected %d items.\n", ncal, nvalues, 4); return; } tmp = g_malloc (nvalues * sizeof (GVariant*)); for (i = 0; i < ncal; i++) tmp[i] = g_variant_new_int32 (cal[i]); array = g_variant_new_array (G_VARIANT_TYPE_INT32, tmp, nvalues); g_settings_set_value (settings, "area", array); g_free (tmp); }
void cb_cpu_color_changed (GsmColorButton *cp, gpointer data) { guint cpu_i = GPOINTER_TO_UINT (data); auto settings = Gio::Settings::create (GSM_GSETTINGS_SCHEMA); /* Get current values */ GVariant *cpu_colors_var = g_settings_get_value (settings->gobj(), GSM_SETTING_CPU_COLORS); gsize children_n = g_variant_n_children(cpu_colors_var); /* Create builder to contruct new setting with updated value for cpu i */ GVariantBuilder builder; g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY); for (guint i = 0; i < children_n; i++) { if(cpu_i == i) { gchar *color; GdkRGBA button_color; gsm_color_button_get_color(cp, &button_color); color = gdk_rgba_to_string (&button_color); g_variant_builder_add(&builder, "(us)", i, color); g_free (color); } else { g_variant_builder_add_value(&builder, g_variant_get_child_value(cpu_colors_var, i)); } } /* Just set the value and let the changed::cpu-colors signal callback do the rest. */ settings->set_value (GSM_SETTING_CPU_COLORS, Glib::wrap (g_variant_builder_end(&builder))); }
static void calibrate_button_clicked_cb (GtkButton *button, CcWacomPage *page) { int i, calibration[4]; GVariant *variant; int *current; gsize ncal; gint monitor; monitor = gsd_wacom_device_get_display_monitor (page->priv->stylus); if (monitor < 0) { /* The display the tablet should be mapped to could not be located. * This shouldn't happen if the EDID data is good... */ g_critical("Output associated with the tablet is not connected. Unable to calibrate."); return; } variant = g_settings_get_value (page->priv->wacom_settings, "area"); current = (int *) g_variant_get_fixed_array (variant, &ncal, sizeof (gint32)); if (ncal != 4) { g_warning("Device calibration property has wrong length. Got %"G_GSIZE_FORMAT" items; expected %d.\n", ncal, 4); g_free (current); return; } for (i = 0; i < 4; i++) calibration[i] = current[i]; if (calibration[0] == -1 && calibration[1] == -1 && calibration[2] == -1 && calibration[3] == -1) { gint *device_cal; #ifdef FAKE_AREA GdkScreen *screen; screen = gdk_screen_get_default (); device_cal = g_new0 (int, 4); device_cal[0] = 0; device_cal[1] = gdk_screen_get_width (screen); device_cal[2] = 0; device_cal[3] = gdk_screen_get_height (screen); #else device_cal = gsd_wacom_device_get_area (page->priv->stylus); if (device_cal == NULL) { g_warning ("Failed to get device's area. " "Not running calibration."); return; } #endif /* FAKE_AREA */ for (i = 0; i < 4; i++) calibration[i] = device_cal[i]; g_free (device_cal); }
void cb_cpu_color_changed (GSMColorButton *cp, gpointer data) { guint cpu_i = GPOINTER_TO_UINT (data); GSettings *settings = g_settings_new (GSM_GSETTINGS_SCHEMA); /* Get current values */ GVariant *cpu_colors_var = g_settings_get_value(settings, "cpu-colors"); gsize children_n = g_variant_n_children(cpu_colors_var); /* Create builder to contruct new setting with updated value for cpu i */ GVariantBuilder builder; g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY); for (guint i = 0; i < children_n; i++) { if(cpu_i == i) { gchar color[24]; GdkColor button_color; gsm_color_button_get_color(cp, &button_color); g_snprintf(color, sizeof(color), "#%04x%04x%04x", button_color.red, button_color.green, button_color.blue); g_variant_builder_add(&builder, "(us)", i, color); } else { g_variant_builder_add_value(&builder, g_variant_get_child_value(cpu_colors_var, i)); } } /* Just set the value and let the changed::cpu-colors signal callback do the rest. */ g_settings_set_value(settings, "cpu-colors", g_variant_builder_end(&builder)); }
bool QGSettings::trySetValue(const QString &key, const QVariant &value) { Q_D(QGSettings); if (!d->valid) return false; gchar *keyName = Utils::fromCamelCase(key); // Since gio crashes when setting a key that doesn't exist, // we better check here and return false if (!keys().contains(key)) return false; bool result = false; // It might be hard to detect the right GVariant type from // complext QVariant types such as string lists or more detailed // types such as integers (GVariant has different sizes), // therefore we get the current value for the key and convert // to QVariant using the GVariant type GVariant *oldValue = g_settings_get_value(d->settings, keyName); GVariant *newValue = Utils::toGVariant(g_variant_get_type(oldValue), value); if (newValue) result = g_settings_set_value(d->settings, keyName, newValue); g_free(keyName); g_variant_unref(oldValue); return result; }
static void gb_color_picker_prefs_palette_row_activate (GbColorPickerPrefsPaletteRow *self) { g_autoptr (GVariant) value = NULL; g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self)); g_assert (self->target != NULL); if (!gtk_widget_get_sensitive (GTK_WIDGET (self)) || self->settings == NULL || self->updating) return; value = g_settings_get_value (self->settings, self->key); if (g_variant_is_of_type (value, g_variant_get_type (self->target))) { if (!g_variant_equal (value, self->target)) { self->updating = TRUE; g_settings_set_value (self->settings, self->key, self->target); gtk_widget_set_visible (GTK_WIDGET (self->image), TRUE); self->updating = FALSE; } } else g_warning ("Value and target must be of the same type"); }
static void gb_color_picker_prefs_palette_row_changed (GbColorPickerPrefsPaletteRow *self, const gchar *key, GSettings *settings) { g_autoptr (GVariant) value = NULL; gboolean active; g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self)); g_assert (key != NULL); g_assert (G_IS_SETTINGS (settings)); if (self->target == NULL) { gtk_widget_set_visible (GTK_WIDGET (self->image), FALSE); return; } if (self->updating == TRUE) return; value = g_settings_get_value (settings, key); if (g_variant_is_of_type (value, g_variant_get_type (self->target))) { active = (g_variant_equal (value, self->target)); gtk_widget_set_visible (GTK_WIDGET (self->image), active); } else g_warning ("Value and target must be of the same type"); }
static void pocketvox_setup_get_modules_grid(PocketvoxSetup *setup) { setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup, TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate); PocketvoxSetupPrivate *priv = setup->priv; GVariant *modules; GVariantIter *iter; gchar *key, *value; gboolean isapps; priv->listBox = gtk_list_box_new(); GtkWidget *ph_widget = gtk_label_new("Add your modules"); gtk_label_set_markup(GTK_LABEL(ph_widget), _("<b><b><big> ADD YOUR MODULES </big></b></b>")); gtk_widget_show(ph_widget); gtk_list_box_set_placeholder(GTK_LIST_BOX(priv->listBox),ph_widget); //only need to connect signals modules = g_settings_get_value(priv->settings, "list-apps"); //get the content of the GVariant g_variant_get(modules, "a(ssb)", &iter); //loop other all apps while(g_variant_iter_loop(iter, "(ssb)", &key, &value, &isapps)) { pocketvox_setup_add_module(setup, key, value, isapps); } g_variant_iter_free(iter); }
static void update_configuration (GtkTreeModel *model) { GtkTreeIter iter; gchar *type; gchar *id; GVariantBuilder builder; GVariant *old_sources; const gchar *old_current_type; const gchar *old_current_id; guint old_current_index; guint old_n_sources; guint index; old_sources = g_settings_get_value (input_sources_settings, KEY_INPUT_SOURCES); old_current_index = g_settings_get_uint (input_sources_settings, KEY_CURRENT_INPUT_SOURCE); old_n_sources = g_variant_n_children (old_sources); if (old_n_sources > 0 && old_current_index < old_n_sources) { g_variant_get_child (old_sources, old_current_index, "(&s&s)", &old_current_type, &old_current_id); } else { old_current_type = ""; old_current_id = ""; } g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(ss)")); index = 0; gtk_tree_model_get_iter_first (model, &iter); do { gtk_tree_model_get (model, &iter, TYPE_COLUMN, &type, ID_COLUMN, &id, -1); if (index != old_current_index && g_str_equal (type, old_current_type) && g_str_equal (id, old_current_id)) { g_settings_set_uint (input_sources_settings, KEY_CURRENT_INPUT_SOURCE, index); } g_variant_builder_add (&builder, "(ss)", type, id); g_free (type); g_free (id); index += 1; } while (gtk_tree_model_iter_next (model, &iter)); g_settings_set_value (input_sources_settings, KEY_INPUT_SOURCES, g_variant_builder_end (&builder)); g_settings_apply (input_sources_settings); g_variant_unref (old_sources); }
static void photos_main_window_init (PhotosMainWindow *self) { PhotosMainWindowPrivate *priv; GApplication *app; GVariant *variant; PhotosSearchContextState *state; gboolean maximized; const gint32 *position; const gint32 *size; gsize n_elements; self->priv = photos_main_window_get_instance_private (self); priv = self->priv; app = g_application_get_default (); state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app)); priv->settings = photos_settings_new (); variant = g_settings_get_value (priv->settings, "window-size"); size = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32)); if (n_elements == 2) gtk_window_set_default_size (GTK_WINDOW (self), size[0], size[1]); g_variant_unref (variant); variant = g_settings_get_value (priv->settings, "window-position"); position = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32)); if (n_elements == 2) gtk_window_move (GTK_WINDOW (self), position[0], position[1]); g_variant_unref (variant); maximized = g_settings_get_boolean (priv->settings, "window-maximized"); if (maximized) gtk_window_maximize (GTK_WINDOW (self)); priv->item_mngr = g_object_ref (state->item_mngr); priv->mode_cntrlr = photos_mode_controller_dup_singleton (); g_signal_connect_swapped (priv->mode_cntrlr, "fullscreen-changed", G_CALLBACK (photos_main_window_fullscreen_changed), self); priv->sel_cntrlr = photos_selection_controller_dup_singleton (); }
// Set the background // NOTE: The background is controlled by Qt because setting it as a CSS background is too slow void On::setWallpaper() { GSettings *backgroundSettings = g_settings_new("org.gnome.desktop.background"); QString bg = QUrl::fromEncoded(g_variant_get_string(g_settings_get_value(backgroundSettings, "picture-uri"), 0)).toString(); QPalette p = palette(); QRect rect = this->rect(); if (!bg.isEmpty()) { bg = bg.remove("file://"); QPixmap background(QFileInfo(bg).canonicalFilePath()); if (background.isNull()) { background = QPixmap("/usr/share/themes/Asturix/backgrounds/asturix4.jpg"); } QSize size(rect.width(), rect.height()); QPixmap pixmap(background.scaledToWidth(size.width(), Qt::SmoothTransformation)); //QPixmap pixmap(background.scaled(size, Qt::KeepAspectRatio)); //QPixmap pixmap(background.scaled(size)); p.setBrush(QPalette::Background, pixmap); // TODO: Modes. picture-options: zoom, fill, span, scale, center, tile } else { QColor primColor(g_variant_get_string(g_settings_get_value(backgroundSettings, "primary-color"), 0)); qDebug(g_variant_get_string(g_settings_get_value(backgroundSettings, "primary-color"), 0)); QColor secColor(g_variant_get_string(g_settings_get_value(backgroundSettings, "secondary-color"), 0)); QString mode = QString(g_variant_get_string(g_settings_get_value(backgroundSettings, "color-shading-type"), 0)); QBrush brush; if (mode == "solid") { brush = QBrush(primColor); } else if (mode == "vertical") { QLinearGradient grad(QPointF(0, 0), QPointF(0, rect.height())); grad.setColorAt(0, primColor); grad.setColorAt(1, secColor); brush = QBrush(grad); } else { QLinearGradient grad(QPointF(0, 0), QPointF(rect.width(), 0)); grad.setColorAt(0, primColor); grad.setColorAt(1, secColor); brush = QBrush(grad); } p.setBrush(QPalette::Background, brush); } setPalette(p); p.setBrush(QPalette::Base, Qt::transparent); page()->setPalette(p); setAttribute(Qt::WA_OpaquePaintEvent, false); g_object_unref(backgroundSettings); }
void ephy_web_application_initialize_settings (const char *profile_directory) { GSettings *settings; GSettings *web_app_settings; char *name; char *path; name = g_path_get_basename (profile_directory); settings = g_settings_new_with_path (EPHY_PREFS_WEB_SCHEMA, "/org/gnome/epiphany/web/"); path = g_build_path ("/", "/org/gnome/epiphany/web-apps/", name, "web/", NULL); web_app_settings = g_settings_new_with_path (EPHY_PREFS_WEB_SCHEMA, path); g_free (path); for (guint i = 0; i < G_N_ELEMENTS (ephy_prefs_web_schema); i++) { GVariant *value; value = g_settings_get_value (settings, ephy_prefs_web_schema[i]); g_settings_set_value (web_app_settings, ephy_prefs_web_schema[i], value); g_variant_unref (value); } g_object_unref (settings); g_object_unref (web_app_settings); settings = g_settings_new_with_path (EPHY_PREFS_STATE_SCHEMA, "/org/gnome/epiphany/state/"); path = g_build_path ("/", "/org/gnome/epiphany/web-apps/", name, "state/", NULL); web_app_settings = g_settings_new_with_path (EPHY_PREFS_STATE_SCHEMA, path); g_free (path); for (guint i = 0; i < G_N_ELEMENTS (ephy_prefs_state_schema); i++) { GVariant *value; value = g_settings_get_value (settings, ephy_prefs_state_schema[i]); g_settings_set_value (web_app_settings, ephy_prefs_state_schema[i], value); g_variant_unref (value); } g_object_unref (settings); g_object_unref (web_app_settings); g_free (name); }
static GWeatherLocation* get_default_location (GWeatherApplet *gw_applet) { const gchar *station_code; GVariant *default_loc; default_loc = g_settings_get_value (gw_applet->lib_settings, "default-location"); g_variant_get (default_loc, "(&s&sm(dd))", NULL, &station_code, NULL, NULL, NULL); return gweather_location_find_by_station_code (gweather_location_get_world (), station_code); }
static void conf_tray_settings_cb (GSettings *settings, guint cnxn_id, gchar *key, gpointer user_data) { GVariant *gv; if (key) { gv = g_settings_get_value (settings, key); if (gv && g_variant_get_type(gv) == G_VARIANT_TYPE_BOOLEAN) ui_tray_enable (g_settings_get_boolean (settings,key)); } }
static gboolean type_uint32 (GSettings *settings, const gchar *key) { const GVariantType *type; GVariant *value; value = g_settings_get_value (settings, key); type = g_variant_get_type (value); g_variant_unref (value); return g_variant_type_equal (type, G_VARIANT_TYPE_UINT32); }
static void gcal_application_changed_view (GSettings *settings, gchar *key, gpointer user_data) { GcalApplicationPrivate *priv; g_return_if_fail (GCAL_IS_APPLICATION (user_data)); priv = GCAL_APPLICATION (user_data)->priv; g_simple_action_set_state (priv->view, g_settings_get_value (priv->settings, "active-view")); }
static void gcal_application_set_app_menu (GApplication *app) { GcalApplicationPrivate *priv; GMenu *app_menu; GMenu *view_as; GSimpleAction *about; GSimpleAction *quit; g_return_if_fail (GCAL_IS_APPLICATION (app)); priv = GCAL_APPLICATION (app)->priv; app_menu = g_menu_new (); priv->view = g_simple_action_new_stateful ( "view", G_VARIANT_TYPE_STRING, g_settings_get_value (priv->settings, "active-view")); g_signal_connect (priv->view, "activate", G_CALLBACK (gcal_application_change_view), app); g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (priv->view)); view_as = g_menu_new (); g_menu_append (view_as, _("Weeks"), "app.view::week"); g_menu_append (view_as, _("Months"), "app.view::month"); g_menu_append_section (app_menu, _("View as"), G_MENU_MODEL (view_as)); about = g_simple_action_new ("about", NULL); g_signal_connect (about, "activate", G_CALLBACK (gcal_application_show_about), app); g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (about)); g_menu_append (app_menu, _("About"), "app.about"); quit = g_simple_action_new ("quit", NULL); g_signal_connect (quit, "activate", G_CALLBACK (gcal_application_quit), app); g_action_map_add_action ( G_ACTION_MAP (app), G_ACTION (quit)); g_menu_append (app_menu, _("Quit"), "app.quit"); gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (app_menu)); }
static void settings_changed (GSettings *settings, gchar *key, gpointer data) { GVariant *value; const GVariantType *type; MetaEnumPreference *cursor; gboolean found_enum; /* String array, handled separately */ if (strcmp (key, KEY_WORKSPACE_NAMES) == 0) { if (update_workspace_names ()); queue_changed (META_PREF_WORKSPACE_NAMES); return; } value = g_settings_get_value (settings, key); type = g_variant_get_type (value); if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) handle_preference_update_bool (settings, key); else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32)) handle_preference_update_int (settings, key); else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { cursor = preferences_enum; found_enum = FALSE; while (cursor->base.key != NULL) { if (strcmp (key, cursor->base.key) == 0) found_enum = TRUE; cursor++; } if (found_enum) handle_preference_update_enum (settings, key); else handle_preference_update_string (settings, key); } else /* Someone added a preference of an unhandled type */ g_assert_not_reached (); g_variant_unref (value); }
gchar * go_conf_get_value_as_str (GOConfNode *node, gchar const *key) { gchar *value_string; GVariant *value = NULL; if (node) { if (key && !strchr (key, '/') && !strchr (key, '.')) value = g_settings_get_value (node->settings, key); else if (node->key) value = g_settings_get_value (node->settings, node->key); } if (value == NULL) { GOConfNode *real_node = go_conf_get_node (node, key); value = real_node? g_settings_get_value (real_node->settings, real_node->key): NULL; go_conf_free_node (real_node); } switch (g_variant_classify (value)) { case 's': value_string = g_strdup (g_variant_get_string (value, NULL)); break; case 'i': value_string = g_strdup_printf ("%i", g_variant_get_int32 (value)); break; case 'd': value_string = g_strdup_printf ("%f", g_variant_get_double (value)); break; case 'b': value_string = g_strdup (go_locale_boolean_name (g_variant_get_boolean (value))); break; default: value_string = g_strdup ("ERROR FIXME"); break; } return value_string; }
GVariant * gnc_gsettings_get_value (const gchar *schema, const gchar *key) { GSettings *settings_ptr = gnc_gsettings_get_settings_ptr (schema); g_return_val_if_fail (G_IS_SETTINGS (settings_ptr), NULL); if (gnc_gsettings_is_valid_key (settings_ptr, key)) return g_settings_get_value (settings_ptr, key); else { PERR ("Invalid key %s for schema %s", key, schema); return NULL; } }
static void calibrate_button_clicked_cb (GtkButton *button, CcWacomPage *page) { int i, calibration[4]; GVariant *variant; int *current; gsize ncal; gint monitor; monitor = csd_wacom_device_get_display_monitor (page->priv->stylus); if (monitor < 0) { /* The display the tablet should be mapped to could not be located. * This shouldn't happen if the EDID data is good... */ g_critical("Output associated with the tablet is not connected. Unable to calibrate."); return; } variant = g_settings_get_value (page->priv->wacom_settings, "area"); current = (int *) g_variant_get_fixed_array (variant, &ncal, sizeof (gint32)); if (ncal != 4) { g_warning("Device calibration property has wrong length. Got %"G_GSIZE_FORMAT" items; expected %d.\n", ncal, 4); g_free (current); return; } for (i = 0; i < 4; i++) calibration[i] = current[i]; if (calibration[0] == -1 && calibration[1] == -1 && calibration[2] == -1 && calibration[3] == -1) { gint *device_cal; device_cal = csd_wacom_device_get_area (page->priv->stylus); for (i = 0; i < 4 && device_cal; i++) { calibration[i] = device_cal[i]; } g_free (device_cal); } run_calibration (page, calibration, monitor); gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE); }
void gt_player_open_channel(GtPlayer* self, GtChannel* chan) { gchar* status; gchar* name; gchar* display_name; gchar* token; gchar* sig; GtTwitchStreamData* stream_data; GVariant* default_quality; GtTwitchStreamQuality _default_quality; GAction* quality_action; GtWin* win; g_object_set(self, "open-channel", chan, NULL); g_object_get(chan, "display-name", &display_name, "name", &name, "status", &status, NULL); default_quality = g_settings_get_value(main_app->settings, "default-quality"); _default_quality = g_settings_get_enum(main_app->settings, "default-quality"); g_message("{GtPlayer} Opening channel '%s' with quality '%d'", name, _default_quality); win = GT_WIN(gtk_widget_get_toplevel(GTK_WIDGET(self))); quality_action = g_action_map_lookup_action(G_ACTION_MAP(win), "player_set_quality"); g_action_change_state(quality_action, default_quality); gt_twitch_stream_access_token(main_app->twitch, name, &token, &sig); stream_data = gt_twitch_stream_by_quality(main_app->twitch, name, _default_quality, token, sig); GT_PLAYER_GET_IFACE(self)->set_uri(self, stream_data->url); GT_PLAYER_GET_IFACE(self)->play(self); gt_twitch_stream_data_free(stream_data); g_free(name); g_free(status); g_free(token); g_free(sig); }
void InspectorClient::populateSetting(const String& key, String* value) { if (shouldIgnoreSetting(key)) return; GSettings* settings = inspectorGSettings(); if (!settings) return; PlatformRefPtr<GVariant> variant = adoptPlatformRef(g_settings_get_value(settings, toGSettingName(key).utf8().data())); if (key == "resourceTrackingEnabled" || key == "xhrMonitor" || key == "debuggerEnabled" || key == "profilerEnabled") *value = truthStringFromVariant(variant.get()); else if (key == "frontendSettings") *value = String(g_variant_get_string(variant.get(), 0)); }