=== modified file 'configure.in' --- configure.in 2009-08-14 14:25:04 +0000 +++ configure.in 2009-08-18 13:59:31 +0000 @@ -24,13 +24,7 @@ # # glib, we need 2.16.0 for the unit-tests # -PKG_CHECK_MODULES([GLIB], [glib-2.0 >= 2.16.0 gthread-2.0 gconf-2.0 gio-2.0]) - -# -# gconf, used by the Defaults class to get system font-face and font-size -# -PKG_CHECK_MODULES([GCONF], [gconf-2.0]) - +PKG_CHECK_MODULES([GLIB], [glib-2.0 >= 2.16.0 gthread-2.0 gio-2.0]) # # libwnck used by the dnd code @@ -62,6 +56,25 @@ AC_SUBST(NOTIFY_OSD_LIBS) # +# gconf, used by the Defaults class to get system font-face and font-size +# +AC_DEFUN([CHECK_FOR_GCONF], +[ + PKG_CHECK_MODULES([GCONF], [gconf-2.0]) + PKG_CHECK_MODULES([GLIB], [glib-2.0 >= 2.16.0 gconf-2.0]) +]) + +# +# checks for xfconf, which can be used instead of gconf +# +AC_DEFUN([CHECK_FOR_XFCONF], +[ + PKG_CHECK_MODULES([XFCONF], [libxfconf-0 >= 4.6.0]) + AC_SUBST(XFCONF_CFLAGS) + AC_SUBST(XFCONF_LIBS) +]) + +# # checks for building C- or C#-examples # AC_DEFUN([CHECK_FOR_MONO_STUFF], @@ -101,6 +114,16 @@ there are Python-examples too, but they don't need to be build]) +AC_ARG_WITH(gconf, [ --with-gconf=[[yes/no]] + use gconf as the utility to store notify-osd's + settings. Allows better integration in GNOME + based distributions.]) + +AC_ARG_WITH(xfconf, [ --with-xfconf=[[yes/no]] + use xfconf as the utility to store notify-osd's + settings. Allows better integration in XFCE + based distributions.]) + c_examples=no csharp_examples=no if test "x$with_examples" = "xc"; then @@ -120,8 +143,29 @@ AC_MSG_NOTICE([Build with C-sharp examples]) fi +# +# Checking for the configuration framework to use. If none, default to gconf +# +use_gconf=no +use_xfconf=no +if test "x$with_gconf" = "xyes"; then + CHECK_FOR_GCONF + use_gconf=yes + AC_MSG_NOTICE([Use GConf to store settings]) +elif test "x$with_xfconf" = "xyes"; then + CHECK_FOR_XFCONF + use_xfconf=yes + AC_MSG_NOTICE([Use XFCONF to store settings]) +else + # we dont set use_gconf to yes as user didnt explicitely ask for gconf + CHECK_FOR_GCONF + AC_MSG_NOTICE([Use the default framework (GConf) to store settings]) +fi + AM_CONDITIONAL(BUILD_C_EXAMPLES, test "x$c_examples" != "xno") AM_CONDITIONAL(BUILD_MONO_EXAMPLES, test "x$csharp_examples" != "xno") +AM_CONDITIONAL(USE_GCONF, test "x$use_gconf" = "xyes") +AM_CONDITIONAL(USE_XFCONF, test "x$use_xfconf" = "xyes") dnl CFLAGS CFLAGS="$CFLAGS -lm -Wall -Werror -std=c99" @@ -146,3 +190,11 @@ echo "" echo " Build C# Examples: ${csharp_examples}" echo "" +if test "x$use_gconf" = "xyes"; then +echo " Store settings with: GConf" +elif test "x$use_xfconf" = "xyes"; then +echo " Store settings with: XFCONF" +else +echo " Store settings with: default (GConf)" +fi +echo "" === modified file 'src/Makefile.am' --- src/Makefile.am 2009-08-14 14:21:49 +0000 +++ src/Makefile.am 2009-08-18 13:59:31 +0000 @@ -81,7 +81,6 @@ notify_osd_LDADD = \ $(X_LIBS) \ $(GLIB_LIBS) \ - $(GCONF_LIBS) \ $(GTK_LIBS) \ $(NOTIFY_OSD_LIBS) \ $(DBUS_LIBS) \ @@ -93,13 +92,31 @@ $(GTK_CFLAGS) \ $(NOTIFY_OSD_CFLAGS) \ $(GLIB_CFLAGS) \ - $(GCONF_CFLAGS) \ $(DBUS_CFLAGS) \ -DWNCK_I_KNOW_THIS_IS_UNSTABLE \ $(WNCK_CFLAGS) \ $(INCLUDES) \ $(NULL) + +if USE_GCONF +notify_osd_LDADD += $(GCONF_LIBS) + +notify_osd_CFLAGS += -D__USE_GCONF \ + $(GCONF_CFLAGS) +else +if USE_XFCONF +notify_osd_LDADD += $(XFCONF_LIBS) + +notify_osd_CFLAGS += -D__USE_XFCONF \ + $(XFCONF_CFLAGS) +else +notify_osd_LDADD += $(GCONF_LIBS) + +notify_osd_CFLAGS += $(GCONF_CFLAGS) +endif +endif + notify_osd_LDFLAGS = \ -Xlinker -export-dynamic -Wl,-O1 -Wl,-Bsymbolic-functions \ $(NULL) === modified file 'src/bubble.c' --- src/bubble.c 2009-08-04 17:34:48 +0000 +++ src/bubble.c 2009-08-18 13:59:31 +0000 @@ -112,9 +112,7 @@ A }; -// FIXME: this is in class Defaults already, but not yet hooked up so for the -// moment we use the macros here, these values reflect the visual-guideline -// for jaunty notifications + #define TEXT_TITLE_COLOR_R 1.0f #define TEXT_TITLE_COLOR_G 1.0f #define TEXT_TITLE_COLOR_B 1.0f @@ -135,6 +133,11 @@ #define BUBBLE_BG_COLOR_B 0.15f #define BUBBLE_BG_COLOR_A 0.9f +#define BUBBLE_SHADOW_COLOR_R 0.0f +#define BUBBLE_SHADOW_COLOR_G 0.0f +#define BUBBLE_SHADOW_COLOR_B 0.0f +#define BUBBLE_SHADOW_COLOR_A 1.0f + #define INDICATOR_UNLIT_R 1.0f #define INDICATOR_UNLIT_G 1.0f #define INDICATOR_UNLIT_B 1.0f @@ -352,10 +355,11 @@ void _draw_shadow (cairo_t* cr, - gdouble width, - gdouble height, - gint shadow_radius, - gint corner_radius) + Defaults* defaults, + gdouble width, + gdouble height, + gint shadow_radius, + gint corner_radius) { cairo_surface_t* tmp_surface = NULL; cairo_surface_t* new_surface = NULL; @@ -363,6 +367,9 @@ cairo_t* cr_surf = NULL; cairo_matrix_t matrix; raico_blur_t* blur = NULL; + gchar* color_string = NULL; + GdkColor* color = NULL; + tmp_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 4 * shadow_radius, @@ -386,7 +393,29 @@ cairo_set_operator (cr_surf, CAIRO_OPERATOR_CLEAR); cairo_paint (cr_surf); cairo_set_operator (cr_surf, CAIRO_OPERATOR_OVER); - cairo_set_source_rgba (cr_surf, 0.0f, 0.0f, 0.0f, 1.0f); + + color_string = defaults_get_bubble_shadow_color (defaults); + color = g_malloc (sizeof (GdkColor)); + if (gdk_color_parse (color_string, color)) + { + cairo_set_source_rgba (cr_surf, + (gdouble)color->red / 65535.0f, + (gdouble)color->green / 65535.0f, + (gdouble)color->blue / 65535.0f, + 1.0f); + } + else + { + g_warning("Error while setting bubble shadow rgba from bubble-shadow-color\n"); + cairo_set_source_rgba (cr_surf, + BUBBLE_SHADOW_COLOR_R, + BUBBLE_SHADOW_COLOR_G, + BUBBLE_SHADOW_COLOR_B, + BUBBLE_SHADOW_COLOR_A); + } + g_free (color_string); + g_free (color); + cairo_arc (cr_surf, 2 * shadow_radius, 2 * shadow_radius, @@ -644,6 +673,9 @@ raico_blur_t* blur = NULL; gint width; gint height; + gchar* color_string = NULL; + gdouble bg_opacity; + GdkColor* color = NULL; bubble_get_size (self, &width, &height); @@ -682,11 +714,15 @@ cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); cairo_set_operator (cr, CAIRO_OPERATOR_OVER); - + + color_string = defaults_get_bubble_bg_color (d); + color = g_malloc (sizeof (GdkColor)); + if (priv->composited) { _draw_shadow ( cr, + d, width, height, EM2PIXELS (defaults_get_bubble_shadow_size (d), d), @@ -703,18 +739,48 @@ 2.0f * EM2PIXELS (defaults_get_bubble_shadow_size (d), d)); cairo_fill (cr); cairo_set_operator (cr, CAIRO_OPERATOR_OVER); - cairo_set_source_rgba (cr, - BUBBLE_BG_COLOR_R, - BUBBLE_BG_COLOR_G, - BUBBLE_BG_COLOR_B, - BUBBLE_BG_COLOR_A); + + bg_opacity = defaults_get_bubble_bg_opacity (d); + if (gdk_color_parse (color_string, color)) + { + cairo_set_source_rgba (cr, + (gdouble)color->red / 65535.0f, + (gdouble)color->green / 65535.0f, + (gdouble)color->blue / 65535.0f, + bg_opacity); + } + else + { + g_warning("Error while setting bubble bg rgba from bubble-bg-color and bubble-bg-opacity\n"); + cairo_set_source_rgba (cr, + BUBBLE_BG_COLOR_R, + BUBBLE_BG_COLOR_G, + BUBBLE_BG_COLOR_B, + BUBBLE_BG_COLOR_A); + } } else - cairo_set_source_rgb (cr, - BUBBLE_BG_COLOR_R, - BUBBLE_BG_COLOR_G, - BUBBLE_BG_COLOR_B); + { + if (gdk_color_parse (color_string, color)) + { + cairo_set_source_rgb (cr, + (gdouble)color->red / 65535.0f, + (gdouble)color->green / 65535.0f, + (gdouble)color->blue / 65535.0f); + } + else + { + g_warning("Error while setting bubble bg rgb from bubble-bg-color\n"); + cairo_set_source_rgb (cr, + BUBBLE_BG_COLOR_R, + BUBBLE_BG_COLOR_G, + BUBBLE_BG_COLOR_B); + } + } + g_free (color_string); + g_free (color); + draw_round_rect ( cr, 1.0f, @@ -943,13 +1009,15 @@ void _refresh_title (Bubble* self) { - BubblePrivate* priv = GET_PRIVATE (self); - Defaults* d = self->defaults; - cairo_surface_t* normal = NULL; - cairo_t* cr = NULL; - PangoFontDescription* desc = NULL; - PangoLayout* layout = NULL; - raico_blur_t* blur = NULL; + BubblePrivate* priv = GET_PRIVATE (self); + Defaults* d = self->defaults; + cairo_surface_t* normal = NULL; + cairo_t* cr = NULL; + PangoFontDescription* desc = NULL; + PangoLayout* layout = NULL; + raico_blur_t* blur = NULL; + gchar* color_string = NULL; + GdkColor* color = NULL; // create temp. scratch surface normal = cairo_image_surface_create ( @@ -1012,11 +1080,28 @@ cairo_move_to (cr, BUBBLE_CONTENT_BLUR_RADIUS, BUBBLE_CONTENT_BLUR_RADIUS); - cairo_set_source_rgba (cr, - TEXT_SHADOW_COLOR_R, - TEXT_SHADOW_COLOR_G, - TEXT_SHADOW_COLOR_B, - TEXT_SHADOW_COLOR_A); + + color_string = defaults_get_content_shadow_color (d); + color = g_malloc (sizeof (GdkColor)); + if (gdk_color_parse (color_string, color)) + { + cairo_set_source_rgba (cr, + (gdouble)color->red / 65535.0f, + (gdouble)color->green / 65535.0f, + (gdouble)color->blue / 65535.0f, + TEXT_SHADOW_COLOR_A); + } + else + { + g_warning("Error while setting text shadow rgba from content-shadow-color\n"); + cairo_set_source_rgba (cr, + TEXT_SHADOW_COLOR_R, + TEXT_SHADOW_COLOR_G, + TEXT_SHADOW_COLOR_B, + TEXT_SHADOW_COLOR_A); + } + g_free (color_string); + g_free (color); // ... blur it blur = raico_blur_create (RAICO_BLUR_QUALITY_HIGH); @@ -1025,11 +1110,27 @@ raico_blur_destroy (blur); // now draw normal (non-blurred) text over drop-shadow - cairo_set_source_rgba (cr, - TEXT_TITLE_COLOR_R, - TEXT_TITLE_COLOR_G, - TEXT_TITLE_COLOR_B, - TEXT_TITLE_COLOR_A); + color_string = defaults_get_text_title_color (d); + color = g_malloc (sizeof (GdkColor)); + if (gdk_color_parse (color_string, color)) + { + cairo_set_source_rgba (cr, + (gdouble)color->red / 65535.0f, + (gdouble)color->green / 65535.0f, + (gdouble)color->blue / 65535.0f, + TEXT_TITLE_COLOR_A); + } + else + { + g_warning("Error while setting text title rgba from text-title-color\n"); + cairo_set_source_rgba (cr, + TEXT_TITLE_COLOR_R, + TEXT_TITLE_COLOR_G, + TEXT_TITLE_COLOR_B, + TEXT_TITLE_COLOR_A); + } + g_free (color_string); + g_free (color); pango_cairo_show_layout (cr, layout); g_object_unref (layout); @@ -1047,13 +1148,15 @@ void _refresh_body (Bubble* self) { - BubblePrivate* priv = GET_PRIVATE (self); - Defaults* d = self->defaults; - cairo_surface_t* normal = NULL; - cairo_t* cr = NULL; - PangoFontDescription* desc = NULL; - PangoLayout* layout = NULL; - raico_blur_t* blur = NULL; + BubblePrivate* priv = GET_PRIVATE (self); + Defaults* d = self->defaults; + cairo_surface_t* normal = NULL; + cairo_t* cr = NULL; + PangoFontDescription* desc = NULL; + PangoLayout* layout = NULL; + raico_blur_t* blur = NULL; + gchar* color_string = NULL; + GdkColor* color = NULL; // create temp. scratch surface normal = cairo_image_surface_create ( @@ -1118,11 +1221,28 @@ cairo_move_to (cr, BUBBLE_CONTENT_BLUR_RADIUS, BUBBLE_CONTENT_BLUR_RADIUS); - cairo_set_source_rgba (cr, - TEXT_SHADOW_COLOR_R, - TEXT_SHADOW_COLOR_G, - TEXT_SHADOW_COLOR_B, - TEXT_SHADOW_COLOR_A); + + color_string = defaults_get_content_shadow_color (d); + color = g_malloc (sizeof (GdkColor)); + if (gdk_color_parse (color_string, color)) + { + cairo_set_source_rgba (cr, + (gdouble)color->red / 65535.0f, + (gdouble)color->green / 65535.0f, + (gdouble)color->blue / 65535.0f, + TEXT_SHADOW_COLOR_A); + } + else + { + g_warning("Error while setting text shadow rgba from content-shadow-color\n"); + cairo_set_source_rgba (cr, + TEXT_SHADOW_COLOR_R, + TEXT_SHADOW_COLOR_G, + TEXT_SHADOW_COLOR_B, + TEXT_SHADOW_COLOR_A); + } + g_free (color_string); + g_free (color); pango_cairo_show_layout (cr, layout); // ... blur it @@ -1132,11 +1252,27 @@ raico_blur_destroy (blur); // now draw normal (non-blurred) text over drop-shadow - cairo_set_source_rgba (cr, - TEXT_BODY_COLOR_R, - TEXT_BODY_COLOR_G, - TEXT_BODY_COLOR_B, - TEXT_BODY_COLOR_A); + color_string = defaults_get_text_body_color (d); + color = g_malloc (sizeof (GdkColor)); + if (gdk_color_parse (color_string, color)) + { + cairo_set_source_rgba (cr, + (gdouble)color->red / 65535.0f, + (gdouble)color->green / 65535.0f, + (gdouble)color->blue / 65535.0f, + TEXT_BODY_COLOR_A); + } + else + { + g_warning("Error while setting text body rgba from text-body-color\n"); + cairo_set_source_rgba (cr, + TEXT_BODY_COLOR_R, + TEXT_BODY_COLOR_G, + TEXT_BODY_COLOR_B, + TEXT_BODY_COLOR_A); + } + g_free (color_string); + g_free (color); pango_cairo_show_layout (cr, layout); g_object_unref (layout); === added file 'src/defaults-gconf.c' --- src/defaults-gconf.c 1970-01-01 00:00:00 +0000 +++ src/defaults-gconf.c 2009-08-19 16:45:39 +0000 @@ -0,0 +1,1002 @@ +/******************************************************************************* +**3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 +** 10 20 30 40 50 60 70 80 +** +** notify-osd +** +** defaults-gconf.c - gconf framework for the notify-osd defaults class +** +** Copyright 2009 Canonical Ltd. +** +** Authors: +** Mirco "MacSlow" Mueller +** David Barth +** +** This program is free software: you can redistribute it and/or modify it +** under the terms of the GNU General Public License version 3, as published +** by the Free Software Foundation. +** +** This program is distributed in the hope that it will be useful, but +** WITHOUT ANY WARRANTY; without even the implied warranties of +** MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR +** PURPOSE. See the GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License along +** with this program. If not, see . +** +*******************************************************************************/ + +#include + +#include "defaults.h" +#include "defaults-gconf.h" + + +GString* +conf_get_font(ConfData* d, + gchar* fallback) +{ + GError* error = NULL; + GString* dest = NULL; + + dest = g_string_new (gconf_client_get_string (d->context, + GCONF_UI_FONT_NAME, + &error)); + if (error) + { + /* if something went wrong, use the fallback value */ + dest = g_string_assign (dest, fallback); + } + + return dest; +} + +gdouble +conf_get_dpi(ConfData* d, + gdouble fallback) +{ + GError* error = NULL; + gdouble dest = fallback; + + dest = gconf_client_get_float (d->context, + GCONF_FONT_DPI, + &error); + if (error || (dest == 0.0f)) + { + /* if something went wrong, use the fallback value */ + dest = fallback; + } + + return dest; +} + +gdouble +conf_get_text_title_size(ConfData* d, + gdouble fallback) +{ + gdouble title_size = fallback; + GError* error = NULL; + + title_size = gconf_client_get_float (d->context, GCONF_TEXT_TITLE_SIZE, &error); + if (error || (title_size == 0.0f)) + { + /* if something went wrong, use default value and continue */ + title_size = fallback; + } + + return title_size; +} + +gdouble +conf_get_text_body_size(ConfData* d, + gdouble fallback) +{ + gdouble body_size = fallback; + GError* error = NULL; + + body_size = gconf_client_get_float (d->context, GCONF_TEXT_BODY_SIZE, &error); + if (error || (body_size == 0.0f)) + { + /* if something went wrong, use default value and continue */ + body_size = fallback; + } + + return body_size; +} + +gchar* +conf_get_bubble_shadow_color(ConfData* d, + gchar* fallback) +{ + GError* error = NULL; + gchar* val = NULL; + + val = g_strdup (gconf_client_get_string (d->context, + GCONF_BUBBLE_SHADOW_COLOR, + &error)); + if (error || (val == NULL)) + { + /* if something went wrong, use default value continue */ + val = g_strdup (fallback); + } + + return val; +} + +gchar* +conf_get_bubble_bg_color(ConfData* d, + gchar* fallback) +{ + GError* error = NULL; + gchar* val = NULL; + + val = g_strdup (gconf_client_get_string (d->context, + GCONF_BUBBLE_BG_COLOR, + &error)); + if (error || (val == NULL)) + { + /* if something went wrong, use default value continue */ + val = g_strdup (fallback); + } + + return val; +} + +gdouble +conf_get_bubble_bg_opacity(ConfData* d, + gdouble fallback) +{ + GError* error = NULL; + gdouble val = fallback; + + val = gconf_client_get_float (d->context, + GCONF_BUBBLE_BG_OPACITY, + &error); + if (error || (val == 0.0f)) + { + /* if something went wrong, use default value continue */ + val = fallback; + } + + return val; +} + +gdouble +conf_get_bubble_hover_opacity(ConfData* d, + gdouble fallback) +{ + GError* error = NULL; + gdouble val = fallback; + + val = gconf_client_get_float (d->context, + GCONF_BUBBLE_HOVER_OPACITY, + &error); + if (error || (val == 0.0f)) + { + /* if something went wrong, use default value continue */ + val = fallback; + } + + return val; +} + +gchar* +conf_get_content_shadow_color(ConfData* d, + gchar* fallback) +{ + GError* error = NULL; + gchar* val = NULL; + + val = g_strdup (gconf_client_get_string (d->context, + GCONF_CONTENT_SHADOW_COLOR, + &error)); + if (error || (val == NULL)) + { + /* if something went wrong, use default value continue */ + val = g_strdup (fallback); + } + + return val; +} + +gchar* +conf_get_text_title_color(ConfData* d, + gchar* fallback) +{ + GError* error = NULL; + gchar* val = NULL; + + val = g_strdup (gconf_client_get_string (d->context, + GCONF_TEXT_TITLE_COLOR, + &error)); + if (error || (val == NULL)) + { + /* if something went wrong, use default value continue */ + val = g_strdup (fallback); + } + + return val; +} + +gchar* +conf_get_text_body_color(ConfData* d, + gchar* fallback) +{ + GError* error = NULL; + gchar* val = NULL; + + val = g_strdup (gconf_client_get_string (d->context, + GCONF_TEXT_BODY_COLOR, + &error)); + if (error || (val == NULL)) + { + /* if something went wrong, use default value continue */ + val = g_strdup (fallback); + } + + return val; +} + +gboolean +conf_multihead_does_focus_follow(ConfData* d, + gboolean fallback) +{ + gboolean mode = fallback; + GError *error = NULL; + + gchar *mode_str = gconf_client_get_string (d->context, + GCONF_MULTIHEAD_MODE, + &error); + if (mode_str != NULL) + { + if (! g_strcmp0 (mode_str, "focus-follow")) + mode = TRUE; + } else if (error != NULL) + g_warning ("error getting multihead mode: %s\n", + error->message); + + return mode; +} + +static void +_font_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* grab system-wide font-face/size and DPI */ + _get_font_size_dpi (defaults); + + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_antialias_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* just triggering a redraw by emitting the "value-changed" signal is + ** enough in this case, no need to update any stored values */ + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_dpi_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* grab system-wide font-face/size and DPI */ + _get_font_size_dpi (defaults); + + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_hinting_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* just triggering a redraw by emitting the "value-changed" signal is + ** enough in this case, no need to update any stored values */ + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_subpixel_order_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* just triggering a redraw by emitting the "value-changed" signal is + ** enough in this case, no need to update any stored values */ + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + + +static void +_text_title_size_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* grab text title and body size */ + _get_text_size (defaults); + + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_text_body_size_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* grab text title and body size */ + _get_text_size (defaults); + + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_bubble_shadow_color_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + gchar* val = NULL; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* update the theme and let the bubble know */ + val = conf_get_bubble_shadow_color (defaults->conf, DEFAULT_BUBBLE_SHADOW_COLOR); + defaults_set_bubble_shadow_color (defaults, val); + g_free (val); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_bubble_bg_color_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + gchar* val = NULL; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* update the theme and let the bubble know */ + val = conf_get_bubble_bg_color (defaults->conf, DEFAULT_BUBBLE_BG_COLOR); + defaults_set_bubble_bg_color (defaults, val); + g_free (val); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_bubble_bg_opacity_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + gdouble val = 0.0f; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* update the theme and let the bubble know */ + val = conf_get_bubble_bg_opacity (defaults->conf, DEFAULT_BUBBLE_BG_OPACITY); + defaults_set_bubble_bg_opacity (defaults, val); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + +} + +static void +_bubble_hover_opacity_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + gdouble val = 0.0f; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* update the theme and let the bubble know */ + val = conf_get_bubble_hover_opacity (defaults->conf, DEFAULT_BUBBLE_HOVER_OPACITY); + defaults_set_bubble_hover_opacity (defaults, val); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + +} + +static void +_content_shadow_color_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + gchar* val = NULL; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* update the theme and let the bubble know */ + val = conf_get_content_shadow_color (defaults->conf, DEFAULT_CONTENT_SHADOW_COLOR); + defaults_set_content_shadow_color (defaults, val); + g_free (val); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_text_title_color_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + gchar* val = NULL; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* update the theme and let the bubble know */ + val = conf_get_text_title_color (defaults->conf, DEFAULT_TEXT_TITLE_COLOR); + defaults_set_text_title_color (defaults, val); + g_free (val); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +static void +_text_body_color_changed (GConfClient* client, + guint cnxn_id, + GConfEntry* entry, + gpointer data) +{ + Defaults* defaults; + gchar* val = NULL; + + if (!data) + return; + + defaults = (Defaults*) data; + if (!IS_DEFAULTS (defaults)) + return; + + /* update the theme and let the bubble know */ + val = conf_get_text_body_color (defaults->conf, DEFAULT_TEXT_BODY_COLOR); + defaults_set_text_body_color (defaults, val); + g_free (val); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); +} + +void +conf_defaults_dispose(Defaults* defaults) +{ + if (!IS_DEFAULTS (defaults)) + return; + + if (!defaults->conf) + return; + + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[7]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[8]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[9]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[10]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[11]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[12]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[13]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); +} + +gboolean +conf_defaults_init(Defaults* defaults) +{ + GError* error; + + if (!IS_DEFAULTS (defaults)) + return FALSE; + + if (!defaults->conf) + return FALSE; + + /* "connect" to the whole gconf-thing */ + defaults->conf->context = NULL; + defaults->conf->context = gconf_client_get_default (); + if (!defaults->conf->context) + { + g_warning ("Could not get GConf client-context"); + return FALSE; + } + + /* register watching all relevant GNOME UI-settings */ + error = NULL; + gconf_client_add_dir (defaults->conf->context, + GCONF_UI_TREE, + GCONF_CLIENT_PRELOAD_NONE, + &error); + if (error) + { + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* register watching all font-settings */ + error = NULL; + gconf_client_add_dir (defaults->conf->context, + GCONF_FONT_TREE, + GCONF_CLIENT_PRELOAD_NONE, + &error); + if (error) + { + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* register watching all notify-osd settings */ + error = NULL; + gconf_client_add_dir (defaults->conf->context, + GCONF_NOTIFYOSD_TREE, + GCONF_CLIENT_PRELOAD_NONE, + &error); + if (error) + { + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for font-name/size changes */ + error = NULL; + defaults->conf->notifier[0] = gconf_client_notify_add (defaults->conf->context, + GCONF_UI_FONT_NAME, + _font_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for antialiasing changes */ + error = NULL; + defaults->conf->notifier[1] = gconf_client_notify_add (defaults->conf->context, + GCONF_FONT_ANTIALIAS, + _antialias_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for DPI changes */ + error = NULL; + defaults->conf->notifier[2] = gconf_client_notify_add (defaults->conf->context, + GCONF_FONT_DPI, + _dpi_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for hinting changes */ + error = NULL; + defaults->conf->notifier[3] = gconf_client_notify_add (defaults->conf->context, + GCONF_FONT_HINTING, + _hinting_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for subpixel-order changes */ + error = NULL; + defaults->conf->notifier[4] = gconf_client_notify_add (defaults->conf->context, + GCONF_FONT_SUBPIXEL_ORDER, + _subpixel_order_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for text-title-size changes */ + error = NULL; + defaults->conf->notifier[5] = gconf_client_notify_add (defaults->conf->context, + GCONF_TEXT_TITLE_SIZE, + _text_title_size_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for text-body-size changes */ + error = NULL; + defaults->conf->notifier[6] = gconf_client_notify_add (defaults->conf->context, + GCONF_TEXT_BODY_SIZE, + _text_body_size_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for bubble shadow color changes */ + error = NULL; + defaults->conf->notifier[7] = gconf_client_notify_add (defaults->conf->context, + GCONF_BUBBLE_SHADOW_COLOR, + _bubble_shadow_color_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for bubble bg color changes */ + error = NULL; + defaults->conf->notifier[8] = gconf_client_notify_add (defaults->conf->context, + GCONF_BUBBLE_BG_COLOR, + _bubble_bg_color_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[7]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for bubble bg opacity changes */ + error = NULL; + defaults->conf->notifier[9] = gconf_client_notify_add (defaults->conf->context, + GCONF_BUBBLE_BG_OPACITY, + _bubble_bg_opacity_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[7]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[8]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for bubble hover opacity changes */ + error = NULL; + defaults->conf->notifier[10] = gconf_client_notify_add (defaults->conf->context, + GCONF_BUBBLE_HOVER_OPACITY, + _bubble_hover_opacity_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[7]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[8]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[9]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for content shadow color changes */ + error = NULL; + defaults->conf->notifier[11] = gconf_client_notify_add (defaults->conf->context, + GCONF_CONTENT_SHADOW_COLOR, + _content_shadow_color_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[7]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[8]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[9]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[10]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for text title color changes */ + error = NULL; + defaults->conf->notifier[12] = gconf_client_notify_add (defaults->conf->context, + GCONF_TEXT_TITLE_COLOR, + _text_title_color_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[7]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[8]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[9]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[10]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[11]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + /* hook up notifier for text body color changes */ + error = NULL; + defaults->conf->notifier[13] = gconf_client_notify_add (defaults->conf->context, + GCONF_TEXT_BODY_COLOR, + _text_body_color_changed, + (gpointer) defaults, + NULL, + &error); + if (error) + { + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[0]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[1]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[2]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[3]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[4]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[5]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[6]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[7]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[8]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[9]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[10]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[11]); + gconf_client_notify_remove (defaults->conf->context, defaults->conf->notifier[12]); + gconf_client_remove_dir (defaults->conf->context, GCONF_UI_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_FONT_TREE, NULL); + gconf_client_remove_dir (defaults->conf->context, GCONF_NOTIFYOSD_TREE, NULL); + g_object_unref (defaults->conf->context); + g_warning ("%s\n", error->message); + return FALSE; + } + + return TRUE; +} === added file 'src/defaults-gconf.h' --- src/defaults-gconf.h 1970-01-01 00:00:00 +0000 +++ src/defaults-gconf.h 2009-08-18 19:14:30 +0000 @@ -0,0 +1,71 @@ +/******************************************************************************* +**3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 +** 10 20 30 40 50 60 70 80 +** +** notify-osd +** +** defaults-gconf.h - gconf framework for the notify-osd defaults class +** +** Copyright 2009 Canonical Ltd. +** +** Authors: +** Mirco "MacSlow" Mueller +** David Barth +** +** This program is free software: you can redistribute it and/or modify it +** under the terms of the GNU General Public License version 3, as published +** by the Free Software Foundation. +** +** This program is distributed in the hope that it will be useful, but +** WITHOUT ANY WARRANTY; without even the implied warranties of +** MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR +** PURPOSE. See the GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License along +** with this program. If not, see . +** +*******************************************************************************/ + +#ifndef __DEFAULTS_CONF_H +#define __DEFAULTS_CONF_H + +#include + + +/* GConf-keys to watch */ +#define GCONF_UI_FONT_NAME "/desktop/gnome/interface/font_name" +#define GCONF_FONT_ANTIALIAS "/desktop/gnome/font_rendering/antialiasing" +#define GCONF_FONT_DPI "/desktop/gnome/font_rendering/dpi" +#define GCONF_FONT_HINTING "/desktop/gnome/font_rendering/hinting" +#define GCONF_FONT_SUBPIXEL_ORDER "/desktop/gnome/font_rendering/rgba_order" + +/* GConf-trees to watch */ +#define GCONF_UI_TREE "/desktop/gnome/interface" +#define GCONF_FONT_TREE "/desktop/gnome/font_rendering" +#define GCONF_NOTIFYOSD_TREE "/apps/notify-osd" + +/* notify-osd settings */ +#define GCONF_MULTIHEAD_MODE "/apps/notify-osd/multihead_mode" +#define GCONF_BUBBLE_SHADOW_COLOR "/apps/notify-osd/bubble_shadow_color" +#define GCONF_BUBBLE_BG_COLOR "/apps/notify-osd/bubble_bg_color" +#define GCONF_BUBBLE_BG_OPACITY "/apps/notify-osd/bubble_bg_opacity" +#define GCONF_BUBBLE_HOVER_OPACITY "/apps/notify-osd/bubble_hover_opacity" +#define GCONF_CONTENT_SHADOW_COLOR "/apps/notify-osd/content_shadow_color" +#define GCONF_TEXT_TITLE_COLOR "/apps/notify-osd/text_title_color" +#define GCONF_TEXT_BODY_COLOR "/apps/notify-osd/text_body_color" +#define GCONF_TEXT_TITLE_SIZE "/apps/notify-osd/text_title_size" +#define GCONF_TEXT_BODY_SIZE "/apps/notify-osd/text_body_size" + + +G_BEGIN_DECLS + +struct _GConfData { + GConfClient* context; + guint notifier[14]; +}; + +typedef struct _GConfData ConfData; + +G_END_DECLS + +#endif /* __DEFAULTS_CONF_H */ === added file 'src/defaults-xfconf.c' --- src/defaults-xfconf.c 1970-01-01 00:00:00 +0000 +++ src/defaults-xfconf.c 2009-08-20 22:04:48 +0000 @@ -0,0 +1,325 @@ +/******************************************************************************* +**3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 +** 10 20 30 40 50 60 70 80 +** +** notify-osd +** +** defaults-xfconf.h - xfconf framework for the notify-osd defaults class +** +** Copyright 2009 Canonical Ltd. +** +** Authors: +** Steve Dodier +** +** This program is free software: you can redistribute it and/or modify it +** under the terms of the GNU General Public License version 3, as published +** by the Free Software Foundation. +** +** This program is distributed in the hope that it will be useful, but +** WITHOUT ANY WARRANTY; without even the implied warranties of +** MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR +** PURPOSE. See the GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License along +** with this program. If not, see . +** +*******************************************************************************/ + +#include + +#include "defaults.h" +#include "defaults-xfconf.h" + + +GString* +conf_get_font(ConfData* d, + gchar* fallback) +{ + GString* dest = NULL; + gchar* xfconf_fontname = NULL; + + xfconf_fontname = xfconf_channel_get_string (d->chan_xs, + XFCONF_FONT_NAME, + fallback); + dest = g_string_new (xfconf_fontname); + g_free (xfconf_fontname); + + return dest; +} + + +gdouble +conf_get_dpi(ConfData* d, + gdouble fallback) +{ + gdouble dest = 0.0f; + dest = xfconf_channel_get_int (d->chan_xs, + XFCONF_FONT_DPI, + -1); + + /* -1 means there is no custom DPI */ + if (dest == -1.0) + dest = fallback; + + return dest; +} + +gdouble +conf_get_text_title_size(ConfData* d, + gdouble fallback) +{ + return xfconf_channel_get_double (d->chan_no, + XFCONF_TEXT_TITLE_SIZE, + fallback); +} + +gchar* +conf_get_bubble_shadow_color(ConfData* d, + gchar* fallback) +{ + return xfconf_channel_get_string (d->chan_no, XFCONF_BUBBLE_SHADOW_COLOR, fallback); +} + +gchar* +conf_get_bubble_bg_color(ConfData* d, + gchar* fallback) +{ + return xfconf_channel_get_string (d->chan_no, XFCONF_BUBBLE_BG_COLOR, fallback); +} + +gdouble +conf_get_bubble_bg_opacity(ConfData* d, + gdouble fallback) +{ + return xfconf_channel_get_double (d->chan_no, XFCONF_BUBBLE_BG_OPACITY, fallback); +} + +gdouble +conf_get_bubble_hover_opacity(ConfData* d, + gdouble fallback) +{ + return xfconf_channel_get_double (d->chan_no, XFCONF_BUBBLE_HOVER_OPACITY, fallback); +} + +gchar* +conf_get_content_shadow_color(ConfData* d, + gchar* fallback) +{ + return xfconf_channel_get_string (d->chan_no, XFCONF_CONTENT_SHADOW_COLOR, fallback); +} + +gchar* +conf_get_text_title_color(ConfData* d, + gchar* fallback) +{ + return xfconf_channel_get_string (d->chan_no, XFCONF_TEXT_TITLE_COLOR, fallback); +} + +gchar* +conf_get_text_body_color(ConfData* d, + gchar* fallback) +{ + return xfconf_channel_get_string (d->chan_no, XFCONF_TEXT_BODY_COLOR, fallback); +} + +gdouble +conf_get_text_body_size(ConfData* d, + gdouble fallback) +{ + return xfconf_channel_get_double (d->chan_no, + XFCONF_TEXT_BODY_SIZE, + fallback); +} + +gboolean +conf_multihead_does_focus_follow(ConfData* d, + gboolean fallback) +{ + gboolean mode = fallback; + gchar* mode_str = NULL; + + mode_str = xfconf_channel_get_string (d->chan_no, + XFCONF_MULTIHEAD_MODE, + NULL); + + if (mode_str != NULL) + { + if (g_strcmp0 (mode_str, "focus-follow") == 0) + mode = TRUE; + g_free (mode_str); + } + + return mode; +} + +static void +_xfconf_xsettings_handler(XfconfChannel* channel, + const gchar* property_name, + const GValue* value, + gpointer* ptr) +{ + // If defaults not properly passed, return + Defaults* defaults = (Defaults*) ptr; + if ((!defaults) || (!IS_DEFAULTS (defaults))) + return; + + // Happens when a property is removed, we shouldn't handle it + if (G_VALUE_TYPE(value) == G_TYPE_INVALID) + return; + + if ((g_strcmp0(property_name, XFCONF_FONT_NAME) == 0) || + (g_strcmp0(property_name, XFCONF_FONT_DPI) == 0)) + { + /* grab system-wide font-face/size and DPI */ + _get_font_size_dpi (defaults); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if ((g_strcmp0(property_name, XFCONF_FONT_ANTIALIAS) == 0) || + (g_strcmp0(property_name, XFCONF_FONT_SUBPX_ORDER) == 0) || + (g_strcmp0(property_name, XFCONF_FONT_HINTING) == 0) || + (g_strcmp0(property_name, XFCONF_FONT_HINT_STYLE) == 0)) + { + /* just triggering a redraw by emitting the "value-changed" signal is + ** enough in this case, no need to update any stored values */ + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } +} + +static void +_xfconf_notifyosd_handler(XfconfChannel* channel, + const gchar* property_name, + const GValue* value, + gpointer* ptr) +{ + // If defaults not properly passed, return + Defaults* defaults = (Defaults*) ptr; + if ((!defaults) || (!IS_DEFAULTS (defaults))) + return; + + if (g_strcmp0(property_name, XFCONF_BUBBLE_SHADOW_COLOR) == 0) + { + /* update the bubble shadow color */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_STRING(value))) + defaults_set_bubble_shadow_color (defaults, DEFAULT_BUBBLE_SHADOW_COLOR); + else + defaults_set_bubble_shadow_color (defaults, g_value_get_string (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_BUBBLE_BG_COLOR) == 0) + { + /* update the bubble bg color */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_STRING(value))) + defaults_set_bubble_bg_color (defaults, DEFAULT_BUBBLE_BG_COLOR); + else + defaults_set_bubble_bg_color (defaults, g_value_get_string (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_BUBBLE_BG_OPACITY) == 0) + { + /* update the bubble bg color */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_DOUBLE(value))) + defaults_set_bubble_bg_opacity (defaults, DEFAULT_BUBBLE_BG_OPACITY); + else + defaults_set_bubble_bg_opacity (defaults, g_value_get_double (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_BUBBLE_HOVER_OPACITY) == 0) + { + /* update the bubble bg color */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_DOUBLE(value))) + defaults_set_bubble_hover_opacity (defaults, DEFAULT_BUBBLE_HOVER_OPACITY); + else + defaults_set_bubble_hover_opacity (defaults, g_value_get_double (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_CONTENT_SHADOW_COLOR) == 0) + { + /* update the content shadow color */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_STRING(value))) + defaults_set_content_shadow_color (defaults, DEFAULT_CONTENT_SHADOW_COLOR); + else + defaults_set_content_shadow_color (defaults, g_value_get_string (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_TEXT_TITLE_COLOR) == 0) + { + /* update the text title color */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_STRING(value))) + defaults_set_text_title_color (defaults, DEFAULT_TEXT_TITLE_COLOR); + else + defaults_set_text_title_color (defaults, g_value_get_string (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_TEXT_BODY_COLOR) == 0) + { + /* update the text body color */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_STRING(value))) + defaults_set_text_body_color (defaults, DEFAULT_TEXT_BODY_COLOR); + else + defaults_set_text_body_color (defaults, g_value_get_string (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_TEXT_TITLE_SIZE) == 0) + { + /* update the text title size */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_DOUBLE(value))) + defaults_set_text_title_size (defaults, DEFAULT_TEXT_TITLE_SIZE); + else + defaults_set_text_title_size (defaults, g_value_get_double (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } + + else if (g_strcmp0(property_name, XFCONF_TEXT_BODY_SIZE) == 0) + { + /* update the text body size */ + if ((G_VALUE_TYPE(value) == G_TYPE_INVALID) || (!G_VALUE_HOLDS_DOUBLE(value))) + defaults_set_text_body_size (defaults, DEFAULT_TEXT_BODY_SIZE); + else + defaults_set_text_body_size (defaults, g_value_get_double (value)); + g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + } +} + +void +conf_defaults_dispose(Defaults* defaults) +{ + g_signal_handlers_disconnect_by_func(G_OBJECT (defaults->conf->chan_xs), + G_CALLBACK (_xfconf_xsettings_handler), defaults); + g_signal_handlers_disconnect_by_func(G_OBJECT (defaults->conf->chan_no), + G_CALLBACK (_xfconf_notifyosd_handler), defaults); + xfconf_shutdown(); +} + +gboolean +conf_defaults_init(Defaults* defaults) +{ + GError* error = NULL; + + /* initialize xfconf itself */ + if (FALSE == xfconf_init (&error)) + { + g_warning ("%s\n", error->message); + g_error_free (error); + return FALSE; + } + + /* initialize the xfconf xsettings channel */ + defaults->conf->chan_xs = xfconf_channel_get (XFCONF_CHANNEL_XSETTINGS); + g_signal_connect (G_OBJECT (defaults->conf->chan_xs), "property-changed", + G_CALLBACK (_xfconf_xsettings_handler), defaults); + + /* initialize the xfconf notify-osd channel */ + defaults->conf->chan_no = xfconf_channel_get (XFCONF_CHANNEL_NOTIFYOSD); + g_signal_connect (G_OBJECT (defaults->conf->chan_no), "property-changed", + G_CALLBACK (_xfconf_notifyosd_handler), defaults); + + return TRUE; +} === added file 'src/defaults-xfconf.h' --- src/defaults-xfconf.h 1970-01-01 00:00:00 +0000 +++ src/defaults-xfconf.h 2009-08-18 19:14:30 +0000 @@ -0,0 +1,70 @@ +/******************************************************************************* +**3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 +** 10 20 30 40 50 60 70 80 +** +** notify-osd +** +** defaults-xfconf.h - xfconf framework for the notify-osd defaults class +** +** Copyright 2009 Canonical Ltd. +** +** Authors: +** Steve Dodier +** +** This program is free software: you can redistribute it and/or modify it +** under the terms of the GNU General Public License version 3, as published +** by the Free Software Foundation. +** +** This program is distributed in the hope that it will be useful, but +** WITHOUT ANY WARRANTY; without even the implied warranties of +** MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR +** PURPOSE. See the GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License along +** with this program. If not, see . +** +*******************************************************************************/ + +#ifndef __DEFAULTS_CONF_H +#define __DEFAULTS_CONF_H + +#include + + +/* Xfconf channels to watch */ +#define XFCONF_CHANNEL_XSETTINGS "xsettings" +#define XFCONF_CHANNEL_NOTIFYOSD "notify-osd" + +/* Xfconf keys to watch in xsettings */ +#define XFCONF_FONT_NAME "/Gtk/FontName" +#define XFCONF_FONT_ANTIALIAS "/Xft/Antialias" +#define XFCONF_FONT_HINTING "/Xft/Hinting" +#define XFCONF_FONT_HINT_STYLE "/Xft/HintStyle" +#define XFCONF_FONT_SUBPX_ORDER "/Xft/RGBA" +#define XFCONF_FONT_DPI "/Xft/DPI" + +/* Xfconf keys to watch in notify-osd */ +#define XFCONF_MULTIHEAD_MODE "/MultiheadMode" +#define XFCONF_BUBBLE_SHADOW_COLOR "/appearence/BubbleShadowColor" +#define XFCONF_BUBBLE_BG_COLOR "/appearence/BubbleBgColor" +#define XFCONF_BUBBLE_BG_OPACITY "/appearence/BubbleBgOpacity" +#define XFCONF_BUBBLE_HOVER_OPACITY "/appearence/BubbleHoverOpacity" +#define XFCONF_CONTENT_SHADOW_COLOR "/appearence/ContentShadowColor" +#define XFCONF_TEXT_TITLE_COLOR "/appearence/TextTitleColor" +#define XFCONF_TEXT_BODY_COLOR "/appearence/TextBodyColor" +#define XFCONF_TEXT_TITLE_SIZE "/accessibility/TextTitleSize" +#define XFCONF_TEXT_BODY_SIZE "/accessibility/TextBodySize" + + +G_BEGIN_DECLS + +struct _XfconfData { + XfconfChannel *chan_xs; //xsettings + XfconfChannel *chan_no; //notify-osd +}; + +typedef struct _XfconfData ConfData; + +G_END_DECLS + +#endif /* __DEFAULTS_CONF_H */ === modified file 'src/defaults.c' --- src/defaults.c 2009-08-04 08:53:17 +0000 +++ src/defaults.c 2009-08-20 22:04:48 +0000 @@ -34,7 +34,6 @@ #include #include #include -#include #include #include #include @@ -108,66 +107,28 @@ TEXT_WEIGHT_BOLD = 700 /* QFont::Bold 75 */ }; -/* these values are interpreted as em-measurements and do comply to the - * visual guide for jaunty-notifications */ -#define DEFAULT_DESKTOP_BOTTOM_GAP 6.0f -#define DEFAULT_BUBBLE_WIDTH 24.0f -#define DEFAULT_BUBBLE_MIN_HEIGHT 5.0f -#define DEFAULT_BUBBLE_MAX_HEIGHT 12.2f -#define DEFAULT_BUBBLE_VERT_GAP 0.5f -#define DEFAULT_BUBBLE_HORZ_GAP 0.5f -#define DEFAULT_BUBBLE_SHADOW_SIZE 0.7f -#define DEFAULT_BUBBLE_SHADOW_COLOR "#000000" -#define DEFAULT_BUBBLE_BG_COLOR "#131313" -#define DEFAULT_BUBBLE_BG_OPACITY "#cc" -#define DEFAULT_BUBBLE_HOVER_OPACITY "#66" -#define DEFAULT_BUBBLE_CORNER_RADIUS 0.375f -#define DEFAULT_CONTENT_SHADOW_SIZE 0.125f -#define DEFAULT_CONTENT_SHADOW_COLOR "#000000" -#define DEFAULT_MARGIN_SIZE 1.0f -#define DEFAULT_ICON_SIZE 3.0f -#define DEFAULT_GAUGE_SIZE 0.625f -#define DEFAULT_GAUGE_OUTLINE_WIDTH 0.125f -#define DEFAULT_TEXT_FONT_FACE "Sans" -#define DEFAULT_TEXT_TITLE_COLOR "#ffffff" -#define DEFAULT_TEXT_TITLE_WEIGHT TEXT_WEIGHT_BOLD -#define DEFAULT_TEXT_TITLE_SIZE 1.0f -#define DEFAULT_TEXT_BODY_COLOR "#eaeaea" -#define DEFAULT_TEXT_BODY_WEIGHT TEXT_WEIGHT_NORMAL -#define DEFAULT_TEXT_BODY_SIZE 0.8f -#define DEFAULT_PIXELS_PER_EM 10.0f -#define DEFAULT_SYSTEM_FONT_SIZE 10.0f -#define DEFAULT_SCREEN_DPI 96.0f - -/* these values are interpreted as milliseconds-measurements and do comply to - * the visual guide for jaunty-notifications */ -#define DEFAULT_FADE_IN_TIMEOUT 250 -#define DEFAULT_FADE_OUT_TIMEOUT 1000 -#define DEFAULT_ON_SCREEN_TIMEOUT 10000 - -/* GConf-keys to watch */ -#define GCONF_UI_FONT_NAME "/desktop/gnome/interface/font_name" -#define GCONF_FONT_ANTIALIAS "/desktop/gnome/font_rendering/antialiasing" -#define GCONF_FONT_DPI "/desktop/gnome/font_rendering/dpi" -#define GCONF_FONT_HINTING "/desktop/gnome/font_rendering/hinting" -#define GCONF_FONT_SUBPIXEL_ORDER "/desktop/gnome/font_rendering/rgba_order" - -/* GConf-trees to watch */ -#define GCONF_UI_TREE "/desktop/gnome/interface" -#define GCONF_FONT_TREE "/desktop/gnome/font_rendering" - -/* notify-osd settings */ -#define GCONF_MULTIHEAD_MODE "/apps/notify-osd/multihead_mode" - +/*-- signals -----------------------------------------------------------------*/ static guint g_defaults_signals[LAST_SIGNAL] = { 0 }; +/*-- internal functions that the configuration framework may call ------------*/ +static void _get_font_size_dpi (Defaults* self); +static void _get_text_size (Defaults* self); +static void _get_colors_and_opacity (Defaults* self); + +/*-- configuration framework to use ------------------------------------------*/ +#if defined __USE_GCONF +#include "defaults-gconf.c" +#elif defined __USE_XFCONF +#include "defaults-xfconf.c" +#else +#include "defaults-gconf.c" +#endif + /*-- internal API ------------------------------------------------------------*/ - static void _get_font_size_dpi (Defaults* self) { GString* string = NULL; - GError* error = NULL; GScanner* scanner = NULL; GTokenType token = G_TOKEN_NONE; gint points = 0; @@ -179,15 +140,7 @@ return; /* determine current system font-name/size */ - error = NULL; - string = g_string_new (gconf_client_get_string (self->context, - GCONF_UI_FONT_NAME, - &error)); - if (error) - { - /* if something went wrong, assume "Sans 10" and continue */ - string = g_string_assign (string, "Sans 10"); - } + string = conf_get_font(self->conf, "Sans 10"); /* extract font-family-name and font-size */ scanner = g_scanner_new (NULL); @@ -230,139 +183,104 @@ /* update stored font-face name and clean up */ if (font_face != NULL) { - g_object_set (self, "text-font-face", font_face->str, NULL); + defaults_set_text_font_face (self, font_face->str); g_string_free (font_face, TRUE); } /* update stored system-font size (in pt!) */ - g_object_set (self, "system-font-size", (gdouble) points, NULL); + defaults_set_system_font_size (self, (gdouble) points); /* determine current system DPI-setting */ - error = NULL; - dpi = gconf_client_get_float (self->context, GCONF_FONT_DPI, &error); - if (error) - { - // if something went wrong, assume 96 DPI and continue - dpi = DEFAULT_SCREEN_DPI; - } + dpi = conf_get_dpi(self->conf, DEFAULT_SCREEN_DPI); /* update stored DPI-value */ pixels_per_em = (gdouble) points * dpi / 72.0f; - g_object_set (self, "pixels-per-em", pixels_per_em, NULL); - g_object_set (self, "screen-dpi", dpi, NULL); + defaults_set_pixel_per_em (self, pixels_per_em); + defaults_set_screen_dpi (self, dpi); if (g_getenv ("DEBUG")) - g_print ("font-size: %dpt\ndpi: %3.1f\npixels/EM: %2.2f\nwidth: %d px\ntitle-height: %2.2f pt\nbody-height: %2.2f pt\n\n", - points, + g_print ("font-size: %fpt\ndpi: %3.1f\npixels/EM: %2.2f\nwidth: %d px\ntitle-height: %2.2f pt\nbody-height: %2.2f pt\n\n", + defaults_get_system_font_size (self), defaults_get_screen_dpi (self), - pixels_per_em, - (gint) (pixels_per_em * DEFAULT_BUBBLE_WIDTH), - defaults_get_system_font_size (self) * - defaults_get_text_title_size (self), - defaults_get_system_font_size (self) * - defaults_get_text_body_size (self)); -} - -static void -_font_changed (GConfClient* client, - guint cnxn_id, - GConfEntry* entry, - gpointer data) -{ - Defaults* defaults; - - if (!data) - return; - - defaults = (Defaults*) data; - if (!IS_DEFAULTS (defaults)) - return; - - /* grab system-wide font-face/size and DPI */ - _get_font_size_dpi (defaults); - - g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); -} - -static void -_antialias_changed (GConfClient* client, - guint cnxn_id, - GConfEntry* entry, - gpointer data) -{ - Defaults* defaults; - - if (!data) - return; - - defaults = (Defaults*) data; - if (!IS_DEFAULTS (defaults)) - return; - - /* just triggering a redraw by emitting the "value-changed" signal is - ** enough in this case, no need to update any stored values */ - g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); -} - -static void -_dpi_changed (GConfClient* client, - guint cnxn_id, - GConfEntry* entry, - gpointer data) -{ - Defaults* defaults; - - if (!data) - return; - - defaults = (Defaults*) data; - if (!IS_DEFAULTS (defaults)) - return; - - /* grab system-wide font-face/size and DPI */ - _get_font_size_dpi (defaults); - - g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); -} - -static void -_hinting_changed (GConfClient* client, - guint cnxn_id, - GConfEntry* entry, - gpointer data) -{ - Defaults* defaults; - - if (!data) - return; - - defaults = (Defaults*) data; - if (!IS_DEFAULTS (defaults)) - return; - - /* just triggering a redraw by emitting the "value-changed" signal is - ** enough in this case, no need to update any stored values */ - g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); -} - -static void -_subpixel_order_changed (GConfClient* client, - guint cnxn_id, - GConfEntry* entry, - gpointer data) -{ - Defaults* defaults; - - if (!data) - return; - - defaults = (Defaults*) data; - if (!IS_DEFAULTS (defaults)) - return; - - /* just triggering a redraw by emitting the "value-changed" signal is - ** enough in this case, no need to update any stored values */ - g_signal_emit (defaults, g_defaults_signals[VALUE_CHANGED], 0); + defaults_get_pixel_per_em (self), + (gint) (defaults_get_pixel_per_em (self) * DEFAULT_BUBBLE_WIDTH), + defaults_get_system_font_size (self) * + defaults_get_text_title_size (self), + defaults_get_system_font_size (self) * + defaults_get_text_body_size (self)); +} + +static void +_get_text_size (Defaults* self) +{ + gdouble title_size = 0.0f; + gdouble body_size = 0.0f; + + if (!IS_DEFAULTS (self)) + return; + + /* determine current text-title size */ + title_size = conf_get_text_title_size(self->conf, DEFAULT_TEXT_TITLE_SIZE); + + /* determine current text-body size */ + body_size = conf_get_text_body_size(self->conf, DEFAULT_TEXT_BODY_SIZE); + + /* apply values to self */ + defaults_set_text_title_size (self, title_size); + defaults_set_text_body_size (self, body_size); + + if (g_getenv ("DEBUG")) + g_print ("text-title-size: %.2f\ntext-body-size: %.2f\n", + defaults_get_text_title_size (self), + defaults_get_text_body_size (self)); +} + +static void +_get_colors_and_opacity (Defaults* self) +{ + gchar* bubble_shadow = NULL; + gchar* bubble_bg = NULL; + gdouble bubble_bg_opacity = 0.0f; + gdouble bubble_hover_opacity = 0.0f; + gchar* content_shadow = NULL; + gchar* text_title = NULL; + gchar* text_body = NULL; + + if (!IS_DEFAULTS (self)) + return; + + bubble_shadow = conf_get_bubble_shadow_color (self->conf, DEFAULT_BUBBLE_SHADOW_COLOR); + bubble_bg = conf_get_bubble_bg_color (self->conf, DEFAULT_BUBBLE_BG_COLOR); + bubble_bg_opacity = conf_get_bubble_bg_opacity (self->conf, DEFAULT_BUBBLE_BG_OPACITY); + bubble_hover_opacity = conf_get_bubble_hover_opacity (self->conf, DEFAULT_BUBBLE_HOVER_OPACITY); + content_shadow = conf_get_content_shadow_color (self->conf, DEFAULT_CONTENT_SHADOW_COLOR); + text_title = conf_get_text_title_color (self->conf, DEFAULT_TEXT_TITLE_COLOR); + text_body = conf_get_text_body_color (self->conf, DEFAULT_TEXT_BODY_COLOR); + + /* apply values to self */ + defaults_set_bubble_shadow_color (self, bubble_shadow); + defaults_set_bubble_bg_color (self, bubble_bg); + defaults_set_bubble_bg_opacity (self, bubble_bg_opacity); + defaults_set_bubble_hover_opacity (self, bubble_hover_opacity); + defaults_set_content_shadow_color (self, content_shadow); + defaults_set_text_title_color (self, text_title); + defaults_set_text_body_color (self, text_body); + + if (g_getenv ("DEBUG")) + g_print ("bubble-shadow: %s\nbubble-bg: %s\nbubble-bg-opacity: %f\nbubble-hover-opacity: %f\ncontent-shadow: %s\ntext-title: %s\ntext-body: %s\n", + defaults_get_bubble_shadow_color (self), + defaults_get_bubble_bg_color (self), + defaults_get_bubble_bg_opacity (self), + defaults_get_bubble_hover_opacity (self), + defaults_get_content_shadow_color (self), + defaults_get_text_title_color (self), + defaults_get_text_body_color (self)); + + g_free (bubble_shadow); + g_free (bubble_bg); + g_free (content_shadow); + g_free (text_title); + g_free (text_body); } static gdouble @@ -456,35 +374,14 @@ if (result == Success && items_read) { - g_object_set (self, - "desktop-width", - (gint) coords[2], - NULL); - g_object_set (self, - "desktop-height", - (gint) coords[3], - NULL); - g_object_set (self, - "desktop-top", - (gint) coords[1], - NULL); - g_object_set (self, - "desktop-bottom", - (gint) coords[3], - NULL); - g_object_set (self, - "desktop-left", - (gint) coords[0], - NULL); - g_object_set (self, - "desktop-right", - (gint) coords[2], - NULL); + defaults_set_desktop_width (self, (gint) coords[2]); + defaults_set_desktop_height (self, (gint) coords[3]); + defaults_set_desktop_top (self, (gint) coords[1]); + defaults_set_desktop_bottom (self, (gint) coords[3]); + defaults_set_desktop_left (self, (gint) coords[0]); + defaults_set_desktop_right (self, (gint) coords[2]); /* FIXME: use new upper and lower threshold/limits for stack */ - /*g_object_set (self, - "stack-height", - (gint) coords[3] / 2, - NULL);*/ + /* defaults_set_stack_height (self, (gint) coords[3] / 2); */ XFree (coords); } } @@ -507,7 +404,13 @@ /* grab system-wide font-face/size and DPI */ _get_font_size_dpi (self); - + + /* grab text size ratios */ + _get_text_size (self); + + /* grab colors and opacity settings */ + _get_colors_and_opacity (self); + /* correct the default min. bubble-height, according to the icon-size */ g_object_get (self, "margin-size", @@ -534,10 +437,7 @@ if (new_bubble_height > bubble_height) { - g_object_set (self, - "bubble-min-height", - new_bubble_height, - NULL); + defaults_set_bubble_min_height (self, new_bubble_height); } /* correct the default bubble-width depending on the average width of a @@ -559,10 +459,7 @@ 20.0f * average_char_width; /*if (new_bubble_width > bubble_width) { - g_object_set (self, - "bubble-width", - new_bubble_width, - NULL); + defaults_set_bubble_width (self, new_bubble_width); }*/ /* FIXME: calling this here causes a segfault */ @@ -576,15 +473,9 @@ Defaults* defaults; defaults = DEFAULTS (gobject); - - gconf_client_notify_remove (defaults->context, defaults->notifier[0]); - gconf_client_notify_remove (defaults->context, defaults->notifier[1]); - gconf_client_notify_remove (defaults->context, defaults->notifier[2]); - gconf_client_notify_remove (defaults->context, defaults->notifier[3]); - gconf_client_notify_remove (defaults->context, defaults->notifier[4]); - gconf_client_remove_dir (defaults->context, GCONF_UI_TREE, NULL); - gconf_client_remove_dir (defaults->context, GCONF_FONT_TREE, NULL); - g_object_unref (defaults->context); + + conf_defaults_dispose(defaults); + g_free (defaults->conf); if (defaults->bubble_shadow_color) { @@ -598,18 +489,6 @@ defaults->bubble_bg_color = NULL; } - if (defaults->bubble_bg_opacity) - { - g_string_free (defaults->bubble_bg_opacity, TRUE); - defaults->bubble_bg_opacity = NULL; - } - - if (defaults->bubble_hover_opacity) - { - g_string_free (defaults->bubble_hover_opacity, TRUE); - defaults->bubble_hover_opacity = NULL; - } - if (defaults->content_shadow_color) { g_string_free (defaults->content_shadow_color, TRUE); @@ -648,137 +527,9 @@ static void defaults_init (Defaults* self) { - GError* error; - - /* "connect" to the whole gconf-thing */ - self->context = gconf_client_get_default (); - if (!self->context) - { - g_warning ("Could not get GConf client-context"); - return; - } - - /* register watching all relevant GNOME UI-settings */ - error = NULL; - gconf_client_add_dir (self->context, - GCONF_UI_TREE, - GCONF_CLIENT_PRELOAD_NONE, - &error); - if (error) - { - g_object_unref (self->context); - g_warning ("%s\n", error->message); - return; - } - - /* register watching all font-settings */ - error = NULL; - gconf_client_add_dir (self->context, - GCONF_FONT_TREE, - GCONF_CLIENT_PRELOAD_NONE, - &error); - if (error) - { - gconf_client_remove_dir (self->context, GCONF_UI_TREE, NULL); - g_object_unref (self->context); - g_warning ("%s\n", error->message); - return; - } - - /* hook up notifier for font-name/size changes */ - error = NULL; - self->notifier[0] = gconf_client_notify_add (self->context, - GCONF_UI_FONT_NAME, - _font_changed, - (gpointer) self, - NULL, - &error); - if (error) - { - gconf_client_remove_dir (self->context, GCONF_UI_TREE, NULL); - gconf_client_remove_dir (self->context, GCONF_FONT_TREE, NULL); - g_object_unref (self->context); - g_warning ("%s\n", error->message); - return; - } - - /* hook up notifier for antialiasing changes */ - error = NULL; - self->notifier[1] = gconf_client_notify_add (self->context, - GCONF_FONT_ANTIALIAS, - _antialias_changed, - (gpointer) self, - NULL, - &error); - if (error) - { - gconf_client_notify_remove (self->context, self->notifier[0]); - gconf_client_remove_dir (self->context, GCONF_UI_TREE, NULL); - gconf_client_remove_dir (self->context, GCONF_FONT_TREE, NULL); - g_object_unref (self->context); - g_warning ("%s\n", error->message); - return; - } - - /* hook up notifier for DPI changes */ - error = NULL; - self->notifier[2] = gconf_client_notify_add (self->context, - GCONF_FONT_DPI, - _dpi_changed, - (gpointer) self, - NULL, - &error); - if (error) - { - gconf_client_notify_remove (self->context, self->notifier[0]); - gconf_client_notify_remove (self->context, self->notifier[1]); - gconf_client_remove_dir (self->context, GCONF_UI_TREE, NULL); - gconf_client_remove_dir (self->context, GCONF_FONT_TREE, NULL); - g_object_unref (self->context); - g_warning ("%s\n", error->message); - return; - } - - /* hook up notifier for hinting changes */ - error = NULL; - self->notifier[3] = gconf_client_notify_add (self->context, - GCONF_FONT_HINTING, - _hinting_changed, - (gpointer) self, - NULL, - &error); - if (error) - { - gconf_client_notify_remove (self->context, self->notifier[0]); - gconf_client_notify_remove (self->context, self->notifier[1]); - gconf_client_notify_remove (self->context, self->notifier[2]); - gconf_client_remove_dir (self->context, GCONF_UI_TREE, NULL); - gconf_client_remove_dir (self->context, GCONF_FONT_TREE, NULL); - g_object_unref (self->context); - g_warning ("%s\n", error->message); - return; - } - - /* hook up notifier for subpixel-order changes */ - error = NULL; - self->notifier[4] = gconf_client_notify_add (self->context, - GCONF_FONT_SUBPIXEL_ORDER, - _subpixel_order_changed, - (gpointer) self, - NULL, - &error); - if (error) - { - gconf_client_notify_remove (self->context, self->notifier[0]); - gconf_client_notify_remove (self->context, self->notifier[1]); - gconf_client_notify_remove (self->context, self->notifier[2]); - gconf_client_notify_remove (self->context, self->notifier[3]); - gconf_client_remove_dir (self->context, GCONF_UI_TREE, NULL); - gconf_client_remove_dir (self->context, GCONF_FONT_TREE, NULL); - g_object_unref (self->context); - g_warning ("%s\n", error->message); - return; - } + self->conf = g_malloc(sizeof(ConfData)); + if (!conf_defaults_init(self)) + return; } static void @@ -860,13 +611,11 @@ break; case PROP_BUBBLE_BG_OPACITY: - g_value_set_string (value, - defaults->bubble_bg_opacity->str); + g_value_set_double (value, defaults->bubble_bg_opacity); break; case PROP_BUBBLE_HOVER_OPACITY: - g_value_set_string (value, - defaults->bubble_hover_opacity->str); + g_value_set_double (value, defaults->bubble_hover_opacity); break; case PROP_BUBBLE_CORNER_RADIUS: @@ -1047,23 +796,11 @@ break; case PROP_BUBBLE_BG_OPACITY: - if (defaults->bubble_bg_opacity != NULL) - { - g_string_free (defaults->bubble_bg_opacity, - TRUE); - } - defaults->bubble_bg_opacity = g_string_new ( - g_value_get_string (value)); + defaults->bubble_bg_opacity = g_value_get_double (value); break; case PROP_BUBBLE_HOVER_OPACITY: - if (defaults->bubble_hover_opacity != NULL) - { - g_string_free (defaults->bubble_hover_opacity, - TRUE); - } - defaults->bubble_hover_opacity = g_string_new ( - g_value_get_string (value)); + defaults->bubble_hover_opacity = g_value_get_double (value); break; case PROP_BUBBLE_CORNER_RADIUS: @@ -1241,8 +978,8 @@ "desktop-width", "desktop-width", "Width of desktop in pixels", - 0, - 4096, + DESKTOP_WIDTH_MIN, + DESKTOP_WIDTH_MAX, gdk_screen_get_width (screen), G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1254,8 +991,8 @@ "desktop-height", "desktop-height", "Height of desktop in pixels", - 0, - 4096, + DESKTOP_HEIGHT_MIN, + DESKTOP_HEIGHT_MAX, gdk_screen_get_height (screen), G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1267,8 +1004,8 @@ "desktop-top", "desktop-top", "Top of desktop in pixels", - 0, - 4096, + DESKTOP_TOP_MIN, + DESKTOP_TOP_MAX, 0, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1280,8 +1017,8 @@ "desktop-bottom", "desktop-bottom", "Bottom of desktop in pixels", - 0, - 4096, + DESKTOP_BOTTOM_MIN, + DESKTOP_BOTTOM_MAX, 4096, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1293,8 +1030,8 @@ "desktop-left", "desktop-left", "Left of desktop in pixels", - 0, - 4096, + DESKTOP_LEFT_MIN, + DESKTOP_LEFT_MAX, 0, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1306,8 +1043,8 @@ "desktop-right", "desktop-right", "Right of desktop in pixels", - 0, - 4096, + DESKTOP_RIGHT_MIN, + DESKTOP_RIGHT_MAX, 4096, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1319,8 +1056,8 @@ "desktop-bottom-gap", "desktop-bottom-gap", "Bottom gap on the desktop in em", - 0.0f, - 16.0f, + DESKTOP_BOTTOM_GAP_MIN, + DESKTOP_BOTTOM_GAP_MAX, DEFAULT_DESKTOP_BOTTOM_GAP, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1332,8 +1069,8 @@ "stack-height", "stack-height", "Maximum allowed height of stack (in em)", - 0.0f, - 256.0f, + STACK_HEIGHT_MIN, + STACK_HEIGHT_MAX, 50.0f, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1345,8 +1082,8 @@ "bubble-vert-gap", "bubble-vert-gap", "Vert. gap between bubble and workarea edge (in em)", - 0.0f, - 10.0f, + BUBBLE_VERT_GAP_MIN, + BUBBLE_VERT_GAP_MAX, DEFAULT_BUBBLE_VERT_GAP, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1358,8 +1095,8 @@ "bubble-horz-gap", "bubble-horz-gap", "Horz. gap between bubble and workarea edge (in em)", - 0.0f, - 10.0f, + BUBBLE_HORZ_GAP_MIN, + BUBBLE_HORZ_GAP_MAX, DEFAULT_BUBBLE_HORZ_GAP, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1371,8 +1108,8 @@ "bubble-width", "bubble-width", "Width of bubble (in em)", - 0.0f, - 256.0f, + BUBBLE_WIDTH_MIN, + BUBBLE_WIDTH_MAX, DEFAULT_BUBBLE_WIDTH, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1384,8 +1121,8 @@ "bubble-min-height", "bubble-min-height", "Min. height of bubble (in em)", - 0.0f, - 256.0f, + BUBBLE_MIN_HEIGHT_MIN, + BUBBLE_MIN_HEIGHT_MAX, DEFAULT_BUBBLE_MIN_HEIGHT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1397,8 +1134,8 @@ "bubble-max-height", "bubble-max-height", "Max. height of bubble (in em)", - 0.0f, - 256.0f, + BUBBLE_MAX_HEIGHT_MIN, + BUBBLE_MAX_HEIGHT_MAX, DEFAULT_BUBBLE_MAX_HEIGHT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1410,8 +1147,8 @@ "bubble-shadow-size", "bubble-shadow-size", "Size (in em) of bubble drop-shadow", - 0.0f, - 32.0f, + BUBBLE_SHADOW_SIZE_MIN, + BUBBLE_SHADOW_SIZE_MAX, DEFAULT_BUBBLE_SHADOW_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1441,10 +1178,12 @@ PROP_BUBBLE_BG_COLOR, property_bubble_bg_color); - property_bubble_bg_opacity = g_param_spec_string ( + property_bubble_bg_opacity = g_param_spec_double ( "bubble-bg-opacity", "bubble-bg-opacity", "Opacity of bubble-background", + BUBBLE_BG_OPACITY_MIN, + BUBBLE_BG_OPACITY_MAX, DEFAULT_BUBBLE_BG_OPACITY, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1452,10 +1191,12 @@ PROP_BUBBLE_BG_OPACITY, property_bubble_bg_opacity); - property_bubble_hover_opacity = g_param_spec_string ( + property_bubble_hover_opacity = g_param_spec_double ( "bubble-hover-opacity", "bubble-hover-opacity", "Opacity of bubble in mouse-over case", + BUBBLE_HOVER_OPACITY_MIN, + BUBBLE_HOVER_OPACITY_MAX, DEFAULT_BUBBLE_HOVER_OPACITY, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1467,8 +1208,8 @@ "bubble-corner-radius", "bubble-corner-radius", "Corner-radius of bubble (in em)", - 0.0f, - 16.0f, + BUBBLE_CORNER_RADIUS_MIN, + BUBBLE_CORNER_RADIUS_MAX, DEFAULT_BUBBLE_CORNER_RADIUS, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1480,8 +1221,8 @@ "content-shadow-size", "content-shadow-size", "Size (in em) of icon/text drop-shadow", - 0.0f, - 8.0f, + CONTENT_SHADOW_SIZE_MIN, + CONTENT_SHADOW_SIZE_MAX, DEFAULT_CONTENT_SHADOW_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1504,8 +1245,8 @@ "margin-size", "margin-size", "Size (in em) of margin", - 0.0f, - 32.0f, + MARGIN_SIZE_MIN, + MARGIN_SIZE_MAX, DEFAULT_MARGIN_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1517,8 +1258,8 @@ "icon-size", "icon-size", "Size (in em) of icon/avatar", - 0.0f, - 64.0f, + ICON_SIZE_MIN, + ICON_SIZE_MAX, DEFAULT_ICON_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1530,8 +1271,8 @@ "gauge-size", "gauge-size", "Size/height (in em) of gauge/indicator", - 0.5f, - 1.0f, + GAUGE_SIZE_MIN, + GAUGE_SIZE_MAX, DEFAULT_GAUGE_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1543,8 +1284,8 @@ "gauge-outline-width", "gauge-outline-width", "Width/thickness (in em) of gauge-outline", - 0.1f, - 0.2f, + GAUGE_OUTLINE_WIDTH_MIN, + GAUGE_OUTLINE_WIDTH_MAX, DEFAULT_GAUGE_OUTLINE_WIDTH, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1556,8 +1297,8 @@ "fade-in-timeout", "fade-in-timeout", "Timeout for bubble fade-in in milliseconds", - 0, - 10000, + FADE_IN_TIMEOUT_MIN, + FADE_IN_TIMEOUT_MAX, DEFAULT_FADE_IN_TIMEOUT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1569,8 +1310,8 @@ "fade-out-timeout", "fade-out-timeout", "Timeout for bubble fade-out in milliseconds", - 0, - 10000, + FADE_OUT_TIMEOUT_MIN, + FADE_OUT_TIMEOUT_MAX, DEFAULT_FADE_OUT_TIMEOUT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1582,8 +1323,8 @@ "on-screen-timeout", "on-screen-timeout", "Timeout for bubble on screen in milliseconds", - 0, - 10000, + ON_SCREEN_TIMEOUT_MIN, + ON_SCREEN_TIMEOUT_MAX, DEFAULT_ON_SCREEN_TIMEOUT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1617,8 +1358,8 @@ "text-title-weight", "text-title-weight", "Weight to use for content title-text", - 0, - 1000, + TEXT_TITLE_WEIGHT_MIN, + TEXT_TITLE_WEIGHT_MAX, DEFAULT_TEXT_TITLE_WEIGHT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1630,8 +1371,8 @@ "text-title-size", "text-title-size", "Size (in em) of font to use for content title-text", - 0.0f, - 32.0f, + TEXT_TITLE_SIZE_MIN, + TEXT_TITLE_SIZE_MAX, DEFAULT_TEXT_TITLE_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1654,8 +1395,8 @@ "text-body-weight", "text-body-weight", "Weight to use for content body-text", - 0, - 1000, + TEXT_BODY_WEIGHT_MIN, + TEXT_BODY_WEIGHT_MAX, DEFAULT_TEXT_BODY_WEIGHT, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1667,8 +1408,8 @@ "text-body-size", "text-body-size", "Size (in em) of font to use for content body-text", - 0.0f, - 32.0f, + TEXT_BODY_SIZE_MIN, + TEXT_BODY_SIZE_MAX, DEFAULT_TEXT_BODY_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1680,8 +1421,8 @@ "pixels-per-em", "pixels-per-em", "Number of pixels for one em-unit", - 1.0f, - 100.0f, + PIXELS_PER_EM_MIN, + PIXELS_PER_EM_MAX, DEFAULT_PIXELS_PER_EM, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1693,8 +1434,8 @@ "system-font-size", "system-font-size", "System font-size in pt", - 1.0f, - 100.0f, + SYSTEM_FONT_SIZE_MIN, + SYSTEM_FONT_SIZE_MAX, DEFAULT_SYSTEM_FONT_SIZE, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1706,8 +1447,8 @@ "screen-dpi", "screen-dpi", "Screen DPI value", - 10.0f, - 600.0f, + SCREEN_DPI_MIN, + SCREEN_DPI_MAX, DEFAULT_SCREEN_DPI, G_PARAM_CONSTRUCT | G_PARAM_READWRITE); @@ -1967,34 +1708,28 @@ return bubble_bg_color; } -gchar* +gdouble defaults_get_bubble_bg_opacity (Defaults* self) { - gchar* bubble_bg_opacity = NULL; + gdouble bubble_bg_opacity; if (!self || !IS_DEFAULTS (self)) - return NULL; + return 0.0f; - g_object_get (self, - "bubble-bg-opacity", - &bubble_bg_opacity, - NULL); + g_object_get (self, "bubble-bg-opacity", &bubble_bg_opacity, NULL); return bubble_bg_opacity; } -gchar* +gdouble defaults_get_bubble_hover_opacity (Defaults* self) { - gchar* bubble_hover_opacity = NULL; + gdouble bubble_hover_opacity; if (!self || !IS_DEFAULTS (self)) - return NULL; + return 0.0f; - g_object_get (self, - "bubble-hover-opacity", - &bubble_hover_opacity, - NULL); + g_object_get (self, "bubble-hover-opacity", &bubble_hover_opacity, NULL); return bubble_hover_opacity; } @@ -2269,26 +2004,613 @@ return screen_dpi; } +void +defaults_set_desktop_width (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < DESKTOP_WIDTH_MIN) || (DESKTOP_WIDTH_MAX < val)) + { + g_print ("Attempted to set desktop-width to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "desktop-width", val, NULL); +} + +void +defaults_set_desktop_height (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < DESKTOP_HEIGHT_MIN) || (DESKTOP_HEIGHT_MAX < val)) + { + g_print ("Attempted to set desktop-height to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "desktop-height", val, NULL); +} + +void +defaults_set_desktop_top (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < DESKTOP_TOP_MIN) || (DESKTOP_TOP_MAX < val)) + { + g_print ("Attempted to set desktop-top to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "desktop-top", val, NULL); +} + +void +defaults_set_desktop_bottom (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < DESKTOP_BOTTOM_MIN) || (DESKTOP_BOTTOM_MAX < val)) + { + g_print ("Attempted to set desktop-bottom to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "desktop-bottom", val, NULL); +} + +void +defaults_set_desktop_left (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < DESKTOP_LEFT_MIN) || (DESKTOP_LEFT_MAX < val)) + { + g_print ("Attempted to set desktop-left to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "desktop-left", val, NULL); +} + +void +defaults_set_desktop_right (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < DESKTOP_RIGHT_MIN) || (DESKTOP_RIGHT_MAX < val)) + { + g_print ("Attempted to set desktop-right to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "desktop-right", val, NULL); +} + +void +defaults_set_desktop_bottom_gap (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < DESKTOP_BOTTOM_GAP_MIN) || (DESKTOP_BOTTOM_GAP_MAX < val)) + { + g_print ("Attempted to set desktop-bottom-gap to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "desktop-bottom-gap", val, NULL); +} + +void +defaults_set_stack_height (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < STACK_HEIGHT_MIN) || (STACK_HEIGHT_MAX < val)) + { + g_print ("Attempted to set stack-height to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "stack-height", val, NULL); +} + +void +defaults_set_bubble_width (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_WIDTH_MIN) || (BUBBLE_WIDTH_MAX < val)) + { + g_print ("Attempted to set bubble-width to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-width", val, NULL); +} + +void +defaults_set_bubble_min_height (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_MIN_HEIGHT_MIN) || (BUBBLE_MIN_HEIGHT_MAX < val)) + { + g_print ("Attempted to set bubble-min-height to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-min-height", val, NULL); +} + + +void +defaults_set_bubble_max_height (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_MAX_HEIGHT_MIN) || (BUBBLE_MAX_HEIGHT_MAX < val)) + { + g_print ("Attempted to set bubble-max-height to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-max-height", val, NULL); +} + +void +defaults_set_bubble_vert_gap (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_VERT_GAP_MIN) || (BUBBLE_VERT_GAP_MAX < val)) + { + g_print ("Attempted to set bubble-vert-gap to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-vert-gap", val, NULL); +} + +void +defaults_set_bubble_horz_gap (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_HORZ_GAP_MIN) || (BUBBLE_HORZ_GAP_MAX < val)) + { + g_print ("Attempted to set bubble-horz-gap to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-horz-gap", val, NULL); +} + +void +defaults_set_bubble_shadow_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_SHADOW_SIZE_MIN) || (BUBBLE_SHADOW_SIZE_MAX < val)) + { + g_print ("Attempted to set bubble-shadow-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-shadow-size", val, NULL); +} + +void +defaults_set_bubble_shadow_color (Defaults* self, const gchar* val) +{ + GdkColor* color = NULL; + + if (!self || !IS_DEFAULTS (self)) + return; + + color = g_malloc (sizeof (GdkColor)); + + if (!gdk_color_parse (val, color)) + { + g_print ("Attempted to set bubble-shadow-color to an invalid value : %s\n", val); + g_free (color); + return; + } + + g_free (color); + g_object_set (self, "bubble-shadow-color", val, NULL); +} + +void +defaults_set_bubble_bg_color (Defaults* self, const gchar* val) +{ + GdkColor* color = NULL; + + if (!self || !IS_DEFAULTS (self)) + return; + + color = g_malloc (sizeof (GdkColor)); + + if (!gdk_color_parse (val, color)) + { + g_print ("Attempted to set bubble-bg-color to an invalid value : %s\n", val); + g_free (color); + return; + } + + g_free (color); + g_object_set (self, "bubble-bg-color", val, NULL); +} + +void +defaults_set_bubble_bg_opacity (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_BG_OPACITY_MIN) || (BUBBLE_BG_OPACITY_MAX < val)) + { + g_print ("Attempted to set bubble-bg-opacity to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-bg-opacity", val, NULL); +} + +void +defaults_set_bubble_hover_opacity (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_HOVER_OPACITY_MIN) || (BUBBLE_HOVER_OPACITY_MAX < val)) + { + g_print ("Attempted to set bubble-hover-opacity to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-hover-opacity", val, NULL); +} + +void +defaults_set_bubble_corner_radius (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < BUBBLE_CORNER_RADIUS_MIN) || (BUBBLE_CORNER_RADIUS_MAX < val)) + { + g_print ("Attempted to set bubble-corner-radius to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "bubble-corner-radius", val, NULL); +} + +void +defaults_set_content_shadow_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < CONTENT_SHADOW_SIZE_MIN) || (CONTENT_SHADOW_SIZE_MAX < val)) + { + g_print ("Attempted to set content-shadow-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "content-shadow-size", val, NULL); +} + +void +defaults_set_content_shadow_color (Defaults* self, const gchar* val) +{ + GdkColor* color = NULL; + + if (!self || !IS_DEFAULTS (self)) + return; + + color = g_malloc (sizeof (GdkColor)); + + if (!gdk_color_parse (val, color)) + { + g_print ("Attempted to set content-shadow-color to an invalid value : %s\n", val); + g_free (color); + return; + } + + g_free (color); + g_object_set (self, "content-shadow-color", val, NULL); +} + +void +defaults_set_margin_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < MARGIN_SIZE_MIN) || (MARGIN_SIZE_MAX < val)) + { + g_print ("Attempted to set margin-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "margin-size", val, NULL); +} + +void +defaults_set_icon_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < ICON_SIZE_MIN) || (ICON_SIZE_MAX < val)) + { + g_print ("Attempted to set icon-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "icon-size", val, NULL); +} + +void +defaults_set_gauge_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < GAUGE_SIZE_MIN) || (GAUGE_SIZE_MAX < val)) + { + g_print ("Attempted to set gauge-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "gauge-size", val, NULL); +} + +void +defaults_set_gauge_outline_width (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < GAUGE_OUTLINE_WIDTH_MIN) || (GAUGE_OUTLINE_WIDTH_MAX < val)) + { + g_print ("Attempted to set gauge-outline-width to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "gauge-outline-width", val, NULL); +} + +void +defaults_set_fade_in_timeout (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < FADE_IN_TIMEOUT_MIN) || (FADE_IN_TIMEOUT_MAX < val)) + { + g_print ("Attempted to set fade-in-timeout to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "fade-in-timeout", val, NULL); +} + +void +defaults_set_fade_out_timeout (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < FADE_OUT_TIMEOUT_MIN) || (FADE_OUT_TIMEOUT_MAX < val)) + { + g_print ("Attempted to set fade-out-timeout to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "fade-out-timeout", val, NULL); +} + +void +defaults_set_on_screen_timeout (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < ON_SCREEN_TIMEOUT_MIN) || (ON_SCREEN_TIMEOUT_MAX < val)) + { + g_print ("Attempted to set on-screen-timeout to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "on-screen-timeout", val, NULL); +} + +void +defaults_set_text_font_face (Defaults* self, const gchar* val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((NULL == val) || (g_strcmp0(val, "") == 0)) + { + g_print ("Attempted to set text-font-face to an invalid value\n"); + return; + } + + g_object_set (self, "text-font-face", val, NULL); +} + +void +defaults_set_text_title_color (Defaults* self, const gchar* val) +{ + GdkColor* color = NULL; + + if (!self || !IS_DEFAULTS (self)) + return; + + color = g_malloc (sizeof (GdkColor)); + + if (!gdk_color_parse (val, color)) + { + g_print ("Attempted to set text-title-color to an invalid value : %s\n", val); + g_free (color); + return; + } + + g_free (color); + g_object_set (self, "text-title-color", val, NULL); +} + +void +defaults_set_text_title_weight (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < TEXT_TITLE_WEIGHT_MIN) || (TEXT_TITLE_WEIGHT_MAX < val)) + { + g_print ("Attempted to set text-title-weight to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "text-title-weight", val, NULL); +} + +void +defaults_set_text_title_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < TEXT_TITLE_SIZE_MIN) || (TEXT_TITLE_SIZE_MAX < val)) + { + g_print ("Attempted to set text-title-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "text-title-size", val, NULL); +} + +void +defaults_set_text_body_color (Defaults* self, const gchar* val) +{ + GdkColor* color = NULL; + + if (!self || !IS_DEFAULTS (self)) + return; + + color = g_malloc (sizeof (GdkColor)); + + if (!gdk_color_parse (val, color)) + { + g_print ("Attempted to set text-body-color to an invalid value : %s\n", val); + g_free (color); + return; + } + + g_free (color); + g_object_set (self, "text-body-color", val, NULL); +} + +void +defaults_set_text_body_weight (Defaults* self, const gint val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < TEXT_BODY_WEIGHT_MIN) || (TEXT_BODY_WEIGHT_MAX < val)) + { + g_print ("Attempted to set text-body-weight to an out-of-bounds value : %d\n", val); + return; + } + + g_object_set (self, "text-body-weight", val, NULL); +} + +void +defaults_set_text_body_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < TEXT_BODY_SIZE_MIN) || (TEXT_BODY_SIZE_MAX < val)) + { + g_print ("Attempted to set text-body-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "text-body-size", val, NULL); +} + +void +defaults_set_pixel_per_em (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < PIXELS_PER_EM_MIN) || (PIXELS_PER_EM_MAX < val)) + { + g_print ("Attempted to set pixels-per-em to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "pixels-per-em", val, NULL); +} + +void +defaults_set_system_font_size (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < SYSTEM_FONT_SIZE_MIN) || (SYSTEM_FONT_SIZE_MAX < val)) + { + g_print ("Attempted to set system-font-size to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "system-font-size", val, NULL); +} + +void +defaults_set_screen_dpi (Defaults* self, const gdouble val) +{ + if (!self || !IS_DEFAULTS (self)) + return; + + if ((val < SCREEN_DPI_MIN) || (SCREEN_DPI_MAX < val)) + { + g_print ("Attempted to set screen-dpi to an out-of-bounds value : %f\n", val); + return; + } + + g_object_set (self, "screen-dpi", val, NULL); +} + static gboolean defaults_multihead_does_focus_follow (Defaults *self) { - GError *error = NULL; - gboolean mode = FALSE; - g_return_val_if_fail (self != NULL && IS_DEFAULTS (self), FALSE); - - gchar *mode_str = gconf_client_get_string (self->context, - GCONF_MULTIHEAD_MODE, - &error); - if (mode_str != NULL) - { - if (! g_strcmp0 (mode_str, "focus-follow")) - mode = TRUE; - } else if (error != NULL) - g_warning ("error getting multihead mode: %s\n", - error->message); - return mode; + return conf_multihead_does_focus_follow(self->conf, FALSE); } static gboolean === modified file 'src/defaults.h' --- src/defaults.h 2009-07-31 14:19:48 +0000 +++ src/defaults.h 2009-08-19 16:45:39 +0000 @@ -30,10 +30,125 @@ #define __DEFAULTS_H #include -#include +/* defaults-*.h should define : + * - a struct typedef'd to ConfData + * - a set of functions with the same headers as defaults-gconf + * If there is no __USE_*CONF defined, GConf should be used + */ +#if defined __USE_GCONF +#include "defaults-gconf.h" +#elif defined __USE_XFCONF +#include "defaults-xfconf.h" +#else +#include "defaults-gconf.h" +#endif G_BEGIN_DECLS +/* these values are interpreted as em-measurements and do comply to the + * visual guide for jaunty-notifications */ +#define DEFAULT_DESKTOP_BOTTOM_GAP 6.0f +#define DEFAULT_BUBBLE_WIDTH 24.0f +#define DEFAULT_BUBBLE_MIN_HEIGHT 5.0f +#define DEFAULT_BUBBLE_MAX_HEIGHT 12.2f +#define DEFAULT_BUBBLE_VERT_GAP 0.5f +#define DEFAULT_BUBBLE_HORZ_GAP 0.5f +#define DEFAULT_BUBBLE_SHADOW_SIZE 0.7f +#define DEFAULT_BUBBLE_SHADOW_COLOR "#000000" +#define DEFAULT_BUBBLE_BG_COLOR "#131313" +#define DEFAULT_BUBBLE_BG_OPACITY 0.8f +#define DEFAULT_BUBBLE_HOVER_OPACITY 0.4f +#define DEFAULT_BUBBLE_CORNER_RADIUS 0.375f +#define DEFAULT_CONTENT_SHADOW_SIZE 0.125f +#define DEFAULT_CONTENT_SHADOW_COLOR "#000000" +#define DEFAULT_MARGIN_SIZE 1.0f +#define DEFAULT_ICON_SIZE 3.0f +#define DEFAULT_GAUGE_SIZE 0.625f +#define DEFAULT_GAUGE_OUTLINE_WIDTH 0.125f +#define DEFAULT_TEXT_FONT_FACE "Sans" +#define DEFAULT_TEXT_TITLE_COLOR "#ffffff" +#define DEFAULT_TEXT_TITLE_WEIGHT TEXT_WEIGHT_BOLD +#define DEFAULT_TEXT_TITLE_SIZE 1.0f +#define DEFAULT_TEXT_BODY_COLOR "#eaeaea" +#define DEFAULT_TEXT_BODY_WEIGHT TEXT_WEIGHT_NORMAL +#define DEFAULT_TEXT_BODY_SIZE 0.8f +#define DEFAULT_PIXELS_PER_EM 10.0f +#define DEFAULT_SYSTEM_FONT_SIZE 10.0f +#define DEFAULT_SCREEN_DPI 96.0f + +/* min and max values allowed for each property of the defaults class */ +#define DESKTOP_WIDTH_MIN 0 +#define DESKTOP_WIDTH_MAX 4096 +#define DESKTOP_HEIGHT_MIN 0 +#define DESKTOP_HEIGHT_MAX 4096 +#define DESKTOP_TOP_MIN 0 +#define DESKTOP_TOP_MAX 4096 +#define DESKTOP_BOTTOM_MIN 0 +#define DESKTOP_BOTTOM_MAX 4096 +#define DESKTOP_LEFT_MIN 0 +#define DESKTOP_LEFT_MAX 4096 +#define DESKTOP_RIGHT_MIN 0 +#define DESKTOP_RIGHT_MAX 4096 +#define DESKTOP_BOTTOM_GAP_MIN 0.0f +#define DESKTOP_BOTTOM_GAP_MAX 16.0f +#define STACK_HEIGHT_MIN 0.0f +#define STACK_HEIGHT_MAX 256.0f +#define BUBBLE_WIDTH_MIN 0.0f +#define BUBBLE_WIDTH_MAX 256.0f +#define BUBBLE_MIN_HEIGHT_MIN 0.0f +#define BUBBLE_MIN_HEIGHT_MAX 256.0f +#define BUBBLE_MAX_HEIGHT_MIN 0.0f +#define BUBBLE_MAX_HEIGHT_MAX 256.0f +#define BUBBLE_VERT_GAP_MIN 0.0f +#define BUBBLE_VERT_GAP_MAX 10.0f +#define BUBBLE_HORZ_GAP_MIN 0.0f +#define BUBBLE_HORZ_GAP_MAX 10.0f +#define BUBBLE_SHADOW_SIZE_MIN 0.0f +#define BUBBLE_SHADOW_SIZE_MAX 32.0f +#define BUBBLE_BG_OPACITY_MIN 0.0f +#define BUBBLE_BG_OPACITY_MAX 1.0f +#define BUBBLE_HOVER_OPACITY_MIN 0.0f +#define BUBBLE_HOVER_OPACITY_MAX 1.0f +#define BUBBLE_CORNER_RADIUS_MIN 0.0f +#define BUBBLE_CORNER_RADIUS_MAX 16.0f +#define CONTENT_SHADOW_SIZE_MIN 0.0f +#define CONTENT_SHADOW_SIZE_MAX 8.0f +#define MARGIN_SIZE_MIN 0.0f +#define MARGIN_SIZE_MAX 32.0f +#define ICON_SIZE_MIN 0.0f +#define ICON_SIZE_MAX 64.0f +#define GAUGE_SIZE_MIN 0.5f +#define GAUGE_SIZE_MAX 1.0f +#define GAUGE_OUTLINE_WIDTH_MIN 0.1f +#define GAUGE_OUTLINE_WIDTH_MAX 0.2f +#define FADE_IN_TIMEOUT_MIN 0 +#define FADE_IN_TIMEOUT_MAX 10000 +#define FADE_OUT_TIMEOUT_MIN 0 +#define FADE_OUT_TIMEOUT_MAX 10000 +#define ON_SCREEN_TIMEOUT_MIN 0 +#define ON_SCREEN_TIMEOUT_MAX 10000 +#define TEXT_TITLE_WEIGHT_MIN 0 +#define TEXT_TITLE_WEIGHT_MAX 1000 +#define TEXT_TITLE_SIZE_MIN 0.1f +#define TEXT_TITLE_SIZE_MAX 32.0f +#define TEXT_BODY_WEIGHT_MIN 0 +#define TEXT_BODY_WEIGHT_MAX 1000 +#define TEXT_BODY_SIZE_MIN 0.1f +#define TEXT_BODY_SIZE_MAX 32.0f +#define PIXELS_PER_EM_MIN 1.0f +#define PIXELS_PER_EM_MAX 100.0f +#define SYSTEM_FONT_SIZE_MIN 1.0f +#define SYSTEM_FONT_SIZE_MAX 100.0f +#define SCREEN_DPI_MIN 10.0f +#define SCREEN_DPI_MAX 600.0f + +/* these values are interpreted as milliseconds-measurements and do comply to + * the visual guide for jaunty-notifications */ +#define DEFAULT_FADE_IN_TIMEOUT 250 +#define DEFAULT_FADE_OUT_TIMEOUT 1000 +#define DEFAULT_ON_SCREEN_TIMEOUT 10000 + + #define DEFAULTS_TYPE (defaults_get_type ()) #define DEFAULTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DEFAULTS_TYPE, Defaults)) #define DEFAULTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DEFAULTS_TYPE, DefaultsClass)) @@ -60,8 +175,7 @@ GObject parent; /* private */ - GConfClient* context; - guint notifier[5]; + ConfData* conf; gint desktop_width; gint desktop_height; gint desktop_top; @@ -78,8 +192,8 @@ gdouble bubble_shadow_size; GString* bubble_shadow_color; GString* bubble_bg_color; - GString* bubble_bg_opacity; - GString* bubble_hover_opacity; + gdouble bubble_bg_opacity; + gdouble bubble_hover_opacity; gdouble bubble_corner_radius; gdouble content_shadow_size; GString* content_shadow_color; @@ -166,10 +280,10 @@ gchar* defaults_get_bubble_bg_color (Defaults* self); -gchar* +gdouble defaults_get_bubble_bg_opacity (Defaults* self); -gchar* +gdouble defaults_get_bubble_hover_opacity (Defaults* self); gdouble @@ -233,6 +347,120 @@ defaults_get_screen_dpi (Defaults* self); void +defaults_set_desktop_width (Defaults* self, const gint val); + +void +defaults_set_desktop_height (Defaults* self, const gint val); + +void +defaults_set_desktop_top (Defaults* self, const gint val); + +void +defaults_set_desktop_bottom (Defaults* self, const gint val); + +void +defaults_set_desktop_left (Defaults* self, const gint val); + +void +defaults_set_desktop_right (Defaults* self, const gint val); + +void +defaults_set_desktop_bottom_gap (Defaults* self, const gdouble val); + +void +defaults_set_stack_height (Defaults* self, const gdouble val); + +void +defaults_set_bubble_width (Defaults* self, const gdouble val); + +void +defaults_set_bubble_min_height (Defaults* self, const gdouble val); + +void +defaults_set_bubble_max_height (Defaults* self, const gdouble val); + +void +defaults_set_bubble_vert_gap (Defaults* self, const gdouble val); + +void +defaults_set_bubble_horz_gap (Defaults* self, const gdouble val); + +void +defaults_set_bubble_shadow_size (Defaults* self, const gdouble val); + +void +defaults_set_bubble_shadow_color (Defaults* self, const gchar* val); + +void +defaults_set_bubble_bg_color (Defaults* self, const gchar* val); + +void +defaults_set_bubble_bg_opacity (Defaults* self, const gdouble val); + +void +defaults_set_bubble_hover_opacity (Defaults* self, const gdouble val); + +void +defaults_set_bubble_corner_radius (Defaults* self, const gdouble val); + +void +defaults_set_content_shadow_size (Defaults* self, const gdouble val); + +void +defaults_set_content_shadow_color (Defaults* self, const gchar* val); + +void +defaults_set_margin_size (Defaults* self, const gdouble val); + +void +defaults_set_icon_size (Defaults* self, const gdouble val); + +void +defaults_set_gauge_size (Defaults* self, const gdouble val); + +void +defaults_set_gauge_outline_width (Defaults* self, const gdouble val); + +void +defaults_set_fade_in_timeout (Defaults* self, const gint val); + +void +defaults_set_fade_out_timeout (Defaults* self, const gint val); + +void +defaults_set_on_screen_timeout (Defaults* self, const gint val); + +void +defaults_set_text_font_face (Defaults* self, const gchar* val); + +void +defaults_set_text_title_color (Defaults* self, const gchar* val); + +void +defaults_set_text_title_weight (Defaults* self, const gint val); + +void +defaults_set_text_title_size (Defaults* self, const gdouble val); + +void +defaults_set_text_body_color (Defaults* self, const gchar* val); + +void +defaults_set_text_body_weight (Defaults* self, const gint val); + +void +defaults_set_text_body_size (Defaults* self, const gdouble val); + +void +defaults_set_pixel_per_em (Defaults* self, const gdouble val); + +void +defaults_set_system_font_size (Defaults* self, const gdouble val); + +void +defaults_set_screen_dpi (Defaults* self, const gdouble val); + +void defaults_refresh_screen_dimension_properties (Defaults *self); void === modified file 'tests/Makefile.am' --- tests/Makefile.am 2009-08-14 14:21:49 +0000 +++ tests/Makefile.am 2009-08-18 13:59:31 +0000 @@ -1,3 +1,21 @@ +if USE_GCONF +conf_LDADD = $(GCONF_LIBS) + +conf_CFLAGS = -D__USE_GCONF \ + $(GCONF_CFLAGS) +else +if USE_XFCONF +conf_LDADD = $(XFCONF_LIBS) + +conf_CFLAGS = -D__USE_XFCONF \ + $(XFCONF_CFLAGS) +else +conf_LDADD = $(GCONF_LIBS) + +conf_CFLAGS = $(GCONF_CFLAGS) +endif +endif + noinst_PROGRAMS = test-modules \ test-timeline \ test-timeline-dup-frames \ @@ -62,7 +80,8 @@ $(LIBNOTIFY_CFLAGS) \ -DSRCDIR=\""$(top_srcdir)"\" \ -I$(top_srcdir)/src \ - -I$(top_srcdir)/ + -I$(top_srcdir)/ \ + $(conf_CFLAGS) test_modules_LDADD = \ $(GLIB_LIBS) \ @@ -70,7 +89,8 @@ $(DBUS_LIBS) \ $(LIBNOTIFY_LIBS) \ $(GTK_LIBS) \ - -lnotify + -lnotify \ + $(conf_LDADD) EGG_MODULES = \ $(top_srcdir)/egg/egg-fixed.c \ @@ -84,7 +104,8 @@ $(GCOV_CFLAGS) \ -Wall -Werror -std=c99 \ $(GLIB_CFLAGS) \ - -I$(top_srcdir)/src -I$(top_srcdir)/egg -I$(top_srcdir) + -I$(top_srcdir)/src -I$(top_srcdir)/egg -I$(top_srcdir) \ + $(conf_CFLAGS) LDADD = $(GLIB_LIBS) @@ -116,10 +137,12 @@ -Wall -Werror -O0 -ggdb -std=c99 \ $(GTK_CFLAGS) \ -I$(top_srcdir)/src \ - -I$(top_srcdir)/ + -I$(top_srcdir)/ \ + $(conf_CFLAGS) test_raico_LDADD = \ - $(GTK_LIBS) + $(GTK_LIBS) \ + $(conf_LDADD) TILE_MODULES = \ $(RAICO_MODULES) \ @@ -134,10 +157,12 @@ -Wall -Werror -O0 -ggdb -std=c99 \ $(GTK_CFLAGS) \ -I$(top_srcdir)/src \ - -I$(top_srcdir) + -I$(top_srcdir) \ + $(conf_CFLAGS) test_tile_LDADD = \ - $(GTK_LIBS) + $(GTK_LIBS) \ + $(conf_LDADD) GROW_BUBBLE_MODULES = \ $(RAICO_MODULES) \ @@ -151,10 +176,12 @@ -Wall -Werror -O0 -ggdb -std=c99 \ $(GTK_CFLAGS) \ -I$(top_srcdir)/src \ - -I$(top_srcdir) + -I$(top_srcdir) \ + $(conf_CFLAGS) test_grow_bubble_LDADD = \ - $(GTK_LIBS) + $(GTK_LIBS) \ + $(conf_LDADD) SCROLL_TEXT_MODULES = \ $(RAICO_MODULES) \ @@ -168,10 +195,13 @@ -Wall -Werror -O0 -ggdb -std=c99 \ $(GTK_CFLAGS) \ -I$(top_srcdir)/src \ - -I$(top_srcdir)/ + -I$(top_srcdir)/ \ + $(conf_CFLAGS) test_scroll_text_LDADD = \ - $(GTK_LIBS) + $(GTK_LIBS) \ + $(conf_LDADD) + test: test-modules gtester -o=test-modules.xml -k ./test-modules === added file 'tests/test-defaults-xfconf.c' --- tests/test-defaults-xfconf.c 1970-01-01 00:00:00 +0000 +++ tests/test-defaults-xfconf.c 2009-08-21 09:29:26 +0000 @@ -0,0 +1,240 @@ +/******************************************************************************* +**3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 +** 10 20 30 40 50 60 70 80 +** +** notify-osd +** +** test-defaults-xfconf.c - test the defaults class with xfconf in use +** +** Copyright 2009 Canonical Ltd. +** +** Authors: +** Steve Dodier +** +** This program is free software: you can redistribute it and/or modify it +** under the terms of the GNU General Public License version 3, as published +** by the Free Software Foundation. +** +** This program is distributed in the hope that it will be useful, but +** WITHOUT ANY WARRANTY; without even the implied warranties of +** MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR +** PURPOSE. See the GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License along +** with this program. If not, see . +** +*******************************************************************************/ + +#include +#include + +#include "defaults.h" +#include "defaults-xfconf.h" + + +static void +_set_float(gchar* key, gdouble val) +{ + GError* error = NULL; + XfconfChannel* chan = NULL; + + xfconf_init(&error); + if (error) { + g_warning("Xfconf failed to initialize\n"); + return; + } + + chan = xfconf_channel_get(XFCONF_CHANNEL_NOTIFYOSD); + xfconf_channel_set_double(chan, key, val); + xfconf_shutdown(); +} + +static void +_set_int(gchar* key, gint val) +{ + GError* error = NULL; + XfconfChannel* chan = NULL; + + xfconf_init(&error); + if (error) { + g_warning("Xfconf failed to initialize\n"); + return; + } + + chan = xfconf_channel_get(XFCONF_CHANNEL_NOTIFYOSD); + xfconf_channel_set_int(chan, key, val); + xfconf_shutdown(); +} + +static void +_set_string(gchar* key, gchar* val) +{ + GError* error = NULL; + XfconfChannel* chan = NULL; + + xfconf_init(&error); + if (error) { + g_warning("Xfconf failed to initialize\n"); + return; + } + + chan = xfconf_channel_get(XFCONF_CHANNEL_NOTIFYOSD); + xfconf_channel_set_string(chan, key, val); + xfconf_shutdown(); +} + +static void +_unset(gchar* key) +{ + GError* error = NULL; + XfconfChannel* chan = NULL; + + xfconf_init(&error); + if (error) { + g_warning("Xfconf failed to initialize\n"); + return; + } + + chan = xfconf_channel_get(XFCONF_CHANNEL_NOTIFYOSD); + xfconf_channel_reset_property(chan, key, FALSE); + xfconf_shutdown(); +} + +void +conf_set_text_title_size(gdouble val) +{ + _set_float (XFCONF_TEXT_TITLE_SIZE, val); +} + +void +conf_set_text_title_size_to_wrong_type() +{ + _unset (XFCONF_TEXT_TITLE_SIZE); + _set_string (XFCONF_TEXT_TITLE_SIZE, "test"); +} + +void +conf_remove_text_title_size() +{ + _unset (XFCONF_TEXT_TITLE_SIZE); +} + +/*-------------------------*/ + +void +conf_set_text_body_size(gdouble val) +{ + _set_float (XFCONF_TEXT_BODY_SIZE, val); +} + +void +conf_remove_text_body_size() +{ + _unset (XFCONF_TEXT_BODY_SIZE); +} + +/*-------------------------*/ + +void +conf_set_text_title_color(gchar* val) +{ + _set_string (XFCONF_TEXT_TITLE_COLOR, val); +} + +void +conf_set_text_title_color_to_wrong_type() +{ + _unset (XFCONF_TEXT_TITLE_COLOR); + _set_int (XFCONF_TEXT_TITLE_COLOR, 42); +} + +void +conf_remove_text_title_color() +{ + _unset (XFCONF_TEXT_TITLE_COLOR); +} + +/*-------------------------*/ + +void +conf_set_text_body_color(gchar* val) +{ + _set_string (XFCONF_TEXT_BODY_COLOR, val); +} + +void +conf_remove_text_body_color() +{ + _unset (XFCONF_TEXT_BODY_COLOR); +} + +/*-------------------------*/ + +void +conf_set_content_shadow_color(gchar* val) +{ + _set_string (XFCONF_CONTENT_SHADOW_COLOR, val); +} + +void +conf_remove_content_shadow_color() +{ + _unset (XFCONF_CONTENT_SHADOW_COLOR); +} + +/*-------------------------*/ + +void +conf_set_bubble_shadow_color(gchar* val) +{ + _set_string (XFCONF_BUBBLE_SHADOW_COLOR, val); +} + +void +conf_remove_bubble_shadow_color() +{ + _unset (XFCONF_BUBBLE_SHADOW_COLOR); +} + +/*-------------------------*/ + +void +conf_set_bubble_bg_color(gchar* val) +{ + _set_string (XFCONF_BUBBLE_BG_COLOR, val); +} + +void +conf_remove_bubble_bg_color() +{ + _unset (XFCONF_BUBBLE_BG_COLOR); +} + +/*-------------------------*/ + +void +conf_set_bubble_bg_opacity(gdouble val) +{ + _set_float (XFCONF_BUBBLE_BG_OPACITY, val); +} + +void +conf_remove_bubble_bg_opacity() +{ + _unset (XFCONF_BUBBLE_BG_OPACITY); +} + +/*-------------------------*/ + +void +conf_set_bubble_hover_opacity(gdouble val) +{ + _set_float (XFCONF_BUBBLE_HOVER_OPACITY, val); +} + +void +conf_remove_bubble_hover_opacity() +{ + _unset (XFCONF_BUBBLE_HOVER_OPACITY); +} + === modified file 'tests/test-defaults.c' --- tests/test-defaults.c 2009-08-04 17:34:48 +0000 +++ tests/test-defaults.c 2009-08-20 22:04:48 +0000 @@ -30,6 +30,35 @@ #include "defaults.h" +#if defined __USE_GCONF +#include "test-defaults-gconf.c" +#elif defined __USE_XFCONF +#include "test-defaults-xfconf.c" +#else +#include "test-defaults-gconf.c" +#endif + +static +gboolean +stop_main_loop (GMainLoop *loop) +{ + g_main_loop_quit (loop); + + return FALSE; +} + +static +void +wait_a_little (guint interval) +{ + /* let the main loop run to have the slide being performed */ + GMainLoop *loop; + + loop = g_main_loop_new (NULL, FALSE); + g_timeout_add (interval, (GSourceFunc) stop_main_loop, loop); + g_main_loop_run (loop); +} + static void test_defaults_new () @@ -147,6 +176,216 @@ g_object_unref (defaults); } +static +void +test_defaults_get_text_title_size () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + /* Checking that the value is correctly set */ + conf_set_text_title_size (0.9f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_text_title_size (defaults), ==, 0.9f); + + /* Also testing out-of-bounds management for float-type conf keys */ + conf_set_text_title_size (-4.2f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_text_title_size (defaults), <=, TEXT_TITLE_SIZE_MAX); + g_assert_cmpfloat (defaults_get_text_title_size (defaults), >=, TEXT_TITLE_SIZE_MIN); + + conf_set_text_title_size (50.0f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_text_title_size (defaults), <=, TEXT_TITLE_SIZE_MAX); + g_assert_cmpfloat (defaults_get_text_title_size (defaults), >=, TEXT_TITLE_SIZE_MIN); + + /* Checking that the title is correctly set if the conf key doesn't hold the good type */ + conf_set_text_title_size_to_wrong_type (); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_text_title_size (defaults), ==, DEFAULT_TEXT_TITLE_SIZE); + + /* Checking that removing the key gives us the default value */ + conf_remove_text_title_size (); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_text_title_size (defaults), ==, DEFAULT_TEXT_TITLE_SIZE); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_text_body_size () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_text_body_size (0.7f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_text_body_size (defaults), ==, 0.7f); + + conf_remove_text_body_size (); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_text_body_size (defaults), ==, DEFAULT_TEXT_BODY_SIZE); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_text_title_color () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_text_title_color ("#f00"); + wait_a_little (100); + g_assert_cmpstr (defaults_get_text_title_color (defaults), ==, "#f00"); + + /* Checking that color-like keys are set to default if the key isnt a color string */ + conf_set_text_title_color ("wrong string"); + wait_a_little (100); + g_assert_cmpstr (defaults_get_text_title_color (defaults), ==, "#f00"); + + /* Checking that the color is also default if the key is not a string */ + conf_set_text_title_color_to_wrong_type (); + wait_a_little (100); + g_assert_cmpstr (defaults_get_text_title_color (defaults), ==, DEFAULT_TEXT_TITLE_COLOR); + + conf_remove_text_title_color (); + wait_a_little (100); + g_assert_cmpstr (defaults_get_text_title_color (defaults), ==, DEFAULT_TEXT_TITLE_COLOR); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_text_body_color () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_text_body_color ("#f00"); + wait_a_little (100); + g_assert_cmpstr (defaults_get_text_body_color (defaults), ==, "#f00"); + + conf_remove_text_body_color (); + wait_a_little (100); + g_assert_cmpstr (defaults_get_text_body_color (defaults), ==, DEFAULT_TEXT_BODY_COLOR); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_content_shadow_color () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_content_shadow_color ("#f00"); + wait_a_little (100); + g_assert_cmpstr (defaults_get_content_shadow_color (defaults), ==, "#f00"); + + conf_remove_content_shadow_color (); + wait_a_little (100); + g_assert_cmpstr (defaults_get_content_shadow_color (defaults), ==, DEFAULT_CONTENT_SHADOW_COLOR); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_bubble_shadow_color () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_bubble_shadow_color ("#f00"); + wait_a_little (100); + g_assert_cmpstr (defaults_get_bubble_shadow_color (defaults), ==, "#f00"); + + conf_remove_bubble_shadow_color (); + wait_a_little (100); + g_assert_cmpstr (defaults_get_bubble_shadow_color (defaults), ==, DEFAULT_BUBBLE_SHADOW_COLOR); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_bubble_bg_color () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_bubble_bg_color ("#f00"); + wait_a_little (100); + g_assert_cmpstr (defaults_get_bubble_bg_color (defaults), ==, "#f00"); + + conf_remove_bubble_bg_color (); + wait_a_little (100); + g_assert_cmpstr (defaults_get_bubble_bg_color (defaults), ==, DEFAULT_BUBBLE_BG_COLOR); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_bubble_bg_opacity () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_bubble_bg_opacity (0.4f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_bubble_bg_opacity (defaults), ==, 0.4f); + + /* Also testing out-of-bounds management for float-type conf keys */ + conf_set_bubble_bg_opacity (-0.2f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_bubble_bg_opacity (defaults), <=, BUBBLE_BG_OPACITY_MAX); + g_assert_cmpfloat (defaults_get_bubble_bg_opacity (defaults), >=, BUBBLE_BG_OPACITY_MIN); + + conf_set_bubble_bg_opacity (2.0f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_bubble_bg_opacity (defaults), <=, BUBBLE_BG_OPACITY_MAX); + g_assert_cmpfloat (defaults_get_bubble_bg_opacity (defaults), >=, BUBBLE_BG_OPACITY_MIN); + + conf_remove_bubble_bg_opacity (); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_bubble_bg_opacity (defaults), ==, DEFAULT_BUBBLE_BG_OPACITY); + + g_object_unref (defaults); +} + +static +void +test_defaults_get_bubble_hover_opacity () +{ + Defaults* defaults = NULL; + + defaults = defaults_new (); + + conf_set_bubble_hover_opacity (0.4f); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_bubble_hover_opacity (defaults), ==, 0.4f); + + conf_remove_bubble_hover_opacity (); + wait_a_little (100); + g_assert_cmpfloat (defaults_get_bubble_hover_opacity (defaults), ==, DEFAULT_BUBBLE_HOVER_OPACITY); + + g_object_unref (defaults); +} + GTestSuite * test_defaults_create_test_suite (void) { @@ -166,6 +405,15 @@ g_test_suite_add(ts, TC(test_defaults_get_desktop_right)); g_test_suite_add(ts, TC(test_defaults_get_stack_height)); g_test_suite_add(ts, TC(test_defaults_get_bubble_width)); - + g_test_suite_add(ts, TC(test_defaults_get_text_title_size)); + g_test_suite_add(ts, TC(test_defaults_get_text_body_size)); + g_test_suite_add(ts, TC(test_defaults_get_text_title_color)); + g_test_suite_add(ts, TC(test_defaults_get_text_body_color)); + g_test_suite_add(ts, TC(test_defaults_get_content_shadow_color)); + g_test_suite_add(ts, TC(test_defaults_get_bubble_shadow_color)); + g_test_suite_add(ts, TC(test_defaults_get_bubble_bg_color)); + g_test_suite_add(ts, TC(test_defaults_get_bubble_bg_opacity)); + g_test_suite_add(ts, TC(test_defaults_get_bubble_hover_opacity)); + return ts; }