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);
}
void
gsearchtool_get_stored_window_geometry (gint * width,
gint * height)
{
GSettings * settings;
gint saved_width;
gint saved_height;
if (width == NULL || height == NULL) {
return;
}
settings = g_settings_new ("org.mate.search-tool");
saved_width = g_settings_get_int (settings, "default-window-width");
saved_height = g_settings_get_int (settings, "default-window-height");
if (saved_width == -1) {
saved_width = DEFAULT_WINDOW_WIDTH;
}
if (saved_height == -1) {
saved_height = DEFAULT_WINDOW_HEIGHT;
}
*width = MAX (saved_width, MINIMUM_WINDOW_WIDTH);
*height = MAX (saved_height, MINIMUM_WINDOW_HEIGHT);
g_object_unref (settings);
}
static void
ide_editor_perspective_restore_panel_state (IdeEditorPerspective *self)
{
g_autoptr(GSettings) settings = NULL;
GtkWidget *pane;
gboolean reveal;
guint position;
g_assert (IDE_IS_EDITOR_PERSPECTIVE (self));
/* TODO: This belongs in editor settings probably */
settings = g_settings_new ("org.gnome.builder.workbench");
pane = dzl_dock_bin_get_left_edge (DZL_DOCK_BIN (self));
reveal = g_settings_get_boolean (settings, "left-visible");
position = g_settings_get_int (settings, "left-position");
dzl_dock_revealer_set_position (DZL_DOCK_REVEALER (pane), position);
set_reveal_child_without_transition (DZL_DOCK_REVEALER (pane), reveal);
pane = dzl_dock_bin_get_right_edge (DZL_DOCK_BIN (self));
position = g_settings_get_int (settings, "right-position");
dzl_dock_revealer_set_position (DZL_DOCK_REVEALER (pane), position);
set_reveal_child_without_transition (DZL_DOCK_REVEALER (pane), FALSE);
pane = dzl_dock_bin_get_bottom_edge (DZL_DOCK_BIN (self));
reveal = g_settings_get_boolean (settings, "bottom-visible");
position = g_settings_get_int (settings, "bottom-position");
dzl_dock_revealer_set_position (DZL_DOCK_REVEALER (pane), position);
set_reveal_child_without_transition (DZL_DOCK_REVEALER (pane), reveal);
}
static void
settings_changed_cb (GSettings *settings,
const char *key,
gpointer user_data)
{
if (strcmp (key, "animate") == 0) {
p.do_animate = g_settings_get_boolean (settings, "animate");
if (prefsbox == NULL)
return;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_animate),
p.do_animate);
} else if (strcmp (key, "sound") == 0) {
p.do_sound = g_settings_get_boolean (settings, "sound");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_sound),
p.do_sound);
} else if (strcmp (key, "key-left") == 0) {
p.keypress[MOVE_LEFT] = g_settings_get_int (settings, "key-left");
} else if (strcmp (key, "key-right") == 0) {
p.keypress[MOVE_RIGHT] = g_settings_get_int (settings, "key-right");
} else if (strcmp (key, "key-drop") == 0) {
p.keypress[MOVE_DROP] = g_settings_get_int (settings, "key-drop");
} else if (strcmp (key, "theme-id") == 0) {
gint val;
val = sane_theme_id (g_settings_get_int (settings, "theme-id"));
if (val != p.theme_id) {
p.theme_id = val;
if (!gfx_change_theme ())
return;
if (prefsbox == NULL)
return;
gtk_combo_box_set_active (GTK_COMBO_BOX (combobox_theme), p.theme_id);
}
}
}
static void
geometry_load (GtkWindow *window)
{
GSettings *ui_settings;
gboolean maximized;
gint x, y, w, h;
ui_settings = g_object_get_data (G_OBJECT (window), GEOMETRY_DATA_NAME);
maximized = g_settings_get_boolean (ui_settings, TWITUX_UI_WINDOW_MAXIMISED);
x = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_X_POS);
y = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_Y_POS);
w = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_WIDTH);
h = g_settings_get_int (ui_settings, TWITUX_UI_WINDOW_HEIGHT);
if ((x > 0) || (y > 0)){
gtk_window_move (window, x, y);
}
if ((w > 0) && (h > 0)){
gtk_window_resize (window, w, h);
}
if (maximized) {
gtk_window_maximize (window);
} else {
gtk_window_unmaximize (window);
}
}
static void
npw_druid_add_default_property (NPWDruid* druid)
{
gchar* s;
GSettings *settings;
gboolean flag;
gint i;
/* Add default base project directory */
g_hash_table_insert (druid->values, g_strdup (ANJUTA_PROJECT_DIRECTORY_PROPERTY), g_strdup (g_get_home_dir()));
/* Add user name */
g_hash_table_insert (druid->values, g_strdup (USER_NAME_PROPERTY), g_strdup (g_get_real_name()));
/* Add Email address */
/* FIXME: We need a default way for the mail */
s = anjuta_util_get_user_mail();
g_hash_table_insert (druid->values, g_strdup (EMAIL_ADDRESS_PROPERTY), s);
/* Add use-tabs property */
settings = g_settings_new (ANJUTA_PREF_SCHEMA_PREFIX IANJUTA_EDITOR_PREF_SCHEMA);
flag = g_settings_get_boolean (settings, IANJUTA_EDITOR_USE_TABS_KEY);
g_hash_table_insert (druid->values, g_strdup (USE_TABS_PROPERTY), g_strdup (flag ? "1" : "0"));
/* Add tab-width property */
i = g_settings_get_int (settings, IANJUTA_EDITOR_TAB_WIDTH_KEY);
g_hash_table_insert (druid->values, g_strdup (TAB_WIDTH_PROPERTY), g_strdup_printf("%d", i));
/* Add indent-width property */
i = g_settings_get_int (settings, IANJUTA_EDITOR_INDENT_WIDTH_KEY);
g_hash_table_insert (druid->values, g_strdup (INDENT_WIDTH_PROPERTY), g_strdup_printf("%d", i));
g_object_unref (settings);
}
int
main(int argc, char **argv)
{
MathEquation *equation;
int accuracy = 9, word_size = 64, base = 10;
gboolean show_tsep = FALSE, show_zeroes = FALSE;
DisplayFormat number_format;
MPAngleUnit angle_units;
ButtonMode button_mode;
gchar *source_currency, *target_currency;
g_type_init();
bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
/* Seed random number generator. */
srand48((long) time((time_t *) 0));
get_options(argc, argv);
settings = g_settings_new ("org.mate.calc");
accuracy = g_settings_get_int(settings, "accuracy");
word_size = g_settings_get_int(settings, "word-size");
base = g_settings_get_int(settings, "base");
show_tsep = g_settings_get_boolean(settings, "show-thousands");
show_zeroes = g_settings_get_boolean(settings, "show-zeroes");
number_format = g_settings_get_enum(settings, "number-format");
angle_units = g_settings_get_enum(settings, "angle-units");
button_mode = g_settings_get_enum(settings, "button-mode");
source_currency = g_settings_get_string(settings, "source-currency");
target_currency = g_settings_get_string(settings, "target-currency");
equation = math_equation_new();
math_equation_set_accuracy(equation, accuracy);
math_equation_set_word_size(equation, word_size);
math_equation_set_show_thousands_separators(equation, show_tsep);
math_equation_set_show_trailing_zeroes(equation, show_zeroes);
math_equation_set_number_format(equation, number_format);
math_equation_set_angle_units(equation, angle_units);
math_equation_set_source_currency(equation, source_currency);
math_equation_set_target_currency(equation, target_currency);
g_free(source_currency);
g_free(target_currency);
gtk_init(&argc, &argv);
window = math_window_new(equation);
g_signal_connect(G_OBJECT(window), "quit", G_CALLBACK(quit_cb), NULL);
math_buttons_set_programming_base(math_window_get_buttons(window), base);
math_buttons_set_mode(math_window_get_buttons(window), button_mode); // FIXME: We load the basic buttons even if we immediately switch to the next type
gtk_widget_show(GTK_WIDGET(window));
gtk_main();
return(0);
}
static void
gt_win_init(GtWin* self)
{
GtWinPrivate* priv = gt_win_get_instance_private(self);
GPropertyAction* action;
GT_TYPE_PLAYER; // Hack to load GtPlayer into the symbols table
GT_TYPE_PLAYER_HEADER_BAR;
GT_TYPE_BROWSE_HEADER_BAR;
GT_TYPE_CHANNELS_VIEW;
GT_TYPE_GAMES_VIEW;
GT_TYPE_FOLLOWS_VIEW;
GT_TYPE_CHAT;
gtk_window_set_application(GTK_WINDOW(self), GTK_APPLICATION(main_app));
gtk_widget_init_template(GTK_WIDGET(self));
gtk_widget_realize(priv->player_header_bar);
priv->cur_info_data = NULL;
priv->info_queue = g_queue_new();
gtk_window_set_default_size(GTK_WINDOW(self),
g_settings_get_int(main_app->settings, "window-width"),
g_settings_get_int(main_app->settings, "window-height"));
gtk_window_set_default_icon_name("gnome-twitch");
g_object_bind_property(priv->browse_stack, "visible-child",
self, "visible-view",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
GdkScreen* screen = gdk_screen_get_default();
GtkCssProvider* css = gtk_css_provider_new();
gtk_css_provider_load_from_resource(css, "/com/vinszent/GnomeTwitch/com.vinszent.GnomeTwitch.style.css");
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_signal_connect_after(self, "key-press-event", G_CALLBACK(key_press_cb), self);
g_signal_connect(self, "delete-event", G_CALLBACK(delete_cb), self);
g_signal_connect_after(priv->info_bar, "response", G_CALLBACK(close_info_bar_cb), self);
g_action_map_add_action_entries(G_ACTION_MAP(self),
win_actions,
G_N_ELEMENTS(win_actions),
self);
action = g_property_action_new("toggle_fullscreen", self, "fullscreen");
g_action_map_add_action(G_ACTION_MAP(self),
G_ACTION(action));
g_object_unref(action);
GtkWindowGroup* window_group = gtk_window_group_new();
gtk_window_group_add_window(window_group, GTK_WINDOW(self));
g_object_unref(window_group);
}
static gboolean
gth_image_saver_webp_save_image (GthImageSaver *base,
GthImage *image,
char **buffer,
gsize *buffer_size,
const char *mime_type,
GCancellable *cancellable,
GError **error)
{
GthImageSaverWebp *self = GTH_IMAGE_SAVER_WEBP (base);
cairo_surface_t *surface;
char **option_keys;
char **option_values;
int i = -1;
int i_value;
gboolean result;
option_keys = g_new (char *, 4);
option_values = g_new (char *, 4);
i++;
i_value = g_settings_get_boolean (self->priv->settings, PREF_WEBP_LOSSLESS);
option_keys[i] = g_strdup ("lossless");;
option_values[i] = g_strdup_printf ("%d", i_value);
i++;
i_value = g_settings_get_int (self->priv->settings, PREF_WEBP_QUALITY);
option_keys[i] = g_strdup ("quality");;
option_values[i] = g_strdup_printf ("%d", i_value);
i++;
i_value = g_settings_get_int (self->priv->settings, PREF_WEBP_METHOD);
option_keys[i] = g_strdup ("method");;
option_values[i] = g_strdup_printf ("%d", i_value);
i++;
option_keys[i] = NULL;
option_values[i] = NULL;
surface = gth_image_get_cairo_surface (image);
result = _cairo_surface_write_as_webp (surface,
buffer,
buffer_size,
option_keys,
option_values,
error);
cairo_surface_destroy (surface);
g_strfreev (option_keys);
g_strfreev (option_values);
return result;
}
/**
* gva_main_init:
*
* Initializes the main window.
*
* This function should be called once when the application starts.
**/
void
gva_main_init (void)
{
GSettings *settings;
gchar *text;
settings = gva_get_settings ();
gva_tree_view_init ();
gtk_box_pack_start (
GTK_BOX (GVA_WIDGET_MAIN_VBOX),
gva_ui_get_managed_widget ("/main-menu"),
FALSE, FALSE, 0);
gtk_box_reorder_child (
GTK_BOX (GVA_WIDGET_MAIN_VBOX),
gva_ui_get_managed_widget ("/main-menu"), 0);
gtk_widget_set_sensitive (
GVA_WIDGET_MAIN_MUTE_BUTTON,
gva_mame_supports_sound ());
g_settings_bind (
settings, GVA_SETTING_SOUND_MUTED,
GVA_WIDGET_MAIN_MUTE_BUTTON, "muted",
G_SETTINGS_BIND_DEFAULT);
gtk_window_move (
GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW),
g_settings_get_int (settings, "window-x"),
g_settings_get_int (settings, "window-y"));
gtk_window_resize (
GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW),
g_settings_get_int (settings, "window-width"),
g_settings_get_int (settings, "window-height"));
if (g_settings_get_boolean (settings, "window-maximized"))
gtk_window_maximize (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW));
/* Initialize the search entry. */
text = gva_main_get_last_search_text ();
gtk_entry_set_text (GTK_ENTRY (GVA_WIDGET_MAIN_SEARCH_ENTRY), text);
g_free (text);
gva_ui_lock ();
gtk_action_set_visible (GVA_ACTION_INSERT_FAVORITE, FALSE);
gtk_action_set_visible (GVA_ACTION_REMOVE_FAVORITE, FALSE);
gtk_window_present (GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW));
}
static void load_window_size(void)
{
if (g_settings_get_boolean(prefs_priv.settings, PREFS_KEY_WINDOW_MAX)) {
gtk_window_maximize(gui.window);
return;
}
int width = g_settings_get_int(prefs_priv.settings, PREFS_KEY_WINDOW_WIDTH);
int height = g_settings_get_int(prefs_priv.settings, PREFS_KEY_WINDOW_HEIGHT);
if ((width > 0) && (height > 0))
gtk_window_resize(gui.window, width, height);
}
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
pluma_prefs_manager_max_recents_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_MAX_RECENTS) == 0)
{
const GList *windows;
gint max;
max = g_settings_get_int (settings, key);
if (max < 0) {
max = GPM_DEFAULT_MAX_RECENTS;
}
windows = pluma_app_get_windows (pluma_app_get_default ());
while (windows != NULL)
{
PlumaWindow *w = windows->data;
gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (w->priv->toolbar_recent_menu),
max);
windows = g_list_next (windows);
}
/* FIXME: we have no way at the moment to trigger the
* update of the inline recents in the File menu */
}
}
static void
pluma_prefs_manager_undo_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_UNDO_ACTIONS_LIMIT) == 0)
{
gint ul;
GList *docs;
GList *l;
ul = g_settings_get_int (settings, key);
ul = CLAMP (ul, -1, 250);
docs = pluma_app_get_documents (pluma_app_get_default ());
l = docs;
while (l != NULL)
{
gtk_source_buffer_set_max_undo_levels (GTK_SOURCE_BUFFER (l->data),
ul);
l = l->next;
}
g_list_free (docs);
}
}
int
logview_prefs_get_stored_fontsize (LogviewPrefs *prefs)
{
g_assert (LOGVIEW_IS_PREFS (prefs));
return g_settings_get_int (prefs->priv->logview_prefs, PREF_FONTSIZE);
}
static void
settings_int_value_changed (GSettings *settings,
const gchar *key,
gint *save_location)
{
*save_location = g_settings_get_int (settings, key);
}
static gint32
config_get_activate_delay (gboolean *is_writable)
{
GSettings *settings;
gint32 delay;
settings = g_settings_new (GSETTINGS_SCHEMA);
if (is_writable)
{
*is_writable = g_settings_is_writable (settings,
KEY_ACTIVATE_DELAY);
}
delay = g_settings_get_int (settings, KEY_ACTIVATE_DELAY);
if (delay < 1)
{
delay = 1;
}
g_object_unref (settings);
return delay;
}
void
games_controls_list_add_control (GamesControlsList *list,
const char *conf_key,
const char *label,
guint default_keyval)
{
GtkTreeIter iter;
guint keyval;
g_return_if_fail (GAMES_IS_CONTROLS_LIST (list));
g_return_if_fail (conf_key != NULL);
if (!label)
label = _("Unknown Command");
keyval = g_settings_get_int (list->priv->settings, conf_key);
gtk_list_store_insert_with_values (list->priv->store, &iter, -1,
CONFKEY_COLUMN, conf_key,
LABEL_COLUMN, label,
KEYCODE_COLUMN, keyval,
KEYMODS_COLUMN, 0,
DEFAULT_KEYCODE_COLUMN, default_keyval,
DEFAULT_KEYMODS_COLUMN, 0,
-1);
}
gint gm_pref_store_get_int(GmPrefStore * store, const gchar * key)
{
gint value = 0;
if (store == NULL)
return value;
#if HAVE_GSETTINGS
value = g_settings_get_int(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_int(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_integer(store->keyfile, store->context, key, NULL);
#endif
#endif
return value;
}
static void
on_line_spacing_changed_cb (GbpLineSpacingBufferAddin *self,
const gchar *key,
GSettings *settings)
{
gint spacing;
g_assert (GBP_IS_LINE_SPACING_BUFFER_ADDIN (self));
g_assert (IDE_IS_BUFFER (self->buffer));
g_assert (G_IS_SETTINGS (settings));
if (self->tag != NULL)
{
GtkTextTagTable *table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (self->buffer));
gtk_text_tag_table_remove (table, self->tag);
self->tag = NULL;
}
spacing = g_settings_get_int (settings, "line-spacing");
if (spacing > 0)
{
self->tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (self->buffer), NULL,
"pixels-above-lines", spacing,
"pixels-below-lines", spacing,
NULL);
gbp_line_spacing_buffer_addin_apply (self);
}
}
static gchar *
get_proxy_ftp (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GString *string = NULL;
guint port;
GDesktopProxyMode proxy_mode;
g_autofree gchar *host = NULL;
proxy_mode = g_settings_get_enum (priv->settings, "mode");
if (proxy_mode != G_DESKTOP_PROXY_MODE_MANUAL)
return NULL;
host = g_settings_get_string (priv->settings_ftp, "host");
if (host == NULL)
return NULL;
port = g_settings_get_int (priv->settings_ftp, "port");
if (port == 0)
return NULL;
/* make PackageKit proxy string */
string = g_string_new (host);
if (port > 0)
g_string_append_printf (string, ":%i", port);
return g_string_free (string, FALSE);
}
static void
panel_properties_dialog_background_notify (GSettings *settings,
gchar *key,
PanelPropertiesDialog *dialog)
{
if (!strcmp (key, "type"))
{
PanelBackgroundType type = g_settings_get_enum (settings, key);
panel_properties_dialog_update_background_type (dialog, type);
}
else if (!strcmp (key, "color"))
{
char *color = g_settings_get_string (settings, key);
panel_properties_dialog_update_background_color (dialog, color);
g_free (color);
}
else if (!strcmp (key, "opacity"))
{
gint opacity = g_settings_get_int (settings, key);
panel_properties_dialog_update_background_opacity (dialog, opacity);
}
else if (!strcmp (key, "image"))
{
char *image = g_settings_get_string (settings, key);
panel_properties_dialog_update_background_image (dialog, image);
g_free (image);
}
}
gint
tracker_config_get_graphupdated_delay (TrackerConfig *config)
{
g_return_val_if_fail (TRACKER_IS_CONFIG (config), GRAPHUPDATED_DELAY_DEFAULT);
return g_settings_get_int (G_SETTINGS (config), "graphupdated-delay");
}
static void
scrollmethod_clicked_event (GtkWidget *widget,
GtkBuilder *dialog)
{
GtkToggleButton *disabled = GTK_TOGGLE_BUTTON (WID ("scroll_disabled_radio"));
gtk_widget_set_sensitive (WID ("horiz_scroll_toggle"),
!gtk_toggle_button_get_active (disabled));
gtk_widget_set_sensitive (WID ("natural_scroll_toggle"),
!gtk_toggle_button_get_active (disabled));
GSList *radio_group;
int new_scroll_method;
int old_scroll_method = g_settings_get_int (touchpad_settings, "scroll-method");
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)))
return;
radio_group = g_slist_copy (gtk_radio_button_get_group
(GTK_RADIO_BUTTON (WID ("scroll_disabled_radio"))));
radio_group = g_slist_reverse (radio_group);
new_scroll_method = g_slist_index (radio_group, widget);
g_slist_free (radio_group);
if (new_scroll_method != old_scroll_method)
g_settings_set_int (touchpad_settings, "scroll-method", new_scroll_method);
}
static void
create_playbin (GthMediaViewerPage *self)
{
GSettings *settings;
GstBus *bus;
if (self->priv->playbin != NULL)
return;
self->priv->playbin = gst_element_factory_make ("playbin", "playbin");
settings = g_settings_new (GTHUMB_GSTREAMER_TOOLS_SCHEMA);
g_object_set (self->priv->playbin,
"volume", (double) g_settings_get_int (settings, PREF_GSTREAMER_TOOLS_VOLUME) / 100.0,
"force-aspect-ratio", TRUE,
NULL);
g_object_unref (settings);
bus = gst_pipeline_get_bus (GST_PIPELINE (self->priv->playbin));
gst_bus_enable_sync_message_emission (bus);
gst_bus_set_sync_handler (bus, (GstBusSyncHandler) set_playbin_window, self, NULL);
gst_bus_add_signal_watch (bus);
g_signal_connect (self->priv->playbin,
"notify::volume",
G_CALLBACK (playbin_notify_volume_cb),
self);
g_signal_connect (bus,
"message",
G_CALLBACK (bus_message_cb),
self);
}
static void prefs_dialog_temperature_scale_changed(GtkComboBox *temperature_scale_combo_box,
PrefsDialog *prefs_dialog) {
/* get old temp scale value */
TemperatureScale scales[2];
GtkTreeModel *model;
scales[OLD_TEMP_SCALE] = (TemperatureScale) g_settings_get_int (prefs_dialog->sensors_applet->settings,
TEMPERATURE_SCALE);
scales[NEW_TEMP_SCALE] = (TemperatureScale)gtk_combo_box_get_active(temperature_scale_combo_box);
g_settings_set_int (prefs_dialog->sensors_applet->settings,
TEMPERATURE_SCALE,
scales[NEW_TEMP_SCALE]);
/* now go thru and convert all low and high sensor values in
* the tree to either celcius or Fahrenheit */
model = gtk_tree_view_get_model(prefs_dialog->view);
gtk_tree_model_foreach(model,
(GtkTreeModelForeachFunc)prefs_dialog_convert_low_and_high_values,
scales);
/* finally update display of active sensors */
sensors_applet_update_active_sensors(prefs_dialog->sensors_applet);
}
/**
* 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);
}
}
static gboolean
check_entry_grace_period (RhythmDB *db, RhythmDBEntry *entry)
{
GTimeVal time;
gulong last_seen;
gulong grace_period;
GError *error;
error = NULL;
grace_period = g_settings_get_int (db->priv->settings, "grace-period");
if (error != NULL) {
g_error_free (error);
return FALSE;
}
/* This is a bit silly, but I prefer to make sure we won't
* overflow in the following calculations
*/
if ((grace_period <= 0) || (grace_period > 20000)) {
return FALSE;
}
/* Convert from days to seconds */
grace_period = grace_period * 60 * 60 * 24;
g_get_current_time (&time);
last_seen = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_LAST_SEEN);
return (last_seen + grace_period < time.tv_sec);
}
/* Load options */
static void
load_options (void)
{
/* Find various dirs */
last_save_dir = g_settings_get_string (settings,
LAST_SAVE_DIRECTORY_KEY);
if (!last_save_dir || !last_save_dir[0])
{
last_save_dir = get_desktop_dir ();
}
else if (last_save_dir[0] == '~')
{
char *tmp = expand_initial_tilde (last_save_dir);
g_free (last_save_dir);
last_save_dir = tmp;
}
include_border = g_settings_get_boolean (settings,
INCLUDE_BORDER_KEY);
include_pointer = g_settings_get_boolean (settings,
INCLUDE_POINTER_KEY);
border_effect = g_settings_get_string (settings,
BORDER_EFFECT_KEY);
if (!border_effect)
border_effect = g_strdup ("none");
delay = g_settings_get_int (settings, DELAY_KEY);
}
static void
gsm_logout_dialog_set_timeout (GsmLogoutDialog *logout_dialog)
{
GSettings *settings;
settings = g_settings_new (SESSION_SCHEMA);
logout_dialog->priv->timeout = g_settings_get_int (settings, KEY_LOGOUT_TIMEOUT);
if (logout_dialog->priv->timeout > 0) {
/* Sets the secondary text */
gsm_logout_dialog_timeout (logout_dialog);
if (logout_dialog->priv->timeout_id != 0) {
g_source_remove (logout_dialog->priv->timeout_id);
}
logout_dialog->priv->timeout_id = g_timeout_add (1000,
gsm_logout_dialog_timeout,
logout_dialog);
}
else {
gtk_widget_hide (logout_dialog->priv->progressbar);
}
g_object_unref (settings);
}
