static void gsd_ldsm_get_config (void) { gchar **settings_list; free_percent_notify = g_settings_get_double (settings, SETTINGS_FREE_PC_NOTIFY_KEY); free_percent_notify_again = g_settings_get_double (settings, SETTINGS_FREE_PC_NOTIFY_AGAIN_KEY); free_size_gb_no_notify = g_settings_get_int (settings, SETTINGS_FREE_SIZE_NO_NOTIFY); min_notify_period = g_settings_get_int (settings, SETTINGS_MIN_NOTIFY_PERIOD); if (ignore_paths != NULL) { g_slist_foreach (ignore_paths, (GFunc) g_free, NULL); g_clear_pointer (&ignore_paths, g_slist_free); } settings_list = g_settings_get_strv (settings, SETTINGS_IGNORE_PATHS); if (settings_list != NULL) { guint i; for (i = 0; settings_list[i] != NULL; i++) ignore_paths = g_slist_prepend (ignore_paths, g_strdup (settings_list[i])); /* Make sure we dont leave stale entries in ldsm_notified_hash */ g_hash_table_foreach_remove (ldsm_notified_hash, ldsm_is_hash_item_in_ignore_paths, NULL); g_strfreev (settings_list); } purge_trash = g_settings_get_boolean (privacy_settings, SETTINGS_PURGE_TRASH); purge_temp_files = g_settings_get_boolean (privacy_settings, SETTINGS_PURGE_TEMP_FILES); purge_after = g_settings_get_uint (privacy_settings, SETTINGS_PURGE_AFTER); }
static void msd_ldsm_get_config () { gchar **settings_list; free_percent_notify = g_settings_get_double (settings, SETTINGS_FREE_PC_NOTIFY_KEY); if (free_percent_notify >= 1 || free_percent_notify < 0) { /* FIXME define min and max in gschema! */ g_warning ("Invalid configuration of free_percent_notify: %f\n" \ "Using sensible default", free_percent_notify); free_percent_notify = 0.05; } free_percent_notify_again = g_settings_get_double (settings, SETTINGS_FREE_PC_NOTIFY_AGAIN_KEY); if (free_percent_notify_again >= 1 || free_percent_notify_again < 0) { /* FIXME define min and max in gschema! */ g_warning ("Invalid configuration of free_percent_notify_again: %f\n" \ "Using sensible default\n", free_percent_notify_again); free_percent_notify_again = 0.01; } free_size_gb_no_notify = g_settings_get_int (settings, SETTINGS_FREE_SIZE_NO_NOTIFY); min_notify_period = g_settings_get_int (settings, SETTINGS_MIN_NOTIFY_PERIOD); if (ignore_paths != NULL) { g_slist_foreach (ignore_paths, (GFunc) g_free, NULL); g_slist_free (ignore_paths); ignore_paths = NULL; } settings_list = g_settings_get_strv (settings, SETTINGS_IGNORE_PATHS); if (settings_list != NULL) { guint i; for (i = 0; settings_list[i] != NULL; i++) { if (settings_list[i] != NULL) ignore_paths = g_slist_prepend (ignore_paths, g_strdup (settings_list[i])); } /* Make sure we dont leave stale entries in ldsm_notified_hash */ g_hash_table_foreach_remove (ldsm_notified_hash, ldsm_is_hash_item_in_ignore_paths, NULL); g_strfreev (settings_list); } }
static void garu_effects_equalizer_combo_box_changed (GtkComboBox *widget, GaruEffects *self) { GSList *l; gchar *band; int active, i; active = gtk_combo_box_get_active (widget); g_settings_set_int (self->settings,"equalizer-preset", active); equalizer_custom_selected = (active == G_N_ELEMENTS (eq_presets) - 1); equalizer_changed_by_combo_box = TRUE; for (l = self->eq_scales; l != NULL; l = l->next) { i = g_slist_position (self->eq_scales, l); /* If custom preset is activated */ if (equalizer_custom_selected) { band = g_strdup_printf ("eq-custom-band%d", i); gtk_range_set_value (GTK_RANGE (l->data), g_settings_get_double (self->settings, band)); g_free (band); } else { gtk_range_set_value (GTK_RANGE (l->data), eq_presets_values[active][i]); } } equalizer_changed_by_combo_box = FALSE; }
/** * gpm_settings_key_changed_cb: * * We might have to do things when the keys change; do them here. **/ static void gpm_settings_key_changed_cb (GSettings *settings, const gchar *key, GpmBacklight *backlight) { gboolean on_battery; /* get battery status */ g_object_get (backlight->priv->client, "on-battery", &on_battery, NULL); if (!on_battery && g_strcmp0 (key, GPM_SETTINGS_BRIGHTNESS_AC) == 0) { backlight->priv->master_percentage = g_settings_get_double (settings, key); gpm_backlight_brightness_evaluate_and_set (backlight, FALSE, TRUE); } else if (on_battery && g_strcmp0 (key, GPM_SETTINGS_BRIGHTNESS_DIM_BATT) == 0) { gpm_backlight_brightness_evaluate_and_set (backlight, FALSE, TRUE); } else if (g_strcmp0 (key, GPM_SETTINGS_IDLE_DIM_AC) == 0 || g_strcmp0 (key, GPM_SETTINGS_BACKLIGHT_ENABLE) == 0 || g_strcmp0 (key, GPM_SETTINGS_SLEEP_DISPLAY_BATT) == 0 || g_strcmp0 (key, GPM_SETTINGS_BACKLIGHT_BATTERY_REDUCE) == 0 || g_strcmp0 (key, GPM_SETTINGS_IDLE_BRIGHTNESS) == 0) { gpm_backlight_brightness_evaluate_and_set (backlight, FALSE, TRUE); } else if (g_strcmp0 (key, GPM_SETTINGS_IDLE_DIM_TIME) == 0) { backlight->priv->idle_dim_timeout = g_settings_get_int (settings, key); gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout); } else { egg_debug ("unknown key %s", key); } }
gfloat gm_pref_store_get_float(GmPrefStore * store, const gchar * key) { gfloat value = 0.0; if (store == NULL) return value; #if HAVE_GSETTINGS value = g_settings_get_double(store->settings, key); #else #ifdef HAVE_GCONF gchar *full_key; full_key = g_strdup_printf("/apps/%s/preferences/%s", store->context, key); value = gconf_client_get_float(store->gconf, full_key, NULL); g_free(full_key); #else if (g_key_file_has_key(store->keyfile, store->context, key, NULL)) value = g_key_file_get_double(store->keyfile, store->context, key, NULL); #endif #endif return value; }
static void fish_applet_settings_changed (GSettings *settings, char *key, FishApplet *fish) { char *value_str = NULL; gdouble value_double; gboolean value_boolean; /* key == NULL is a locak hack to mean all keys */ if (!key || g_strcmp0 (key, FISH_NAME_KEY) == 0) { value_str = g_settings_get_string (settings, FISH_NAME_KEY); fish_applet_update_name (fish, value_str); } if (!key || g_strcmp0 (key, FISH_IMAGE_KEY) == 0) { value_str = g_settings_get_string (settings, FISH_IMAGE_KEY); fish_applet_update_image (fish, value_str); } if (!key || g_strcmp0 (key, FISH_COMMAND_KEY) == 0) { value_str = g_settings_get_string (settings, FISH_COMMAND_KEY); fish_applet_update_command (fish, value_str); } if (!key || g_strcmp0 (key, FISH_SPEED_KEY) == 0) { value_double = g_settings_get_double (settings, FISH_SPEED_KEY); fish_applet_update_speed (fish, value_double); } if (!key || g_strcmp0 (key, FISH_ROTATE_KEY) == 0) { value_boolean = g_settings_get_boolean (settings, FISH_ROTATE_KEY); fish_applet_update_rotate (fish, value_boolean); } g_free (value_str); }
gdouble go_conf_get_double (GOConfNode *node, gchar const *key) { GOConfNode *real_node = go_conf_get_node (node, key); gdouble res = (real_node)? g_settings_get_double (real_node->settings, real_node->key): 0.; go_conf_free_node (real_node); return res; }
void ss__dlg_catalog_properties (GtkBuilder *builder, GthFileData *file_data, GthCatalog *catalog) { GtkWidget *slideshow_preferences; GtkWidget *label; if (! g_value_hash_is_set (catalog->attributes, "slideshow::personalize") || ! g_value_hash_get_boolean (catalog->attributes, "slideshow::personalize")) { GSettings *settings; char *current_transition; settings = g_settings_new (GTHUMB_SLIDESHOW_SCHEMA); current_transition = g_settings_get_string (settings, PREF_SLIDESHOW_TRANSITION); slideshow_preferences = gth_slideshow_preferences_new (current_transition, g_settings_get_boolean (settings, PREF_SLIDESHOW_AUTOMATIC), (int) (1000.0 * g_settings_get_double (settings, PREF_SLIDESHOW_CHANGE_DELAY)), g_settings_get_boolean (settings, PREF_SLIDESHOW_WRAP_AROUND), g_settings_get_boolean (settings, PREF_SLIDESHOW_RANDOM_ORDER)); gtk_widget_set_sensitive (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), "personalize_box"), FALSE); g_free (current_transition); g_object_unref (settings); } else { slideshow_preferences = gth_slideshow_preferences_new (g_value_hash_get_string (catalog->attributes, "slideshow::transition"), g_value_hash_get_boolean (catalog->attributes, "slideshow::automatic"), g_value_hash_get_int (catalog->attributes, "slideshow::delay"), g_value_hash_get_boolean (catalog->attributes, "slideshow::wrap-around"), g_value_hash_get_boolean (catalog->attributes, "slideshow::random-order")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), "personalize_checkbutton")), TRUE); gtk_widget_set_sensitive (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), "personalize_box"), TRUE); } if (g_value_hash_is_set (catalog->attributes, "slideshow::playlist")) gth_slideshow_preferences_set_audio (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), g_value_hash_get_stringv (catalog->attributes, "slideshow::playlist")); gtk_container_set_border_width (GTK_CONTAINER (slideshow_preferences), 12); gtk_widget_show (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), "personalize_checkbutton")); gtk_widget_hide (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), "slideshow_label")); gtk_widget_show (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), "playlist_box")); gtk_widget_show (slideshow_preferences); #ifndef HAVE_CLUTTER gtk_widget_hide (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (slideshow_preferences), "transition_box")); #endif /* ! HAVE_CLUTTER */ label = gtk_label_new (_("Slideshow")); gtk_widget_show (label); gtk_notebook_append_page (GTK_NOTEBOOK (_gtk_builder_get_widget (builder, "properties_notebook")), slideshow_preferences, label); g_object_set_data (G_OBJECT (builder), "slideshow_preferences", slideshow_preferences); }
MinbarConfig* config_read(void) { MinbarConfig* config = config_new(); config->city = g_settings_get_string(city, "name"); config->latitude = g_settings_get_double(city, "latitude"); config->longitude = g_settings_get_double(city, "longitude"); config->correction = g_settings_get_double(city, "correction"); config->method = g_settings_get_int(prefs, "method"); config->start_hidden = g_settings_get_boolean(prefs, "start-hidden"); config->close_closes = g_settings_get_boolean(prefs, "closes"); config->notification = g_settings_get_boolean(prefs, "notification"); config->notification_time = g_settings_get_int(prefs, "notification-time"); config->athan_enabled = g_settings_get_boolean(athan, "play"); config->athan_normal = g_settings_get_string(athan, "normal"); config->athan_subh = g_settings_get_string(athan, "subh"); return config; }
static void xhairs_opacity_notify_cb (GSettings *settings, gchar *key, GtkColorButton *button) { GdkRGBA rgba; gdouble opacity; opacity = g_settings_get_double (settings, key); gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &rgba); rgba.alpha = opacity * 65535; gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), &rgba); }
static void init_xhairs_color_opacity (GtkColorButton *color_button, GSettings *settings) { gchar *color_setting; GdkRGBA rgba; color_setting = g_settings_get_string (settings, "cross-hairs-color"); gdk_rgba_parse (&rgba, color_setting); rgba.alpha = g_settings_get_double (settings, "cross-hairs-opacity"); gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (color_button), &rgba); }
static void effects_slider_set_value (GtkRange *slider, GSettings *settings) { gchar **keys; gdouble red, green, blue; gdouble value; keys = g_object_get_data (G_OBJECT (slider), "settings-keys"); red = g_settings_get_double (settings, keys[0]); green = g_settings_get_double (settings, keys[1]); blue = g_settings_get_double (settings, keys[2]); if (red == green && green == blue) value = red; else /* use NTSC conversion weights for reasonable average */ value = 0.299 * red + 0.587 * green + 0.114 * blue; gtk_range_set_value (slider, value); }
gdouble gnc_gsettings_get_float (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), 0); if (gnc_gsettings_is_valid_key (settings_ptr, key)) return g_settings_get_double (settings_ptr, key); else { PERR ("Invalid key %s for schema %s", key, schema); return 0; } }
gdouble ug_settings_get_double (const gchar* key) { gdouble result = 0.0; GSettings* _tmp0_; GSettings* gsettings; const gchar* _tmp1_; gdouble _tmp2_ = 0.0; g_return_val_if_fail (key != NULL, 0.0); _tmp0_ = g_settings_new (UG_SETTINGS_SCHEMA); gsettings = _tmp0_; _tmp1_ = key; _tmp2_ = g_settings_get_double (gsettings, _tmp1_); result = _tmp2_; _g_object_unref0 (gsettings); return result; }
static void dialog_am_pm_to_button_clicked_cb (GtkButton *button, CcNightLightDialog *self) { gdouble value; value = g_settings_get_double (self->settings_display, "night-light-schedule-to"); if (value > 12.f) value -= 12.f; else value += 12.f; if (value >= 24.f) value = fmod (value, 24); g_settings_set_double (self->settings_display, "night-light-schedule-to", value); g_debug ("new value = %.3f", value); }
/* * The font rendering details dialog */ static void dpi_load (GSettings *settings, GtkSpinButton *spinner) { gdouble value = g_settings_get_double (settings, FONT_DPI_KEY); gdouble dpi; if (value != 0) dpi = value; else dpi = get_dpi_from_x_server (); if (dpi < DPI_LOW_REASONABLE_VALUE) dpi = DPI_LOW_REASONABLE_VALUE; in_change = TRUE; gtk_spin_button_set_value (spinner, dpi); in_change = FALSE; }
static void dialog_update_state (CcNightLightDialog *self) { gboolean automatic; gboolean disabled_until_tomorrow = FALSE; gboolean enabled; gdouble value = 0.f; g_autoptr(GDateTime) dt = g_date_time_new_now_local (); GtkToggleButton *toggle_button; /* only show the infobar if we are disabled */ if (self->proxy_color != NULL) { g_autoptr(GVariant) disabled = NULL; disabled = g_dbus_proxy_get_cached_property (self->proxy_color, "DisabledUntilTomorrow"); if (disabled != NULL) disabled_until_tomorrow = g_variant_get_boolean (disabled); } gtk_widget_set_visible (self->infobar_disabled, disabled_until_tomorrow); /* make things insensitive if the switch is disabled */ enabled = g_settings_get_boolean (self->settings_display, "night-light-enabled"); automatic = g_settings_get_boolean (self->settings_display, "night-light-schedule-automatic"); self->ignore_value_changed = TRUE; if (!enabled) toggle_button = GTK_TOGGLE_BUTTON (self->togglebutton_off); else if (automatic) toggle_button = GTK_TOGGLE_BUTTON (self->togglebutton_automatic); else toggle_button = GTK_TOGGLE_BUTTON (self->togglebutton_manual); gtk_toggle_button_set_active (toggle_button, TRUE); self->ignore_value_changed = FALSE; gtk_widget_set_sensitive (self->box_manual, enabled && !automatic); gtk_widget_set_sensitive (self->scale_color_temperature, enabled); /* Don't show the off button if it can't be turned off */ /* Don't allow choosing Manual or "Sunset to Sunrise" if it can't be turned on */ if (!g_settings_is_writable (self->settings_display, "night-light-enabled")) { gtk_widget_set_visible (self->togglebutton_off, !enabled); gtk_widget_set_sensitive (self->togglebutton_box, enabled); } else { gtk_widget_set_visible (self->togglebutton_off, TRUE); gtk_widget_set_sensitive (self->togglebutton_box, TRUE); } /* Don't show the Manual buttons if Manual can't be enabled. Same for "Sunset to Sunrise". */ if (!g_settings_is_writable (self->settings_display, "night-light-schedule-automatic")) { gtk_widget_set_visible (self->togglebutton_automatic, automatic); gtk_widget_set_visible (self->togglebutton_manual, !automatic); gtk_widget_set_visible (self->box_manual, !automatic); } else { gtk_widget_set_visible (self->togglebutton_automatic, TRUE); gtk_widget_set_visible (self->togglebutton_manual, TRUE); gtk_widget_set_visible (self->box_manual, TRUE); } /* set from */ if (automatic && self->proxy_color != NULL) { g_autoptr(GVariant) sunset = NULL; sunset = g_dbus_proxy_get_cached_property (self->proxy_color, "Sunset"); if (sunset != NULL) { value = g_variant_get_double (sunset); } else { value = 16.0f; g_warning ("no sunset data, using %02.2f", value); } } else { value = g_settings_get_double (self->settings_display, "night-light-schedule-from"); value = fmod (value, 24.f); } dialog_adjustments_set_frac_hours (self, value, self->adjustment_from_hours, self->adjustment_from_minutes, self->stack_from); /* set to */ if (automatic && self->proxy_color != NULL) { g_autoptr(GVariant) sunset = NULL; sunset = g_dbus_proxy_get_cached_property (self->proxy_color, "Sunrise"); if (sunset != NULL) { value = g_variant_get_double (sunset); } else { value = 8.0f; g_warning ("no sunrise data, using %02.2f", value); } } else { value = g_settings_get_double (self->settings_display, "night-light-schedule-to"); value = fmod (value, 24.f); } dialog_adjustments_set_frac_hours (self, value, self->adjustment_to_hours, self->adjustment_to_minutes, self->stack_to); self->ignore_value_changed = TRUE; value = (gdouble) g_settings_get_uint (self->settings_display, "night-light-temperature"); gtk_adjustment_set_value (self->adjustment_color_temperature, value); self->ignore_value_changed = FALSE; }
static GtkWidget * gth_file_tool_resize_get_options (GthFileTool *base) { GthFileToolResize *self = (GthFileToolResize *) base; cairo_surface_t *source; GtkWidget *window; GtkWidget *viewer_page; GtkWidget *viewer; GtkAllocation allocation; int preview_width; int preview_height; GtkWidget *options; char *text; source = gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self)); if (source == NULL) return NULL; self->priv->original_width = cairo_image_surface_get_width (source); self->priv->original_height = cairo_image_surface_get_height (source); window = gth_file_tool_get_window (base); viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window)); viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page)); gtk_widget_get_allocation (GTK_WIDGET (viewer), &allocation); preview_width = self->priv->original_width; preview_height = self->priv->original_height; if (scale_keeping_ratio (&preview_width, &preview_height, allocation.width, allocation.height, FALSE)) self->priv->preview = _cairo_image_surface_scale_fast (source, preview_width, preview_height); else self->priv->preview = cairo_surface_reference (source); _gtk_widget_get_screen_size (window, &self->priv->screen_width, &self->priv->screen_height); self->priv->new_image = NULL; self->priv->new_width = self->priv->original_width; self->priv->new_height = self->priv->original_height; self->priv->high_quality = g_settings_get_boolean (self->priv->settings, PREF_RESIZE_HIGH_QUALITY); self->priv->unit = g_settings_get_enum (self->priv->settings, PREF_RESIZE_UNIT); self->priv->builder = _gtk_builder_new_from_file ("resize-options.ui", "file_tools"); self->priv->apply_to_original = FALSE; update_dimensione_info_label (self, "original_dimensions_label", self->priv->original_width, self->priv->original_height, TRUE); options = _gtk_builder_get_widget (self->priv->builder, "options"); gtk_widget_show (options); if (self->priv->unit == GTH_UNIT_PIXELS) { gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), 0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), 0); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_WIDTH)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_HEIGHT)); } else if (self->priv->unit == GTH_UNIT_PERCENTAGE) { gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), 2); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), 2); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_width_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_WIDTH)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("resize_height_spinbutton")), g_settings_get_double (self->priv->settings, PREF_RESIZE_HEIGHT)); } gtk_combo_box_set_active (GTK_COMBO_BOX (GET_WIDGET ("unit_combobox")), self->priv->unit); self->priv->ratio_combobox = _gtk_combo_box_new_with_texts (_("None"), _("Square"), NULL); text = g_strdup_printf (_("%d x %d (Image)"), self->priv->original_width, self->priv->original_height); gtk_label_set_text (GTK_LABEL (GET_WIDGET ("image_size_label")), text); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), text); g_free (text); text = g_strdup_printf (_("%d x %d (Screen)"), self->priv->screen_width, self->priv->screen_height); gtk_label_set_text (GTK_LABEL (GET_WIDGET ("screen_size_label")), text); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), text); g_free (text); _gtk_combo_box_append_texts (GTK_COMBO_BOX_TEXT (self->priv->ratio_combobox), _("5:4"), _("4:3 (DVD, Book)"), _("7:5"), _("3:2 (Postcard)"), _("16:10"), _("16:9 (DVD)"), _("1.85:1"), _("2.39:1"), _("Custom"), NULL); gtk_widget_show (self->priv->ratio_combobox); gtk_box_pack_start (GTK_BOX (GET_WIDGET ("ratio_combobox_box")), self->priv->ratio_combobox, TRUE, TRUE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("high_quality_checkbutton")), self->priv->high_quality); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("invert_ratio_checkbutton")), g_settings_get_boolean (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_INVERT)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_w_spinbutton")), MAX (g_settings_get_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_WIDTH), 1)); gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("ratio_h_spinbutton")), MAX (g_settings_get_int (self->priv->settings, PREF_RESIZE_ASPECT_RATIO_HEIGHT), 1)); g_signal_connect_swapped (GET_WIDGET ("options_close_button"), "clicked", G_CALLBACK (gtk_widget_hide), GET_WIDGET ("options_dialog")); g_signal_connect (GET_WIDGET ("options_dialog"), "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (GET_WIDGET ("resize_width_spinbutton"), "value-changed", G_CALLBACK (selection_width_value_changed_cb), self); g_signal_connect (GET_WIDGET ("resize_height_spinbutton"), "value-changed", G_CALLBACK (selection_height_value_changed_cb), self); g_signal_connect (GET_WIDGET ("high_quality_checkbutton"), "toggled", G_CALLBACK (high_quality_checkbutton_toggled_cb), self); g_signal_connect (GET_WIDGET ("unit_combobox"), "changed", G_CALLBACK (unit_combobox_changed_cb), self); g_signal_connect (self->priv->ratio_combobox, "changed", G_CALLBACK (ratio_combobox_changed_cb), self); g_signal_connect (GET_WIDGET ("ratio_w_spinbutton"), "value_changed", G_CALLBACK (ratio_value_changed_cb), self); g_signal_connect (GET_WIDGET ("ratio_h_spinbutton"), "value_changed", G_CALLBACK (ratio_value_changed_cb), self); g_signal_connect (GET_WIDGET ("invert_ratio_checkbutton"), "toggled", G_CALLBACK (invert_ratio_changed_cb), self); g_signal_connect (GET_WIDGET ("image_size_button"), "clicked", G_CALLBACK (image_size_button_clicked_cb), self); g_signal_connect (GET_WIDGET ("screen_size_button"), "clicked", G_CALLBACK (screen_size_button_clicked_cb), self); gtk_combo_box_set_active (GTK_COMBO_BOX (self->priv->ratio_combobox), g_settings_get_enum (self->priv->settings, PREF_RESIZE_ASPECT_RATIO)); gth_image_viewer_set_zoom_quality (GTH_IMAGE_VIEWER (viewer), GTH_ZOOM_QUALITY_HIGH); return options; }
/** * gpm_backlight_init: * @brightness: This brightness class instance * * initialises the brightness class. NOTE: We expect laptop_panel objects * to *NOT* be removed or added during the session. * We only control the first laptop_panel object if there are more than one. **/ static void gpm_backlight_init (GpmBacklight *backlight) { backlight->priv = GPM_BACKLIGHT_GET_PRIVATE (backlight); /* record our idle time */ backlight->priv->idle_timer = g_timer_new (); /* watch for manual brightness changes (for the popup widget) */ backlight->priv->brightness = gpm_brightness_new (); g_signal_connect (backlight->priv->brightness, "brightness-changed", G_CALLBACK (brightness_changed_cb), backlight); /* we use up_client for the ac-adapter-changed signal */ backlight->priv->client = up_client_new (); g_signal_connect (backlight->priv->client, "changed", G_CALLBACK (gpm_backlight_client_changed_cb), backlight); /* gets caps */ backlight->priv->can_dim = gpm_brightness_has_hw (backlight->priv->brightness); /* watch for dim value changes */ backlight->priv->settings = g_settings_new (GPM_SETTINGS_SCHEMA); g_signal_connect (backlight->priv->settings, "changed", G_CALLBACK (gpm_settings_key_changed_cb), backlight); /* set the main brightness, this is designed to be updated if the user changes the * brightness so we can undim to the 'correct' value */ backlight->priv->master_percentage = g_settings_get_double (backlight->priv->settings, GPM_SETTINGS_BRIGHTNESS_AC); /* watch for brightness up and down buttons and also check lid state */ backlight->priv->button = gpm_button_new (); g_signal_connect (backlight->priv->button, "button-pressed", G_CALLBACK (gpm_backlight_button_pressed_cb), backlight); /* watch for idle mode changes */ backlight->priv->idle = gpm_idle_new (); g_signal_connect (backlight->priv->idle, "idle-changed", G_CALLBACK (idle_changed_cb), backlight); /* assumption */ backlight->priv->system_is_idle = FALSE; backlight->priv->idle_dim_timeout = g_settings_get_int (backlight->priv->settings, GPM_SETTINGS_IDLE_DIM_TIME); gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout); /* use a visual widget */ backlight->priv->popup = gsd_media_keys_window_new (); gsd_media_keys_window_set_action_custom (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup), "gpm-brightness-lcd", TRUE); gtk_window_set_position (GTK_WINDOW (backlight->priv->popup), GTK_WIN_POS_NONE); /* DPMS mode poll class */ backlight->priv->dpms = gpm_dpms_new (); /* we refresh DPMS on resume */ backlight->priv->control = gpm_control_new (); g_signal_connect (backlight->priv->control, "resume", G_CALLBACK (control_resume_cb), backlight); /* Don't do dimming on inactive console */ backlight->priv->consolekit = egg_console_kit_new (); /* sync at startup */ gpm_backlight_brightness_evaluate_and_set (backlight, FALSE, TRUE); }
static void text_scaling_factor_notify_cb (GSettings *settings, const gchar *key, CcUaPanel *panel) { CcUaPanelPrivate *priv = panel->priv; GtkTreeIter iter; GtkTreeModel *model; GtkWidget *combo; gboolean valid; gdouble conf_value; GtkTreeIter best; gdouble distance; if (!g_str_equal (key, "text-scaling-factor")) return; conf_value = g_settings_get_double (settings, key); combo = WID (priv->builder, "seeing_text_size_combobox"); model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo)); /* Recalculate the font sizes so that * their size is about constant when changing text size */ valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gfloat factor; gtk_tree_model_get (model, &iter, DPI_MODEL_FACTOR_COLUMN, &factor, -1); factor /= conf_value; gtk_list_store_set (GTK_LIST_STORE (model), &iter, DPI_MODEL_FACTOR_CALC_COLUMN, factor, -1); valid = gtk_tree_model_iter_next (model, &iter); } /* find the closest match in the combobox model */ distance = 1e6; valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gfloat factor; gdouble d; gtk_tree_model_get (model, &iter, DPI_MODEL_FACTOR_COLUMN, &factor, -1); d = fabs (conf_value - factor); if (d < distance) { best = iter; distance = d; } valid = gtk_tree_model_iter_next (model, &iter); } g_signal_handlers_block_by_func (combo, text_scaling_factor_combo_box_changed, panel); gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &best); g_signal_handlers_unblock_by_func (combo, text_scaling_factor_combo_box_changed, panel); }
void UpdateTextScaleFactor() { parent_->font_scaling = g_settings_get_double(ui_settings_, TEXT_SCALE_FACTOR.c_str()); decoration::Style::Get()->font_scale = parent_->font_scaling(); }
void UpdateCursorScaleFactor() { cursor_scale_ = g_settings_get_double(ui_settings_, CURSOR_SCALE_FACTOR.c_str()); }
Impl(Settings* owner) : parent_(owner) , usettings_(g_settings_new(SETTINGS_NAME.c_str())) , lim_settings_(g_settings_new(LIM_SETTINGS.c_str())) , ui_settings_(g_settings_new(UI_SETTINGS.c_str())) , ubuntu_ui_settings_(g_settings_new(UBUNTU_UI_SETTINGS.c_str())) , gnome_ui_settings_(g_settings_new(GNOME_UI_SETTINGS.c_str())) , launcher_widths_(monitors::MAX, DEFAULT_LAUNCHER_WIDTH) , cached_form_factor_(FormFactor::DESKTOP) , cursor_scale_(1.0) , cached_double_click_activate_(true) , changing_gnome_settings_(false) , lowGfx_(false) { parent_->form_factor.SetGetterFunction(sigc::mem_fun(this, &Impl::GetFormFactor)); parent_->form_factor.SetSetterFunction(sigc::mem_fun(this, &Impl::SetFormFactor)); parent_->double_click_activate.SetGetterFunction(sigc::mem_fun(this, &Impl::GetDoubleClickActivate)); for (unsigned i = 0; i < monitors::MAX; ++i) em_converters_.emplace_back(std::make_shared<EMConverter>()); CacheFormFactor(); CacheDoubleClickActivate(); // The order is important here, DPI is the last thing to be updated UpdateLimSetting(); UpdateTextScaleFactor(); UpdateCursorScaleFactor(); UpdateFontSize(); UpdateDPI(); UScreen::GetDefault()->changed.connect(sigc::hide(sigc::hide(sigc::mem_fun(this, &Impl::UpdateDPI)))); signals_.Add<void, GSettings*, const gchar*>(usettings_, "changed::" + FORM_FACTOR, [this] (GSettings*, const gchar*) { CacheFormFactor(); }); signals_.Add<void, GSettings*, const gchar*>(usettings_, "changed::" + DOUBLE_CLICK_ACTIVATE, [this] (GSettings*, const gchar*) { CacheDoubleClickActivate(); parent_->double_click_activate.changed.emit(cached_double_click_activate_); }); signals_.Add<void, GSettings*, const gchar*>(usettings_, "changed::" + LIM_KEY, [this] (GSettings*, const gchar*) { UpdateLimSetting(); }); signals_.Add<void, GSettings*, const gchar*>(ubuntu_ui_settings_, "changed::" + SCALE_FACTOR, [this] (GSettings*, const gchar* t) { UpdateDPI(); }); signals_.Add<void, GSettings*, const gchar*>(ui_settings_, "changed::" + TEXT_SCALE_FACTOR, [this] (GSettings*, const gchar* t) { UpdateTextScaleFactor(); UpdateDPI(); }); signals_.Add<void, GSettings*, const gchar*>(ui_settings_, "changed::" + CURSOR_SCALE_FACTOR, [this] (GSettings*, const gchar* t) { UpdateCursorScaleFactor(); UpdateDPI(); }); signals_.Add<void, GSettings*, const gchar*>(ui_settings_, "changed::" + APP_SCALE_MONITOR, [this] (GSettings*, const gchar* t) { UpdateDPI(); }); signals_.Add<void, GSettings*, const gchar*>(ui_settings_, "changed::" + APP_USE_MAX_SCALE, [this] (GSettings*, const gchar* t) { UpdateDPI(); }); signals_.Add<void, GSettings*, const gchar*>(gnome_ui_settings_, "changed::" + GNOME_FONT_NAME, [this] (GSettings*, const gchar* t) { UpdateFontSize(); UpdateDPI(); }); signals_.Add<void, GSettings*, const gchar*>(gnome_ui_settings_, "changed::" + GNOME_TEXT_SCALE_FACTOR, [this] (GSettings*, const gchar* t) { if (!changing_gnome_settings_) { double new_scale_factor = g_settings_get_double(gnome_ui_settings_, GNOME_TEXT_SCALE_FACTOR.c_str()); g_settings_set_double(ui_settings_, TEXT_SCALE_FACTOR.c_str(), new_scale_factor); } }); signals_.Add<void, GSettings*, const gchar*>(lim_settings_, "changed", [this] (GSettings*, const gchar*) { UpdateLimSetting(); }); }
void ss__dlg_preferences_construct_cb (GtkWidget *dialog, GthBrowser *browser, GtkBuilder *dialog_builder) { BrowserData *data; GtkWidget *notebook; char *current_transition; gboolean image_viewer_page_found; notebook = _gtk_builder_get_widget (dialog_builder, "notebook"); data = g_new0 (BrowserData, 1); data->settings = g_settings_new (GTHUMB_SLIDESHOW_SCHEMA); current_transition = g_settings_get_string (data->settings, PREF_SLIDESHOW_TRANSITION); data->preferences_page = gth_slideshow_preferences_new (current_transition, g_settings_get_boolean (data->settings, PREF_SLIDESHOW_AUTOMATIC), (int) (1000.0 * g_settings_get_double (data->settings, PREF_SLIDESHOW_CHANGE_DELAY)), g_settings_get_boolean (data->settings, PREF_SLIDESHOW_WRAP_AROUND), g_settings_get_boolean (data->settings, PREF_SLIDESHOW_RANDOM_ORDER)); gtk_widget_show (data->preferences_page); g_free (current_transition); #ifndef HAVE_CLUTTER gtk_widget_hide (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (data->preferences_page), "transition_box")); #endif /* ! HAVE_CLUTTER */ g_signal_connect (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (data->preferences_page), "transition_combobox"), "changed", G_CALLBACK (transition_combobox_changed_cb), data); g_signal_connect (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (data->preferences_page), "automatic_checkbutton"), "toggled", G_CALLBACK (automatic_checkbutton_toggled_cb), data); g_signal_connect (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (data->preferences_page), "wrap_around_checkbutton"), "toggled", G_CALLBACK (wrap_around_checkbutton_toggled_cb), data); g_signal_connect (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (data->preferences_page), "random_order_checkbutton"), "toggled", G_CALLBACK (random_order_checkbutton_toggled_cb), data); g_signal_connect (gth_slideshow_preferences_get_widget (GTH_SLIDESHOW_PREFERENCES (data->preferences_page), "change_delay_spinbutton"), "value-changed", G_CALLBACK (change_delay_spinbutton_value_changed_cb), data); image_viewer_page_found = FALSE; if (gth_main_extension_is_active ("image_viewer")) { GList *children; GList *scan; children = gtk_container_get_children (GTK_CONTAINER (gtk_builder_get_object (dialog_builder, "notebook"))); for (scan = children; scan; scan = scan->next) { GtkWidget *page = scan->data; if (g_strcmp0 (g_object_get_data (G_OBJECT (page), "extension-name"), "image_viewer") == 0) { image_viewer_page_found = TRUE; gtk_widget_set_vexpand (data->preferences_page, FALSE); gtk_box_pack_start (GTK_BOX (page), data->preferences_page, FALSE, FALSE, 0); } } } if (! image_viewer_page_found) { /* add the preferences in an ad-hoc page */ GtkWidget *label; label = gtk_label_new (_("Slideshow")); gtk_widget_show (label); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), data->preferences_page, label); } g_object_set_data_full (G_OBJECT (dialog), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free); }
void gmpv_mpv_obj_initialize(GmpvMpvObj *mpv) { GSettings *main_settings = g_settings_new(CONFIG_ROOT); gchar *config_dir = get_config_dir_path(); gchar *mpvopt = NULL; gchar *current_vo = NULL; gchar *mpv_version = NULL; const struct { const gchar *name; const gchar *value; } options[] = { {"osd-level", "1"}, {"softvol", "yes"}, {"force-window", "yes"}, {"input-default-bindings", "yes"}, {"audio-client-name", ICON_NAME}, {"title", "${media-title}"}, {"autofit-larger", "75%"}, {"window-scale", "1"}, {"pause", "no"}, {"ytdl", "yes"}, {"osd-bar", "no"}, {"input-cursor", "no"}, {"cursor-autohide", "no"}, {"softvol-max", "100"}, {"config", "yes"}, {"screenshot-template", "gnome-mpv-shot%n"}, {"config-dir", config_dir}, {NULL, NULL} }; g_assert(mpv->mpv_ctx); for(gint i = 0; options[i].name; i++) { g_debug( "Applying default option --%s=%s", options[i].name, options[i].value ); mpv_set_option_string( mpv->mpv_ctx, options[i].name, options[i].value ); } if(g_settings_get_boolean(main_settings, "mpv-config-enable")) { gchar *mpv_conf = g_settings_get_string (main_settings, "mpv-config-file"); g_info("Loading config file: %s", mpv_conf); mpv_load_config_file(mpv->mpv_ctx, mpv_conf); g_free(mpv_conf); } if(g_settings_get_boolean(main_settings, "mpv-input-config-enable")) { gchar *input_conf = g_settings_get_string (main_settings, "mpv-input-config-file"); g_info("Loading input config file: %s", input_conf); load_input_conf(mpv, input_conf); g_free(input_conf); } else { load_input_conf(mpv, NULL); } mpvopt = g_settings_get_string(main_settings, "mpv-options"); g_debug("Applying extra mpv options: %s", mpvopt); /* Apply extra options */ if(mpv_obj_apply_args(mpv->mpv_ctx, mpvopt) < 0) { const gchar *msg = _("Failed to apply one or more MPV options."); g_signal_emit_by_name(mpv, "mpv-error", msg); } if(mpv->force_opengl) { g_info("Forcing --vo=opengl-cb"); mpv_set_option_string(mpv->mpv_ctx, "vo", "opengl-cb"); } else { g_debug( "Attaching mpv window to wid %#x", (guint)mpv->wid ); mpv_set_option(mpv->mpv_ctx, "wid", MPV_FORMAT_INT64, &mpv->wid); } mpv_observe_property(mpv->mpv_ctx, 0, "aid", MPV_FORMAT_INT64); mpv_observe_property(mpv->mpv_ctx, 0, "chapters", MPV_FORMAT_INT64); mpv_observe_property(mpv->mpv_ctx, 0, "core-idle", MPV_FORMAT_FLAG); mpv_observe_property(mpv->mpv_ctx, 0, "fullscreen", MPV_FORMAT_FLAG); mpv_observe_property(mpv->mpv_ctx, 0, "pause", MPV_FORMAT_FLAG); mpv_observe_property(mpv->mpv_ctx, 0, "length", MPV_FORMAT_DOUBLE); mpv_observe_property(mpv->mpv_ctx, 0, "media-title", MPV_FORMAT_STRING); mpv_observe_property(mpv->mpv_ctx, 0, "playlist-pos", MPV_FORMAT_INT64); mpv_observe_property(mpv->mpv_ctx, 0, "track-list", MPV_FORMAT_NODE); mpv_observe_property(mpv->mpv_ctx, 0, "volume", MPV_FORMAT_DOUBLE); mpv_set_wakeup_callback(mpv->mpv_ctx, wakeup_callback, mpv); mpv_check_error(mpv_initialize(mpv->mpv_ctx)); mpv_version = gmpv_mpv_obj_get_property_string(mpv, "mpv-version"); current_vo = gmpv_mpv_obj_get_property_string(mpv, "current-vo"); g_info("Using %s", mpv_version); if(current_vo && !GDK_IS_X11_DISPLAY(gdk_display_get_default())) { g_info( "The chosen vo is %s but the display is not X11; " "forcing --vo=opengl-cb and resetting", current_vo ); mpv->force_opengl = TRUE; mpv->state.paused = FALSE; gmpv_mpv_obj_reset(mpv); } else { GSettings *win_settings; gdouble volume; win_settings = g_settings_new(CONFIG_WIN_STATE); volume = g_settings_get_double(win_settings, "volume")*100; g_debug("Setting volume to %f", volume); mpv_set_property( mpv->mpv_ctx, "volume", MPV_FORMAT_DOUBLE, &volume ); /* The vo should be opengl-cb if current_vo is NULL*/ if(!current_vo) { mpv->opengl_ctx = mpv_get_sub_api ( mpv->mpv_ctx, MPV_SUB_API_OPENGL_CB ); } gmpv_mpv_opt_handle_msg_level(mpv); gmpv_mpv_opt_handle_fs(mpv); gmpv_mpv_opt_handle_geometry(mpv); mpv->force_opengl = FALSE; mpv->state.ready = TRUE; g_signal_emit_by_name(mpv, "mpv-init"); g_clear_object(&win_settings); } g_clear_object(&main_settings); g_free(config_dir); g_free(mpvopt); mpv_free(current_vo); mpv_free(mpv_version); }