static void on_button_layout_changed (GtkEditable *entry, WBPlugin *wb)
{
if (gtk_widget_get_sensitive (GTK_WIDGET(entry)))
{
const gchar *button_layout = gtk_entry_get_text (GTK_ENTRY(entry));
wb->prefs->button_layout = button_layout_filter (button_layout, wb->prefs->button_layout);
if (wb->prefs->sync_wm_theme)
{
gchar *part;
const gchar *layout;
const gchar *wm_button_layout = xfconf_channel_get_string(wb->wm_channel, "/general/button_layout", "O|HMC");
/* get opposite part of the layout and concatenate it */
part = opposite_layout_filter (wm_button_layout);
if (wm_button_layout[0] == part[0])
layout = g_strconcat (part, wb->prefs->button_layout, NULL);
else
layout = g_strconcat (wb->prefs->button_layout, part, NULL);
xfconf_channel_set_string (wb->wm_channel, "/general/button_layout", layout);
g_free (part);
}
else
{
replace_buttons (wb->prefs->button_layout, wb);
on_wck_state_changed (wb->win->controlwindow, wb);
}
}
}
int
main(int argc,
char **argv)
{
XfconfChannel *channel;
SignalTestData std = { NULL, FALSE };
std.mloop = g_main_loop_new(NULL, FALSE);
if(!xfconf_tests_start())
return 2;
channel = xfconf_channel_new(TEST_CHANNEL_NAME);
xfconf_channel_reset_property (channel, test_string_property, FALSE);
g_signal_connect(G_OBJECT(channel), "property-changed",
G_CALLBACK(test_signal_changed), &std);
TEST_OPERATION(xfconf_channel_set_string(channel, test_string_property, test_string));
g_timeout_add(1500, test_watchdog, &std);
g_main_loop_run(std.mloop);
g_main_loop_unref(std.mloop);
g_object_unref(G_OBJECT(channel));
xfconf_tests_end();
return std.got_signal ? 0 : 1;
}
static void
cb_activate_action_bring_radio_toggled (GtkToggleButton *toggle, XfconfChannel *channel)
{
if (gtk_toggle_button_get_active (toggle))
{
xfconf_channel_set_string (channel, "/general/activate_action", "bring");
}
}
static void
cb_activate_placement_mouse_radio_toggled (GtkToggleButton *toggle, XfconfChannel *channel)
{
if (gtk_toggle_button_get_active (toggle))
{
xfconf_channel_set_string (channel, "/general/placement_mode", "mouse");
}
}
void
xfce_randr_apply (XfceRandr *randr,
const gchar *scheme,
XfconfChannel *channel)
{
g_return_if_fail (randr != NULL && scheme != NULL);
g_return_if_fail (XFCONF_IS_CHANNEL (channel));
/* tell the helper to apply this theme */
xfconf_channel_set_string (channel, "/Schemes/Apply", scheme);
}
static void
cb_easy_click_combo_box_changed (GtkComboBox *combo, XfconfChannel *channel)
{
gint n;
n = 0;
while (modifier_list[n])
{
if (gtk_combo_box_get_active (combo) == n)
{
xfconf_channel_set_string (channel, "/general/easy_click", _(modifier_list[n]));
}
n++;
}
}
static void
wckbuttons_theme_selection_changed (GtkTreeSelection *selection,
WBPlugin *wb)
{
GtkTreeModel *model;
GtkTreeIter iter;
const gchar *theme;
GtkWidget *entry;
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter, COL_THEME_NAME, &theme, -1);
/* set the theme name */
wb->prefs->theme = g_strdup (theme);
entry = GTK_WIDGET(gtk_builder_get_object(wb->prefs->builder, "button_layout"));
if (wb->prefs->sync_wm_theme)
{
xfconf_channel_set_string (wb->wm_channel, "/general/theme", wb->prefs->theme);
gchar *button_layout;
button_layout = get_rc_button_layout (theme);
if (button_layout)
{
gtk_widget_set_sensitive (entry, FALSE);
gtk_entry_set_text (GTK_ENTRY(entry), button_layout);
}
else
{
gtk_entry_set_text (GTK_ENTRY(entry), wb->prefs->button_layout);
gtk_widget_set_sensitive (entry, TRUE);
}
g_free (button_layout);
}
else
{
load_theme (wb->prefs->theme, wb);
replace_buttons (wb->prefs->button_layout, wb);
on_wck_state_changed (wb->win->controlwindow, wb);
}
}
}
static void
xfce_workspace_change_backdrop(XfceWorkspace *workspace,
XfceBackdrop *backdrop,
const gchar *backdrop_file)
{
XfconfChannel *channel = workspace->priv->channel;
char buf[1024];
gchar *monitor_name = NULL;
guint i, monitor_num;
g_return_if_fail(workspace->priv->nbackdrops > 0);
TRACE("entering");
/* Find out which monitor we're on */
for(i = 0; i < workspace->priv->nbackdrops; ++i) {
if(backdrop == workspace->priv->backdrops[i]) {
monitor_num = i;
break;
}
}
monitor_name = gdk_screen_get_monitor_plug_name(workspace->priv->gscreen,
monitor_num);
/* Get the backdrop's image property */
if(monitor_name == NULL) {
g_snprintf(buf, sizeof(buf), "%smonitor%d/workspace%d/last-image",
workspace->priv->property_prefix, monitor_num, workspace->priv->workspace_num);
} else {
g_snprintf(buf, sizeof(buf), "%smonitor%s/workspace%d/last-image",
workspace->priv->property_prefix, monitor_name, workspace->priv->workspace_num);
g_free(monitor_name);
}
/* Update the property so that xfdesktop won't show the same image every
* time it starts up when the user wants it to cycle different images */
xfconf_channel_set_string(channel, buf, backdrop_file);
}
/* Setting '/switch-view-on-resume' changed either at widget or at xfconf property */
static void _xfdashboard_settings_widget_changed_switch_view_on_resume(XfdashboardSettings *self, GtkComboBox *inComboBox)
{
XfdashboardSettingsPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *value;
g_return_if_fail(XFDASHBOARD_IS_SETTINGS(self));
g_return_if_fail(GTK_IS_COMBO_BOX(inComboBox));
priv=self->priv;
/* Get selected entry from combo box */
model=gtk_combo_box_get_model(inComboBox);
gtk_combo_box_get_active_iter(inComboBox, &iter);
gtk_tree_model_get(model, &iter, 1, &value, -1);
/* Set value at xfconf property */
xfconf_channel_set_string(priv->xfconfChannel, "/switch-view-on-resume", value);
/* Release allocated resources */
if(value) g_free(value);
}
/* Perform full initialization of this application instance */
static gboolean _xfdashboard_application_initialize_full(XfdashboardApplication *self, XfdashboardStage **outStage)
{
XfdashboardApplicationPrivate *priv;
GError *error;
ClutterActor *stage;
#if !GARCON_CHECK_VERSION(0,3,0)
const gchar *desktop;
#endif
g_return_val_if_fail(XFDASHBOARD_IS_APPLICATION(self), FALSE);
g_return_val_if_fail(outStage==NULL || *outStage==NULL, FALSE);
priv=self->priv;
error=NULL;
/* Initialize garcon for current desktop environment */
#if !GARCON_CHECK_VERSION(0,3,0)
desktop=g_getenv("XDG_CURRENT_DESKTOP");
if(G_LIKELY(desktop==NULL))
{
/* If we could not determine current desktop environment
* assume Xfce as this application is developed for this DE.
*/
desktop="XFCE";
}
/* If desktop enviroment was found but has no name
* set NULL to get all menu items shown.
*/
else if(*desktop==0) desktop=NULL;
garcon_set_environment(desktop);
#else
garcon_set_environment_xdg(GARCON_ENVIRONMENT_XFCE);
#endif
/* Setup the session management */
priv->sessionManagementClient=xfce_sm_client_get();
xfce_sm_client_set_priority(priv->sessionManagementClient, XFCE_SM_CLIENT_PRIORITY_DEFAULT);
xfce_sm_client_set_restart_style(priv->sessionManagementClient, XFCE_SM_CLIENT_RESTART_IMMEDIATELY);
g_signal_connect_swapped(priv->sessionManagementClient, "quit", G_CALLBACK(_xfdashboard_application_on_session_quit), self);
if(!xfce_sm_client_connect(priv->sessionManagementClient, &error))
{
g_warning("Failed to connect to session manager: %s",
(error && error->message) ? error->message : _("unknown error"));
g_clear_error(&error);
}
/* Initialize xfconf */
if(!xfconf_init(&error))
{
g_critical(_("Could not initialize xfconf: %s"),
(error && error->message) ? error->message : _("unknown error"));
if(error) g_error_free(error);
return(FALSE);
}
priv->xfconfChannel=xfconf_channel_get(XFDASHBOARD_XFCONF_CHANNEL);
/* Set up keyboard and pointer bindings */
priv->bindings=xfdashboard_bindings_pool_get_default();
if(!priv->bindings)
{
g_critical(_("Could not initialize bindings"));
return(FALSE);
}
if(!xfdashboard_bindings_pool_load(priv->bindings, &error))
{
g_critical(_("Could not load bindings: %s"),
(error && error->message) ? error->message : _("unknown error"));
if(error!=NULL) g_error_free(error);
return(FALSE);
}
/* Set up application database */
priv->appDatabase=xfdashboard_application_database_get_default();
if(!priv->appDatabase)
{
g_critical(_("Could not initialize application database"));
return(FALSE);
}
if(!xfdashboard_application_database_load(priv->appDatabase, &error))
{
g_critical(_("Could not load application database: %s"),
(error && error->message) ? error->message : _("unknown error"));
if(error!=NULL) g_error_free(error);
return(FALSE);
}
/* Set up application tracker */
priv->appTracker=xfdashboard_application_tracker_get_default();
if(!priv->appTracker)
{
g_critical(_("Could not initialize application tracker"));
return(FALSE);
}
/* Set up and load theme */
priv->xfconfThemeChangedSignalID=xfconf_g_property_bind(priv->xfconfChannel,
THEME_NAME_XFCONF_PROP,
G_TYPE_STRING,
self,
"theme-name");
if(!priv->xfconfThemeChangedSignalID)
{
g_warning(_("Could not create binding between xfconf property and local resource for theme change notification."));
}
/* Set up default theme in Xfcond if property in channel does not exist
* because it indicates first start.
*/
if(!xfconf_channel_has_property(priv->xfconfChannel, THEME_NAME_XFCONF_PROP))
{
xfconf_channel_set_string(priv->xfconfChannel,
THEME_NAME_XFCONF_PROP,
DEFAULT_THEME_NAME);
}
/* At this time the theme must have been loaded, either because we
* set the default theme name because of missing theme property in
* xfconf channel or the value of xfconf channel property has been read
* and set when setting up binding (between xfconf property and local property)
* what caused a call to function to set theme name in this object
* and also caused a reload of theme.
* So if no theme object is set in this object then loading theme has
* failed and we have to return FALSE.
*/
if(!priv->theme) return(FALSE);
/* Register built-in views (order of registration is important) */
priv->viewManager=xfdashboard_view_manager_get_default();
xfdashboard_view_manager_register(priv->viewManager, XFDASHBOARD_TYPE_WINDOWS_VIEW);
xfdashboard_view_manager_register(priv->viewManager, XFDASHBOARD_TYPE_APPLICATIONS_VIEW);
xfdashboard_view_manager_register(priv->viewManager, XFDASHBOARD_TYPE_SEARCH_VIEW);
/* Register built-in search providers */
priv->searchManager=xfdashboard_search_manager_get_default();
xfdashboard_search_manager_register(priv->searchManager, XFDASHBOARD_TYPE_APPLICATIONS_SEARCH_PROVIDER);
/* Create single-instance of focus manager to keep it alive while
* application is running.
*/
priv->focusManager=xfdashboard_focus_manager_get_default();
/* Create stage containing all monitors */
stage=xfdashboard_stage_new();
g_signal_connect_swapped(stage, "delete-event", G_CALLBACK(_xfdashboard_application_on_delete_stage), self);
/* Emit signal 'theme-changed' to get current theme loaded at each stage created */
g_signal_emit(self, XfdashboardApplicationSignals[SIGNAL_THEME_CHANGED], 0, priv->theme);
/* Set return results */
if(outStage) *outStage=XFDASHBOARD_STAGE(stage);
/* Initialization was successful so return TRUE */
#ifdef DEBUG
xfdashboard_notify(NULL, NULL, _("Welcome to %s (%s)!"), PACKAGE_NAME, PACKAGE_VERSION);
#else
xfdashboard_notify(NULL, NULL, _("Welcome to %s!"), PACKAGE_NAME);
#endif
return(TRUE);
}
void
xfce_randr_save_output (XfceRandr *randr,
const gchar *scheme,
XfconfChannel *channel,
guint output,
gint rel_changed)
{
gchar property[512];
gchar *str_value;
const XfceRRMode *mode;
gint degrees;
g_return_if_fail (randr != NULL && scheme != NULL);
g_return_if_fail (XFCONF_IS_CHANNEL (channel));
g_return_if_fail (output < randr->noutput);
/* save the device name */
g_snprintf (property, sizeof (property), "/%s/%s", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_string (channel, property, randr->friendly_name[output]);
/* find the resolution and refresh rate */
mode = xfce_randr_find_mode_by_id (randr, output, randr->mode[output]);
/* if no resolution was found, mark it as inactive and stop */
g_snprintf (property, sizeof (property), "/%s/%s/Active", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_bool (channel, property, mode != NULL);
if (mode == NULL)
return;
/* save the resolution */
str_value = g_strdup_printf ("%dx%d", mode->width, mode->height);
g_snprintf (property, sizeof (property), "/%s/%s/Resolution", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_string (channel, property, str_value);
g_free (str_value);
/* save the refresh rate */
g_snprintf (property, sizeof (property), "/%s/%s/RefreshRate", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_double (channel, property, mode->rate);
/* convert the rotation into degrees */
switch (randr->rotation[output] & XFCE_RANDR_ROTATIONS_MASK)
{
case RR_Rotate_90: degrees = 90; break;
case RR_Rotate_180: degrees = 180; break;
case RR_Rotate_270: degrees = 270; break;
default: degrees = 0; break;
}
/* save the rotation in degrees */
g_snprintf (property, sizeof (property), "/%s/%s/Rotation", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_int (channel, property, degrees);
/* convert the reflection into a string */
switch (randr->rotation[output] & XFCE_RANDR_REFLECTIONS_MASK)
{
case RR_Reflect_X: str_value = "X"; break;
case RR_Reflect_Y: str_value = "Y"; break;
case RR_Reflect_X|RR_Reflect_Y: str_value = "XY"; break;
default: str_value = "0"; break;
}
/* save the reflection string */
g_snprintf (property, sizeof (property), "/%s/%s/Reflection", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_string (channel, property, str_value);
#ifdef HAS_RANDR_ONE_POINT_THREE
/* is it the primary output? */
g_snprintf (property, sizeof (property), "/%s/%s/Primary", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_bool (channel, property,
randr->status[output] == XFCE_OUTPUT_STATUS_PRIMARY);
#endif
/* update positions according to the current relations */
if (rel_changed)
xfce_randr_update_positions (randr, output);
/* save the position */
g_snprintf (property, sizeof (property), "/%s/%s/Position/X", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_int (channel, property, MAX (randr->priv->position[output].x, 0));
g_snprintf (property, sizeof (property), "/%s/%s/Position/Y", scheme,
randr->priv->output_info[output]->name);
xfconf_channel_set_int (channel, property, MAX (randr->priv->position[output].y, 0));
}
static void
migrate_46_end_element_handler (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
ConfigParser *parser = user_data;
SnapPosition snap_position;
gboolean horizontal;
gchar prop[128];
gchar *position;
g_return_if_fail (XFCONF_IS_CHANNEL (parser->channel));
switch (parser->state)
{
case START:
g_set_error (error, G_MARKUP_ERROR_PARSE, G_MARKUP_ERROR,
"Unexpected end element \"%s\"", element_name);
break;
case PANEL:
if (strcmp ("panel", element_name) == 0)
{
parser->state = PANELS;
/* store ids array */
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/plugin-ids", parser->panel_id_counter);
xfconf_channel_set_arrayv (parser->channel, prop, parser->panel_plugin_ids);
xfconf_array_free (parser->panel_plugin_ids);
/* translate the old screen position to a snap position and orientation */
migrate_46_panel_screen_position (parser->panel_screen_position,
&snap_position, &horizontal);
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/horizontal", parser->panel_id_counter);
xfconf_channel_set_bool (parser->channel, prop, horizontal);
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/position", parser->panel_id_counter);
position = g_strdup_printf ("p=%d;x=%d;y=%d",
snap_position,
parser->panel_xoffset,
parser->panel_yoffset);
xfconf_channel_set_string (parser->channel, prop, position);
g_free (position);
/* set transparency */
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/leave-opacity", parser->panel_id_counter);
xfconf_channel_set_uint (parser->channel, prop, 100 - parser->panel_transparency);
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/enter-opacity", parser->panel_id_counter);
xfconf_channel_set_uint (parser->channel, prop, parser->panel_activetrans ?
100 - parser->panel_transparency : 100);
/* prepare for the next panel */
parser->panel_id_counter++;
}
break;
case PANELS:
if (strcmp ("panels", element_name) == 0)
{
parser->state = START;
xfconf_channel_set_uint (parser->channel, "/panels", parser->panel_id_counter);
}
break;
case PROPERTIES:
if (strcmp ("properties", element_name) == 0)
parser->state = PANEL;
break;
case ITEMS:
if (strcmp ("items", element_name) == 0)
parser->state = PANEL;
break;
default:
g_set_error (error, G_MARKUP_ERROR_UNKNOWN_ELEMENT, G_MARKUP_ERROR,
"Unknown end element \"%s\"", element_name);
break;
}
}
static void
migrate_46_panel_add_plugin (ConfigParser *parser,
const gchar *name,
const gchar *id,
GError **error)
{
XfconfChannel *channel;
gchar base[256];
XfceRc *rc;
const gchar *plugin_name = name;
g_return_if_fail (XFCONF_IS_CHANNEL (parser->channel));
/* open the old rc file of the plugin */
g_snprintf (base, sizeof (base), "heartlenv" G_DIR_SEPARATOR_S
"panel" G_DIR_SEPARATOR_S "%s-%s.rc", name, id);
rc = xfce_rc_config_open (XFCE_RESOURCE_CONFIG, base, TRUE);
/* open a panel with the propert base for the plugin */
g_snprintf (base, sizeof (base), "/plugins/plugin-%d", parser->plugin_id_counter);
channel = xfconf_channel_new_with_property_base (XFCE_PANEL_CHANNEL_NAME, base);
if (strcmp (name, "actions") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_actions (channel, rc);
}
else if (strcmp (name, "clock") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_clock (channel, rc);
}
else if (strcmp (name, "iconbox") == 0)
{
plugin_name = "tasklist";
if (G_LIKELY (rc != NULL))
migrate_46_plugin_iconbox (channel, rc);
}
else if (strcmp (name, "launcher") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_launcher (channel, rc, parser->plugin_id_counter, error);
}
else if (strcmp (name, "pager") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_pager (channel, rc);
}
else if (strcmp (name, "separator") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_separator (channel, rc);
}
else if (strcmp (name, "showdesktop") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_showdesktop (channel, rc);
}
else if (strcmp (name, "systray") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_systray (channel, rc);
}
else if (strcmp (name, "tasklist") == 0)
{
if (G_LIKELY (rc != NULL))
migrate_46_plugin_tasklist (channel, rc);
}
else if (strcmp (name, "windowlist") == 0)
{
plugin_name = "windowmenu";
if (G_LIKELY (rc != NULL))
migrate_46_plugin_windowlist (channel, rc);
}
else if (strcmp (name, "heartlenv-menu") == 0)
{
plugin_name = "applicationsmenu";
if (G_LIKELY (rc != NULL))
migrate_46_plugin_heartlenv_menu (channel, rc);
}
else
{
/* handle other "external" plugins */
}
/* close plugin configs */
g_object_unref (G_OBJECT (channel));
if (G_LIKELY (rc != NULL))
xfce_rc_close (rc);
/* store the (new) plugin name */
xfconf_channel_set_string (parser->channel, base, plugin_name);
}
static void
migrate_46_panel_set_property (ConfigParser *parser,
const gchar *property_name,
const gchar *value,
GError **error)
{
gchar prop[128];
GdkDisplay *display;
gchar *name;
gint num;
if (strcmp (property_name, "size") == 0)
{
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/size", parser->panel_id_counter);
xfconf_channel_set_uint (parser->channel, prop, CLAMP (atoi (value), 16, 128));
}
else if (strcmp (property_name, "fullwidth") == 0)
{
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/length", parser->panel_id_counter);
xfconf_channel_set_uint (parser->channel, prop, (atoi (value) != 0) ? 100 : 0);
}
else if (strcmp (property_name, "screen-position") == 0)
{
parser->panel_screen_position = CLAMP (atoi (value),
XFCE_SCREEN_POSITION_NONE,
XFCE_SCREEN_POSITION_FLOATING_V);
}
else if (strcmp (property_name, "xoffset") == 0)
{
parser->panel_xoffset = MAX (0, atoi (value));
}
else if (strcmp (property_name, "yoffset") == 0)
{
parser->panel_yoffset = MAX (0, atoi (value));
}
else if (strcmp (property_name, "monitor") == 0)
{
/* in 4.4 and 4.6 we only use monitor and make no difference between monitors
* and screen's, so check the setup of the user to properly convert this */
num = MAX (0, atoi (value));
if (G_LIKELY (num > 0))
{
display = gdk_display_get_default ();
if (display != NULL && gdk_display_get_n_screens (display) > 1)
name = g_strdup_printf ("screen-%d", num);
else
name = g_strdup_printf ("monitor-%d", num);
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/output", parser->panel_id_counter);
xfconf_channel_set_string (parser->channel, prop, name);
g_free (name);
}
}
else if (strcmp (property_name, "handlestyle") == 0)
{
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/locked", parser->panel_id_counter);
xfconf_channel_set_bool (parser->channel, prop, atoi (value) == 0);
}
else if (strcmp (property_name, "autohide") == 0)
{
g_snprintf (prop, sizeof (prop), "/panels/panel-%u/autohide", parser->panel_id_counter);
xfconf_channel_set_bool (parser->channel, prop, (atoi (value) == 1));
}
else if (strcmp (property_name, "transparency") == 0)
{
parser->panel_transparency = CLAMP (atoi (value), 0, 100);
}
else if (strcmp (property_name, "activetrans") == 0)
{
parser->panel_activetrans = (atoi (value) == 1);
}
else
{
g_set_error (error, G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, G_MARKUP_ERROR,
"Unknown property \"%s\" in #%d \"panel\" element",
property_name, parser->panel_id_counter);
}
}
/* Setting '/theme' changed either at widget or at xfconf property */
static void _xfdashboard_settings_widget_changed_theme(XfdashboardSettings *self, GtkTreeSelection *inSelection)
{
XfdashboardSettingsPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *themeDisplayName;
gchar *themeComment;
gchar *themeAuthor;
gchar *themeVersion;
gchar *themeScreenshot;
gchar *themeFilename;
gchar *themeName;
g_return_if_fail(XFDASHBOARD_IS_SETTINGS(self));
g_return_if_fail(GTK_IS_TREE_SELECTION(inSelection));
priv=self->priv;
themeDisplayName=NULL;
themeComment=NULL;
themeAuthor=NULL;
themeVersion=NULL;
themeScreenshot=NULL;
themeFilename=NULL;
themeName=NULL;
/* Get selected entry from widget */
if(gtk_tree_selection_get_selected(inSelection, &model, &iter))
{
/* Get data from model */
gtk_tree_model_get(model,
&iter,
COLUMN_THEME_NAME, &themeName,
COLUMN_THEME_FILE, &themeFilename,
COLUMN_THEME_DISPLAY_NAME, &themeDisplayName,
COLUMN_THEME_DESCRIPTION, &themeComment,
COLUMN_THEME_AUTHORS, &themeAuthor,
COLUMN_THEME_VERSION, &themeVersion,
COLUMN_THEME_SCREENSHOTS, &themeScreenshot,
-1);
}
/* Set text in labels */
if(themeDisplayName)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeName), themeDisplayName);
gtk_widget_show(priv->widgetThemeName);
gtk_widget_show(priv->widgetThemeNameLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeName);
gtk_widget_hide(priv->widgetThemeNameLabel);
}
if(themeComment)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeDescription), themeComment);
gtk_widget_show(priv->widgetThemeDescription);
gtk_widget_show(priv->widgetThemeDescriptionLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeDescription);
gtk_widget_hide(priv->widgetThemeDescriptionLabel);
}
if(themeAuthor)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeAuthor), themeAuthor);
gtk_widget_show(priv->widgetThemeAuthor);
gtk_widget_show(priv->widgetThemeAuthorLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeAuthor);
gtk_widget_hide(priv->widgetThemeAuthorLabel);
}
if(themeVersion)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeVersion), themeVersion);
gtk_widget_show(priv->widgetThemeVersion);
gtk_widget_show(priv->widgetThemeVersionLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeVersion);
gtk_widget_hide(priv->widgetThemeVersionLabel);
}
/* Set screenshot */
if(themeScreenshot)
{
gchar *screenshotFile;
GdkPixbuf *screenshotImage;
screenshotFile=NULL;
screenshotImage=NULL;
/* Get screenshot file but resolve relative path if needed */
if(!g_path_is_absolute(themeScreenshot))
{
GFile *file;
GFile *parentPath;
gchar *themePath;
file=NULL;
parentPath=NULL;
themePath=NULL;
/* Resolve relative path relative to theme path */
file=g_file_new_for_path(themeFilename);
if(file) parentPath=g_file_get_parent(file);
if(parentPath) themePath=g_file_get_path(parentPath);
if(themePath) screenshotFile=g_build_filename(themePath, themeScreenshot, NULL);
/* Release allocated resources */
if(themePath) g_free(themePath);
if(parentPath) g_object_unref(parentPath);
if(file) g_object_unref(file);
}
else
{
/* Path is absolute so just create a copy */
screenshotFile=g_strdup(themeScreenshot);
}
/* If screenshot file exists set up and show image
* otherwise hide image.
*/
if(screenshotFile &&
g_file_test(screenshotFile, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
{
GError *error;
gint width;
gint height;
error=NULL;
/* Check if screenshot fits into widget without scaling or
* scale it to maximum size but preserve aspect ratio.
*/
if(gdk_pixbuf_get_file_info(screenshotFile, &width, &height))
{
if(width<MAX_SCREENSHOT_WIDTH)
{
screenshotImage=gdk_pixbuf_new_from_file(screenshotFile,
&error);
}
else
{
screenshotImage=gdk_pixbuf_new_from_file_at_scale(screenshotFile,
MAX_SCREENSHOT_WIDTH,
-1,
TRUE,
&error);
}
if(error)
{
g_warning("Could not load screenshot: %s",
error ? error->message : _("Unknown error"));
/* Release allocated resources */
if(error) g_error_free(error);
if(screenshotImage)
{
g_object_unref(screenshotImage);
screenshotImage=NULL;
}
}
}
}
if(screenshotImage)
{
gtk_image_set_from_pixbuf(GTK_IMAGE(priv->widgetThemeScreenshot), screenshotImage);
gtk_widget_show(priv->widgetThemeScreenshot);
}
else
{
gtk_widget_hide(priv->widgetThemeScreenshot);
}
/* Release allocated resources */
if(screenshotImage) g_object_unref(screenshotImage);
if(screenshotFile) g_free(screenshotFile);
}
else
{
gtk_widget_hide(priv->widgetThemeScreenshot);
}
/* Set value at xfconf property if it must be changed */
if(themeName)
{
gchar *currentTheme;
currentTheme=xfconf_channel_get_string(priv->xfconfChannel, "/theme", DEFAULT_THEME);
if(g_strcmp0(currentTheme, themeName))
{
xfconf_channel_set_string(priv->xfconfChannel, "/theme", themeName);
}
g_free(currentTheme);
}
/* Release allocated resources */
if(themeDisplayName) g_free(themeDisplayName);
if(themeComment) g_free(themeComment);
if(themeAuthor) g_free(themeAuthor);
if(themeVersion) g_free(themeVersion);
if(themeScreenshot) g_free(themeScreenshot);
if(themeFilename) g_free(themeFilename);
if(themeName) g_free(themeName);
}