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