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