void
calendar_config_set_tag_vpane_pos (float vpane_pos)
{
calendar_config_init ();
gconf_client_set_float (config, CALENDAR_CONFIG_TAG_VPANE_POS, vpane_pos, NULL);
}
NS_IMETHODIMP
nsGConfService::SetFloat(const nsACString &aKey, float aValue)
{
PRBool res = gconf_client_set_float(mClient, PromiseFlatCString(aKey).get(),
aValue, nsnull);
return res ? NS_OK : NS_ERROR_FAILURE;
}
static gboolean increase_step(CPU_plug_data **p)
{
CPU_plug_data *data = *p;
data->size_mult = data->size_mult * 1.2;
data->max_width_left = -1;
gconf_client_set_float(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, data->size_mult, NULL);
return TRUE;
}
static gboolean increase_step(Uptime_plug_data **p)
{
Uptime_plug_data *data = *p;
data->size_mult = data->size_mult * 1.2;
gconf_client_set_float(get_dashboard_gconf(), GCONF_UPTIME_SIZE_MULT, data->size_mult, NULL);
data->forceupdate = TRUE;
return TRUE;
}
void
confsection_t::set_float(const char *name, float value)
{
string_var key = make_key(name);
#if HAVE_LIBGCONF
GError *e = 0;
gconf_client_set_float(gconf_client_get_default(), key, value, &e);
handle_error(secname_, e);
#else
gnome_config_set_float(key.data(), value);
#endif
}
void
eel_gconf_set_float (const char *key,
gfloat float_value)
{
GConfClient *client;
GError *error = NULL;
g_return_if_fail (key != NULL);
client = eel_gconf_client_get_global ();
g_return_if_fail (client != NULL);
gconf_client_set_float (client, key, float_value, &error);
eel_gconf_handle_error (&error);
}
/* Callback invoked when slider #band changes value. Updates gconf value */
static void update_band_cb(GtkRange *range, gpointer band)
{
gchar *key;
gdouble value;
if (!confclient) {
confclient = gconf_client_get_default();
}
key = g_strdup_printf("%s%d", GCONF_MAFW_GST_EQ_RENDERER "/band",
GPOINTER_TO_INT(band));
value = gtk_range_get_value(range);
gconf_client_set_float(confclient, key, value, NULL);
g_free(key);
}
/**
* Gets the border width
*/
gfloat cpumeter_gconf_get_border_width(GConfClient* client)
{
gfloat width;
GConfValue *value = gconf_client_get(client, GCONF_BORDER_WIDTH, NULL);
if (value)
{
width = gconf_client_get_float(client, GCONF_BORDER_WIDTH, NULL);
}
else
{
width = GCONF_DEFAULT_BORDER_WIDTH;
gconf_client_set_float(client, GCONF_BORDER_WIDTH, GCONF_DEFAULT_BORDER_WIDTH, NULL);
}
return width;
}
static void
dpi_value_changed (GtkSpinButton *spinner,
GConfClient *client)
{
/* Like any time when using a spin button with GConf, there is
* a race condition here. When we change, we send the new
* value to GConf, then restore to the old value until
* we get a response to emulate the proper model/view behavior.
*
* If the user changes the value faster than responses are
* received from GConf, this may cause mildly strange effects.
*/
gdouble new_dpi = gtk_spin_button_get_value (spinner);
gconf_client_set_float (client, FONT_DPI_KEY, new_dpi, NULL);
dpi_load (client, spinner);
}
/**
* panel_applet_gconf_set_float:
* @applet: a #PanelApplet.
* @key: a GConf key name.
* @the_float: new value for @key.
* @error: a #GError, or %NULL.
*
* Convenience wrapper around gconf_client_set_float() to update @key in the
* per-instance GConf directory of @applet.
*
* Deprecated: 3.0: Use #GSettings to store per-instance settings.
**/
void
panel_applet_gconf_set_float (PanelApplet *applet,
const gchar *key,
gdouble the_float,
GError **error)
{
GConfClient *client;
gchar *full_key;
g_return_if_fail (PANEL_IS_APPLET (applet));
full_key = panel_applet_gconf_get_full_key (applet, key);
client = panel_applet_gconf_get_client ();
gconf_client_set_float (client, full_key, the_float, error);
g_free (full_key);
}
void
gnc_gconf_set_float (const gchar *section,
const gchar *name,
const gdouble value,
GError **caller_error)
{
GError *error = NULL;
gchar *key;
if (our_client == NULL)
our_client = gconf_client_get_default();
/* Remember whether the column width */
key = gnc_gconf_make_key(section, name);
if (!gconf_client_set_float(our_client, key, value, &error))
{
gnc_gconf_save_error(key, caller_error, error);
}
g_free(key);
}
void gm_pref_store_set_float(GmPrefStore * store, const gchar * key, gfloat value)
{
if (store == NULL)
return;
#if HAVE_GSETTINGS
g_settings_set_double(store->settings, key, value);
#else
#ifdef HAVE_GCONF
gchar *full_key;
full_key = g_strdup_printf("/apps/%s/preferences/%s", store->context, key);
gconf_client_set_float(store->gconf, full_key, value, NULL);
g_free(full_key);
#else
g_key_file_set_double(store->keyfile, store->context, key, value);
#endif
#endif
}
/* Load preset values into gconf */
static void preset_load(xmlDoc *preset)
{
xmlNode *root_node;
xmlNode *current_node;
xmlChar *band_number;
xmlChar *value_text;
gdouble value;
gchar *key;
g_return_if_fail(preset != NULL);
if (!confclient) {
confclient = gconf_client_get_default();
}
root_node = xmlDocGetRootElement(preset);
current_node = root_node->children;
while (current_node) {
if (xmlStrcmp(current_node->name,
BAD_CAST XML_NODE_BAND) == 0) {
band_number = xmlGetProp(current_node,
BAD_CAST XML_PROP_BAND_NUMBER);
if (band_number) {
key = g_strconcat(GCONF_MAFW_GST_EQ_RENDERER,
"/band",
band_number,
NULL);
value_text = xmlNodeGetContent(current_node);
value = atof((char *) value_text);
gconf_client_set_float(confclient, key,
value, NULL);
g_free(key);
g_free(band_number);
xmlFree(value_text);
}
}
current_node = current_node->next;
}
}
static void construct(CPU_plug_data **p)
{
GConfValue *value;
*p = g_malloc(sizeof(CPU_plug_data));
CPU_plug_data * data = *p;
gchar * svalue;
data->max_width_left = -1;
data->max_width_right = -1;
data->timer = 100;
data->user = 0;
data->sys = 0;
data->idle = 100;
data->iowait = 0;
data->emotive_text = FALSE;
svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_BG, NULL);
if (!svalue)
{
gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_BG, svalue = g_strdup("999999ee"), NULL);
}
awn_cairo_string_to_color(svalue, &data->bg);
g_free(svalue);
svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_FG, NULL);
if (!svalue)
{
gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_FG, svalue = g_strdup("000000ff"), NULL);
}
awn_cairo_string_to_color(svalue, &data->fg);
g_free(svalue);
value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, NULL);
if (value)
{
data->size_mult = gconf_client_get_float(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, NULL);
}
else
{
data->size_mult = 1.72;
gconf_client_set_float(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, data->size_mult, NULL);
}
value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_REFRESH, NULL);
if (value)
{
data->refresh = gconf_client_get_int(get_dashboard_gconf(), GCONF_CPU_REFRESH, NULL);
}
else
{
data->refresh = 500;
set_refresh(*p, data->refresh);
}
value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_METER, NULL);
if (value)
{
data->shiny_graphs = gconf_client_get_bool(get_dashboard_gconf(), GCONF_CPU_METER, NULL);
}
else
{
data->shiny_graphs = TRUE;
gconf_client_set_bool(get_dashboard_gconf(), GCONF_CPU_METER,
data->shiny_graphs, NULL);
}
value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_METER_USE_2_COLOUR_GRADIENT , NULL);
if (value)
{
data->two_colour_gradient = gconf_client_get_bool(get_dashboard_gconf(), GCONF_CPU_METER_USE_2_COLOUR_GRADIENT , NULL);
}
else
{
data->two_colour_gradient = FALSE;
gconf_client_set_bool(get_dashboard_gconf(), GCONF_CPU_METER_USE_2_COLOUR_GRADIENT, data->two_colour_gradient, NULL);
}
svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_START_COLOUR, NULL);
if (!svalue)
{
gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_START_COLOUR, svalue = g_strdup("00FF10bb"), NULL);
}
awn_cairo_string_to_color(svalue, &data->colour_meter_start);
g_free(svalue);
svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_MIDDLE_COLOUR, NULL);
if (!svalue)
{
gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_MIDDLE_COLOUR, svalue = g_strdup("EEC83177"), NULL);
}
awn_cairo_string_to_color(svalue, &data->colour_meter_middle);
g_free(svalue);
svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_STOP_COLOUR, NULL);
if (!svalue)
{
gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_STOP_COLOUR, svalue = g_strdup("FF0010ee"), NULL);
}
awn_cairo_string_to_color(svalue, &data->colour_meter_end);
g_free(svalue);
//data->pats[] is initialized once i render.. then needs to be free'd in constructor
}
int
main (int argc, char **argv)
{
pid_t pid;
gboolean delay_click = FALSE;
gboolean dwell_click = FALSE;
gdouble delay_time = -1.;
gdouble dwell_time = -1.;
gboolean shutdown = FALSE;
gboolean ctw = FALSE;
gboolean animate = FALSE;
gchar *mode = NULL;
gint pos_x = -1;
gint pos_y = -1;
gint threshold = -1;
GOptionContext *context;
GOptionEntry entries[] = {
{"enable-dwell", 0, 0, G_OPTION_ARG_NONE, &dwell_click,
N_("Enable dwell click"), 0},
{"enable-secondary", 0, 0, G_OPTION_ARG_NONE, &delay_click,
N_("Enable simulated secondary click"), 0},
{"dwell-time", 0, 0, G_OPTION_ARG_DOUBLE, &dwell_time,
N_("Time to wait before a dwell click"), "[0.2-3.0]"},
{"secondary-time", 0, 0, G_OPTION_ARG_DOUBLE, &delay_time,
N_("Time to wait before a simulated secondary click"), "[0.5-3.0]"},
{"dwell-mode", 'm', 0, G_OPTION_ARG_STRING, &mode,
N_("Dwell mode to use"), "[window|gesture]"},
{"show-ctw", 'c', 0, G_OPTION_ARG_NONE, &ctw,
N_("Show click type window"), 0},
{"ctw-x", 'x', 0, G_OPTION_ARG_INT, &pos_x,
N_("Window x position"), 0},
{"ctw-y", 'y', 0, G_OPTION_ARG_INT, &pos_y,
N_("Window y position"), 0},
{"threshold", 't', 0, G_OPTION_ARG_INT, &threshold,
N_("Ignore small pointer movements"), "[0-30]"},
{"animate-cursor", 'a', 0, G_OPTION_ARG_NONE, &animate,
N_("Show elapsed time as cursor overlay"), 0},
{"shutdown", 's', 0, G_OPTION_ARG_NONE, &shutdown,
N_("Shut down mousetweaks"), 0},
{ NULL }
};
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
setlocale (LC_ALL, "");
context = g_option_context_new (_("- GNOME mousetweaks daemon"));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
if (shutdown) {
int ret;
if ((ret = mt_pidfile_kill_wait (SIGINT, 5)) < 0)
g_print ("Shutdown failed or nothing to shut down.\n");
else
g_print ("Shutdown successful.\n");
return ret < 0 ? 1 : 0;
}
if ((pid = mt_pidfile_is_running ()) >= 0) {
g_print ("Daemon is already running. (PID %u)\n", pid);
return 1;
}
g_print ("Starting daemon.\n");
if ((pid = fork ()) < 0) {
g_error ("fork() failed.");
return 1;
}
else if (pid) {
/* Parent return */
return 0;
}
else {
/* Child process */
MTClosure *mt;
MtCursorManager *manager;
MtListener *listener;
gint spi_status;
gint spi_leaks = 0;
if (mt_pidfile_create () < 0)
return 1;
signal (SIGINT, signal_handler);
signal (SIGTERM, signal_handler);
signal (SIGQUIT, signal_handler);
signal (SIGHUP, signal_handler);
gtk_init (&argc, &argv);
g_set_application_name ("Mousetweaks");
mt = mt_closure_init ();
if (!mt)
goto FINISH;
spi_status = SPI_init ();
if (!accessibility_enabled (mt, spi_status)) {
mt_closure_free (mt);
goto FINISH;
}
/* command-line options */
if (dwell_click)
gconf_client_set_bool (mt->client, OPT_DWELL, TRUE, NULL);
if (delay_click)
gconf_client_set_bool (mt->client, OPT_DELAY, TRUE, NULL);
if (delay_time >= .5 && delay_time <= 3.)
gconf_client_set_float (mt->client, OPT_DELAY_T, delay_time, NULL);
if (dwell_time >= .2 && dwell_time <= 3.)
gconf_client_set_float (mt->client, OPT_DWELL_T, dwell_time, NULL);
if (threshold >= 0 && threshold <= 30)
gconf_client_set_int (mt->client, OPT_THRESHOLD, threshold, NULL);
if (ctw)
gconf_client_set_bool (mt->client, OPT_CTW, TRUE, NULL);
if (animate)
gconf_client_set_bool (mt->client, OPT_ANIMATE, TRUE, NULL);
if (mode) {
if (g_str_equal (mode, "gesture"))
gconf_client_set_int (mt->client, OPT_MODE,
DWELL_MODE_GESTURE, NULL);
else if (g_str_equal (mode, "window"))
gconf_client_set_int (mt->client, OPT_MODE,
DWELL_MODE_CTW, NULL);
g_free (mode);
}
get_gconf_options (mt);
if (!mt_ctw_init (mt, pos_x, pos_y))
goto CLEANUP;
/* init cursor animation */
manager = mt_cursor_manager_get_default ();
g_signal_connect (manager, "cursor_changed",
G_CALLBACK (cursor_changed), mt);
g_signal_connect (manager, "cache_cleared",
G_CALLBACK (cursor_cache_cleared), mt);
mt->cursor = mt_cursor_manager_current_cursor (manager);
/* init at-spi signals */
listener = mt_listener_get_default ();
g_signal_connect (listener, "motion_event",
G_CALLBACK (global_motion_event), mt);
g_signal_connect (listener, "button_event",
G_CALLBACK (global_button_event), mt);
g_signal_connect (listener, "focus_changed",
G_CALLBACK (global_focus_event), mt);
gtk_main ();
mt_cursor_manager_restore_all (manager);
g_object_unref (manager);
g_object_unref (listener);
CLEANUP:
spi_leaks = SPI_exit ();
mt_closure_free (mt);
FINISH:
mt_pidfile_remove ();
if (spi_leaks)
g_warning ("AT-SPI reported %i leak%s.",
spi_leaks, spi_leaks != 1 ? "s" : "");
}
return 0;
}
static void
cheese_gconf_set_property (GObject *object, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
CheeseGConf *self;
self = CHEESE_GCONF (object);
CheeseGConfPrivate *priv = CHEESE_GCONF_GET_PRIVATE (self);
gchar **effects = NULL;
GSList *list = NULL;
int i;
switch (prop_id)
{
case GCONF_PROP_COUNTDOWN:
gconf_client_set_bool (priv->client,
CHEESE_GCONF_PREFIX "/countdown",
g_value_get_boolean (value),
NULL);
break;
case GCONF_PROP_FLASH:
gconf_client_set_bool (priv->client,
CHEESE_GCONF_PREFIX "/flash",
g_value_get_boolean (value),
NULL);
break;
case GCONF_PROP_CAMERA:
gconf_client_set_string (priv->client,
CHEESE_GCONF_PREFIX "/camera",
g_value_get_string (value),
NULL);
break;
case GCONF_PROP_SELECTED_EFFECTS:
if (g_value_get_string (value) == NULL)
{
list = NULL;
}
else
{
char *str = g_value_dup_string (value);
int j;
for (j = 0; j < g_utf8_strlen (str, -1); j++)
{
if (g_ascii_isupper (str[j]))
{
str[j] = g_ascii_tolower (str[j]);
}
else if (str[j] == ' ')
{
str[j] = '-';
}
else if (str[j] == '/')
{
str[j] = '_';
}
}
effects = g_strsplit (str, ",", 12);
for (i = 0; effects[i] != NULL; i++)
{
list = g_slist_append (list, effects[i]);
}
g_free (str);
}
gconf_client_set_list (priv->client,
CHEESE_GCONF_PREFIX "/selected_effects",
GCONF_VALUE_STRING,
list,
NULL);
g_slist_free (list);
g_strfreev (effects);
break;
case GCONF_PROP_X_RESOLUTION:
gconf_client_set_int (priv->client,
CHEESE_GCONF_PREFIX "/x_resolution",
g_value_get_int (value),
NULL);
break;
case GCONF_PROP_Y_RESOLUTION:
gconf_client_set_int (priv->client,
CHEESE_GCONF_PREFIX "/y_resolution",
g_value_get_int (value),
NULL);
break;
case GCONF_PROP_BRIGHTNESS:
gconf_client_set_float (priv->client,
CHEESE_GCONF_PREFIX "/brightness",
g_value_get_double (value),
NULL);
break;
case GCONF_PROP_CONTRAST:
gconf_client_set_float (priv->client,
CHEESE_GCONF_PREFIX "/contrast",
g_value_get_double (value),
NULL);
break;
case GCONF_PROP_SATURATION:
gconf_client_set_float (priv->client,
CHEESE_GCONF_PREFIX "/saturation",
g_value_get_double (value),
NULL);
break;
case GCONF_PROP_HUE:
gconf_client_set_float (priv->client,
CHEESE_GCONF_PREFIX "/hue",
g_value_get_double (value),
NULL);
break;
case GCONF_PROP_VIDEO_PATH:
gconf_client_set_string (priv->client,
CHEESE_GCONF_PREFIX "/video_path",
g_value_get_string (value),
NULL);
break;
case GCONF_PROP_PHOTO_PATH:
gconf_client_set_string (priv->client,
CHEESE_GCONF_PREFIX "/photo_path",
g_value_get_string (value),
NULL);
break;
case GCONF_PROP_ENABLE_DELETE:
gconf_client_set_bool (priv->client,
CHEESE_GCONF_PREFIX "/enable_delete",
g_value_get_boolean (value),
NULL);
break;
case GCONF_PROP_WIDE_MODE:
gconf_client_set_bool (priv->client,
CHEESE_GCONF_PREFIX "/wide_mode",
g_value_get_boolean (value),
NULL);
break;
case GCONF_PROP_BURST_DELAY:
gconf_client_set_int (priv->client,
CHEESE_GCONF_PREFIX "/burst_delay",
g_value_get_int (value),
NULL);
break;
case GCONF_PROP_BURST_REPEAT:
gconf_client_set_int (priv->client,
CHEESE_GCONF_PREFIX "/burst_repeat",
g_value_get_int (value),
NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
