static void apply_wm_settings (WindowckPlugin *wckp)
{
const gchar *wm_theme = xfconf_channel_get_string (wckp->wm_channel, "/general/theme", NULL);
if (G_LIKELY(wm_theme))
{
const gchar *wm_title_font = xfconf_channel_get_string (wckp->wm_channel, "/general/title_font", wckp->prefs->title_font);
wckp->prefs->title_font = g_strdup (wm_title_font);
on_name_changed (wckp->win->controlwindow, wckp);
}
}
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);
}
}
}
static void
xfce_keyboard_layout_helper_set (XfceKeyboardLayoutHelper *helper,
const gchar *xfconf_option_name,
gchar ***xkl_config_option,
const gchar *debug_name)
{
gchar *xfconf_values, *xkl_values;
gchar **values;
if (!helper->xkb_disable_settings)
{
xfconf_values = g_strjoinv (",", *xkl_config_option);
xkl_values = xfconf_channel_get_string (helper->channel,
xfconf_option_name, xfconf_values);
if (g_strcmp0 (xfconf_values, xkl_values) != 0)
{
values = g_strsplit_set (xkl_values, ",", 0);
g_strfreev (*xkl_config_option);
*xkl_config_option = values;
xkl_config_rec_activate (helper->config, helper->engine);
xfsettings_dbg (XFSD_DEBUG_KEYBOARD_LAYOUT, "set %s to \"%s\"", debug_name, xkl_values);
}
g_free (xfconf_values);
g_free (xkl_values);
}
}
static void
xfce_keyboard_layout_helper_set_model (XfceKeyboardLayoutHelper *helper)
{
gchar *xkbmodel;
if (!helper->xkb_disable_settings)
{
xkbmodel = xfconf_channel_get_string (helper->channel, "/Default/XkbModel", NULL);
if (!xkbmodel || !*xkbmodel)
{
/* If xkb model is not set by user, we want to try to use the system default */
g_free (xkbmodel);
xkbmodel = g_strdup (helper->system_keyboard_model);
}
if (g_strcmp0 (helper->config->model, xkbmodel) != 0)
{
g_free (helper->config->model);
helper->config->model = xkbmodel;
xkl_config_rec_activate (helper->config, helper->engine);
xfsettings_dbg (XFSD_DEBUG_KEYBOARD_LAYOUT, "set model to \"%s\"", xkbmodel);
}
else
{
g_free (xkbmodel);
}
}
}
static gboolean
tvm_block_device_autophoto (TvmContext *context,
GMount *mount,
GError **error)
{
gboolean autophoto;
gboolean result = FALSE;
gchar *autophoto_command;
gint response;
g_return_val_if_fail (context != NULL, FALSE);
g_return_val_if_fail (G_IS_MOUNT (mount), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* check if autophoto support is enabled */
autophoto = xfconf_channel_get_bool (context->channel, "/autophoto/enabled", FALSE);
if (autophoto)
{
autophoto_command = xfconf_channel_get_string (context->channel,
"/autophoto/command", NULL);
if (autophoto_command != NULL && *autophoto_command != '\0')
{
/* check if we have any photos on the volume */
if (tvm_file_test (mount, "dcim", G_FILE_TEST_IS_DIR))
{
/* ask the user to import photos */
response = tvm_prompt (context, "camera-photo", _("Photo Import"),
_("A photo card has been detected"),
_("There are photos on the card. Would you like to "
"add these photos to your album?"),
_("Ig_nore"), GTK_RESPONSE_CANCEL,
_("Import _Photos"), TVM_RESPONSE_PHOTOS,
NULL);
if (response == TVM_RESPONSE_PHOTOS)
{
/* run the preferred photo application */
result = tvm_run_command (context, mount, autophoto_command, error);
}
else
{
/* pretend that we handled the device */
result = TRUE;
}
}
}
g_free (autophoto_command);
}
return result;
}
static void
xfce_keyboard_layout_helper_set_option (XfceKeyboardLayoutHelper *helper,
const gchar *xkb_option_name,
const gchar *xfconf_option_name)
{
if (!helper->xkb_disable_settings)
{
gchar *option_value;
gchar *xkl_option_value;
gchar *other_options;
xkl_option_value = xfce_keyboard_layout_get_option (helper->config->options,
xkb_option_name, &other_options);
option_value = xfconf_channel_get_string (helper->channel, xfconf_option_name,
xkl_option_value);
if (g_strcmp0 (option_value, xkl_option_value) != 0)
{
gchar *options_string;
if (other_options == NULL)
{
options_string = g_strdup (option_value);
}
else
{
if (strlen (option_value) != 0)
{
options_string = g_strconcat (option_value, ",", other_options, NULL);
}
else
{
options_string = strdup (other_options);
}
}
g_strfreev (helper->config->options);
helper->config->options = g_strsplit (options_string, ",", 0);
xkl_config_rec_activate (helper->config, helper->engine);
xfsettings_dbg (XFSD_DEBUG_KEYBOARD_LAYOUT, "set %s to \"%s\"",
xkb_option_name, option_value);
g_free (options_string);
}
g_free (other_options);
g_free (option_value);
}
}
static void
xfce_keyboard_layout_reset_xkl_config (XklEngine *xklengine,
XfceKeyboardLayoutHelper *helper)
{
if (!helper->xkb_disable_settings)
{
gchar *xfconf_model;
xfsettings_dbg (XFSD_DEBUG_KEYBOARD_LAYOUT,
"New keyboard detected; restoring XKB settings.");
xkl_config_rec_reset (helper->config);
xkl_config_rec_get_from_server (helper->config, helper->engine);
xfconf_model = xfconf_channel_get_string (helper->channel, "/Default/XkbModel", NULL);
if (xfconf_model && *xfconf_model &&
g_strcmp0 (xfconf_model, helper->config->model) != 0 &&
g_strcmp0 (helper->system_keyboard_model, helper->config->model) != 0)
{
/* We get X-new-device notifications multiple times for a single keyboard device (why?);
if keyboard model is set in user preferences,
we'll reset the default to the user preference when first notified
and we don't want to use that as a system default the next time
the user tries to reset keyboard model to the default in xfce4-keyboard-settings.
The above conditional says: if user set the keyboard model and that's the one
we see here, don't assume it's the system default since it was us who set it
on the previous notification.
*/
g_free (helper->system_keyboard_model);
helper->system_keyboard_model = g_strdup (helper->config->model);
xfsettings_dbg (XFSD_DEBUG_KEYBOARD_LAYOUT,
"system default keyboard model reset: %s",
helper->system_keyboard_model);
}
g_free (xfconf_model);
xfce_keyboard_layout_helper_set_model (helper);
xfce_keyboard_layout_helper_set_layout (helper);
xfce_keyboard_layout_helper_set_variant (helper);
xfce_keyboard_layout_helper_set_grpkey (helper);
xfce_keyboard_layout_helper_set_composekey (helper);
xfce_keyboard_layout_helper_process_xmodmap ();
}
}
static void
wm_tweaks_dialog_configure_widgets (GtkBuilder *builder)
{
GtkWidget *vbox;
GtkTreeIter iter;
GtkListStore *list_store;
GtkCellRenderer *renderer;
XfconfChannel *xfwm4_channel = xfconf_channel_new ("xfwm4");
gchar *easy_click = NULL;
gchar *activate_action = NULL;
gchar *default_placement = NULL;
gboolean modifier_set = FALSE;
guint n;
/* Cycling tab */
GtkWidget *cycle_workspaces_check = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_workspaces_check"));
GtkWidget *cycle_hidden_check = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_hidden_check"));
GtkWidget *cycle_minimum_check = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_minimum_check"));
GtkWidget *cycle_draw_frame = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_draw_frame"));
GtkWidget *cycle_tabwin_mode = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_tabwin_mode"));
/* Focus tab */
GtkWidget *prevent_focus_stealing_check = GTK_WIDGET (gtk_builder_get_object (builder, "prevent_focus_stealing_check"));
GtkWidget *focus_hint_check = GTK_WIDGET (gtk_builder_get_object (builder, "focus_hint_check"));
GtkWidget *activate_action_bring_option = GTK_WIDGET (gtk_builder_get_object (builder, "activate_action_bring_option"));
GtkWidget *activate_action_switch_option = GTK_WIDGET (gtk_builder_get_object (builder, "activate_action_switch_option"));
GtkWidget *activate_action_none_option = GTK_WIDGET (gtk_builder_get_object (builder, "activate_action_none_option"));
/* Accessibility tab */
GtkWidget *easy_click_combo_box = GTK_WIDGET (gtk_builder_get_object (builder, "easy_click_combo_box"));
GtkWidget *raise_with_any_button_check = GTK_WIDGET (gtk_builder_get_object (builder, "raise_with_any_button_check"));
GtkWidget *borderless_maximize_check = GTK_WIDGET (gtk_builder_get_object (builder, "borderless_maximize_check"));
GtkWidget *titleless_maximize_check = GTK_WIDGET (gtk_builder_get_object (builder, "titleless_maximize_check"));
GtkWidget *tile_on_move_check = GTK_WIDGET (gtk_builder_get_object (builder, "tile_on_move_check"));
GtkWidget *snap_resist_check = GTK_WIDGET (gtk_builder_get_object (builder, "snap_resist_check"));
GtkWidget *urgent_blink = GTK_WIDGET (gtk_builder_get_object (builder, "urgent_blink"));
GtkWidget *repeat_urgent_blink = GTK_WIDGET (gtk_builder_get_object (builder, "repeat_urgent_blink"));
GtkWidget *mousewheel_rollup = GTK_WIDGET (gtk_builder_get_object (builder, "mousewheel_rollup"));
/* Workspaces tab */
GtkWidget *scroll_workspaces_check = GTK_WIDGET (gtk_builder_get_object (builder, "scroll_workspaces_check"));
GtkWidget *toggle_workspaces_check = GTK_WIDGET (gtk_builder_get_object (builder, "toggle_workspaces_check"));
GtkWidget *wrap_layout_check = GTK_WIDGET (gtk_builder_get_object (builder, "wrap_layout_check"));
GtkWidget *wrap_cycle_check = GTK_WIDGET (gtk_builder_get_object (builder, "wrap_cycle_check"));
/* Placement tab */
GtkWidget *placement_ratio_scale = GTK_WIDGET (gtk_builder_get_object (builder, "placement_ratio_scale"));
GtkWidget *placement_center_option = GTK_WIDGET (gtk_builder_get_object (builder, "placement_center_option"));
GtkWidget *placement_mouse_option = GTK_WIDGET (gtk_builder_get_object (builder, "placement_mouse_option"));
/* Compositing tab */
GtkWidget *use_compositing_check = GTK_WIDGET (gtk_builder_get_object (builder, "use_compositing_check"));
GtkWidget *use_compositing_box = GTK_WIDGET (gtk_builder_get_object (builder, "use_compositing_box"));
GtkWidget *unredirect_overlays_check = GTK_WIDGET (gtk_builder_get_object (builder, "unredirect_overlays_check"));
GtkWidget *sync_to_vblank_check = GTK_WIDGET (gtk_builder_get_object (builder, "sync_to_vblank_check"));
GtkWidget *cycle_preview_check = GTK_WIDGET (gtk_builder_get_object (builder, "cycle_preview_check"));
GtkWidget *show_frame_shadow_check = GTK_WIDGET (gtk_builder_get_object (builder, "show_frame_shadow_check"));
GtkWidget *show_popup_shadow_check = GTK_WIDGET (gtk_builder_get_object (builder, "show_popup_shadow_check"));
GtkWidget *show_dock_shadow_check = GTK_WIDGET (gtk_builder_get_object (builder, "show_dock_shadow_check"));
GtkWidget *frame_opacity_scale = GTK_WIDGET (gtk_builder_get_object (builder, "frame_opacity_scale"));
GtkWidget *inactive_opacity_scale = GTK_WIDGET (gtk_builder_get_object (builder, "inactive_opacity_scale"));
GtkWidget *move_opacity_scale = GTK_WIDGET (gtk_builder_get_object (builder, "move_opacity_scale"));
GtkWidget *popup_opacity_scale = GTK_WIDGET (gtk_builder_get_object (builder, "popup_opacity_scale"));
GtkWidget *resize_opacity_scale = GTK_WIDGET (gtk_builder_get_object (builder, "resize_opacity_scale"));
/* Fill combo-box */
list_store = gtk_list_store_new (1, G_TYPE_STRING);
easy_click = xfconf_channel_get_string (xfwm4_channel, "/general/easy_click", "Alt");
gtk_cell_layout_clear (GTK_CELL_LAYOUT (easy_click_combo_box));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (easy_click_combo_box), renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (easy_click_combo_box), renderer, "text", 0);
gtk_combo_box_set_model (GTK_COMBO_BOX (easy_click_combo_box), GTK_TREE_MODEL (list_store));
for (n = 0; modifier_list[n]; n++)
{
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter, 0, N_(modifier_list[n]), -1);
if (!modifier_set && !strcmp (easy_click, modifier_list[n]))
{
gtk_combo_box_set_active (GTK_COMBO_BOX (easy_click_combo_box), n);
modifier_set = TRUE;
}
}
/* If not specified, set to "None" */
if (!modifier_set)
gtk_combo_box_set_active (GTK_COMBO_BOX (easy_click_combo_box), 0);
activate_action = xfconf_channel_get_string (xfwm4_channel, "/general/activate_action", "bring");
if (!strcmp (activate_action, "switch"))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (activate_action_bring_option), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (activate_action_switch_option), TRUE);
}
if (!strcmp (activate_action, "none"))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (activate_action_none_option), TRUE);
default_placement = xfconf_channel_get_string (xfwm4_channel, "/general/placement_mode", "center");
if (!strcmp (default_placement, "mouse"))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (placement_center_option), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (placement_mouse_option), TRUE);
}
/* not so easy properties */
g_signal_connect (G_OBJECT (activate_action_bring_option),
"toggled",
G_CALLBACK (cb_activate_action_bring_radio_toggled),
xfwm4_channel);
g_signal_connect (G_OBJECT (activate_action_switch_option),
"toggled",
G_CALLBACK (cb_activate_action_switch_radio_toggled),
xfwm4_channel);
g_signal_connect (G_OBJECT (activate_action_none_option),
"toggled",
G_CALLBACK (cb_activate_action_none_radio_toggled),
xfwm4_channel);
g_signal_connect (G_OBJECT (borderless_maximize_check),
"toggled",
G_CALLBACK (cb_borderless_maximize_button_toggled),
titleless_maximize_check);
g_signal_connect (G_OBJECT (placement_center_option),
"toggled",
G_CALLBACK (cb_activate_placement_center_radio_toggled),
xfwm4_channel);
g_signal_connect (G_OBJECT (placement_mouse_option),
"toggled",
G_CALLBACK (cb_activate_placement_mouse_radio_toggled),
xfwm4_channel);
g_signal_connect (G_OBJECT (use_compositing_check),
"toggled",
G_CALLBACK (cb_use_compositing_check_button_toggled),
use_compositing_box);
g_signal_connect (G_OBJECT (easy_click_combo_box),
"changed",
G_CALLBACK (cb_easy_click_combo_box_changed),
xfwm4_channel);
g_signal_connect (G_OBJECT (urgent_blink),
"toggled",
G_CALLBACK (cb_urgent_blink_button_toggled),
repeat_urgent_blink);
/* Bind easy properties */
/* Cycling tab */
xfconf_g_property_bind (xfwm4_channel,
"/general/cycle_minimum",
G_TYPE_BOOLEAN,
(GObject *)cycle_minimum_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/cycle_hidden",
G_TYPE_BOOLEAN,
(GObject *)cycle_hidden_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/cycle_workspaces",
G_TYPE_BOOLEAN,
(GObject *)cycle_workspaces_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/cycle_draw_frame",
G_TYPE_BOOLEAN,
(GObject *)cycle_draw_frame, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/cycle_tabwin_mode",
G_TYPE_INT,
(GObject *)cycle_tabwin_mode, "active");
/* Focus tab */
xfconf_g_property_bind (xfwm4_channel,
"/general/prevent_focus_stealing",
G_TYPE_BOOLEAN,
(GObject *)prevent_focus_stealing_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/focus_hint",
G_TYPE_BOOLEAN,
(GObject *)focus_hint_check, "active");
/* Accessibility tab */
xfconf_g_property_bind (xfwm4_channel,
"/general/raise_with_any_button",
G_TYPE_BOOLEAN,
(GObject *)raise_with_any_button_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/borderless_maximize",
G_TYPE_BOOLEAN,
(GObject *)borderless_maximize_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/titleless_maximize",
G_TYPE_BOOLEAN,
(GObject *)titleless_maximize_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/tile_on_move",
G_TYPE_BOOLEAN,
(GObject *)tile_on_move_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/snap_resist",
G_TYPE_BOOLEAN,
(GObject *)snap_resist_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/urgent_blink",
G_TYPE_BOOLEAN,
(GObject *)urgent_blink, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/repeat_urgent_blink",
G_TYPE_BOOLEAN,
(GObject *)repeat_urgent_blink, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/mousewheel_rollup",
G_TYPE_BOOLEAN,
(GObject *)mousewheel_rollup, "active");
gtk_widget_set_sensitive (repeat_urgent_blink,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (urgent_blink)));
gtk_widget_set_sensitive (titleless_maximize_check,
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (borderless_maximize_check)));
/* Workspaces tab */
xfconf_g_property_bind (xfwm4_channel,
"/general/toggle_workspaces",
G_TYPE_BOOLEAN,
(GObject *)toggle_workspaces_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/scroll_workspaces",
G_TYPE_BOOLEAN,
(GObject *)scroll_workspaces_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/wrap_layout",
G_TYPE_BOOLEAN,
(GObject *)wrap_layout_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/wrap_cycle",
G_TYPE_BOOLEAN,
(GObject *)wrap_cycle_check, "active");
/* Placement tab */
xfconf_g_property_bind (xfwm4_channel,
"/general/placement_ratio",
G_TYPE_INT,
(GObject *) gtk_range_get_adjustment (GTK_RANGE (placement_ratio_scale)), "value");
/* Compositing tab */
xfconf_g_property_bind (xfwm4_channel,
"/general/use_compositing",
G_TYPE_BOOLEAN,
(GObject *)use_compositing_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/unredirect_overlays",
G_TYPE_BOOLEAN,
(GObject *)unredirect_overlays_check, "active");
#ifdef HAVE_LIBDRM
xfconf_g_property_bind (xfwm4_channel,
"/general/sync_to_vblank",
G_TYPE_BOOLEAN,
(GObject *)sync_to_vblank_check, "active");
#else
gtk_widget_hide (sync_to_vblank_check);
#endif
xfconf_g_property_bind (xfwm4_channel,
"/general/cycle_preview",
G_TYPE_BOOLEAN,
(GObject *)cycle_preview_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/show_frame_shadow",
G_TYPE_BOOLEAN,
(GObject *)show_frame_shadow_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/show_popup_shadow",
G_TYPE_BOOLEAN,
(GObject *)show_popup_shadow_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/show_dock_shadow",
G_TYPE_BOOLEAN,
(GObject *)show_dock_shadow_check, "active");
xfconf_g_property_bind (xfwm4_channel,
"/general/frame_opacity",
G_TYPE_INT,
(GObject *) gtk_range_get_adjustment (GTK_RANGE (frame_opacity_scale)), "value");
xfconf_g_property_bind (xfwm4_channel,
"/general/resize_opacity",
G_TYPE_INT,
(GObject *) gtk_range_get_adjustment (GTK_RANGE (resize_opacity_scale)), "value");
xfconf_g_property_bind (xfwm4_channel,
"/general/move_opacity",
G_TYPE_INT,
(GObject *) gtk_range_get_adjustment (GTK_RANGE (move_opacity_scale)), "value");
xfconf_g_property_bind (xfwm4_channel,
"/general/inactive_opacity",
G_TYPE_INT,
(GObject *) gtk_range_get_adjustment (GTK_RANGE (inactive_opacity_scale)), "value");
xfconf_g_property_bind (xfwm4_channel,
"/general/popup_opacity",
G_TYPE_INT,
(GObject *) gtk_range_get_adjustment (GTK_RANGE (popup_opacity_scale)), "value");
vbox = GTK_WIDGET (gtk_builder_get_object (builder, "main-vbox"));
gtk_widget_show_all (vbox);
g_free (easy_click);
g_free (activate_action);
}
static gboolean
tvm_block_device_autorun (TvmContext *context,
GMount *mount,
GError **error)
{
struct stat statb_mount_point;
struct stat statb_autoopen;
gboolean autoopen;
gboolean autoplay;
gboolean autorun;
gboolean result = FALSE;
GError *err = NULL;
GFile *mount_point;
gchar **argv;
gchar *autoplay_command;
gchar *message;
gchar *mount_path;
gchar *path_autoopen;
gchar *wine;
gchar line[1024];
guint n;
FILE *fp;
gint response;
g_return_val_if_fail (context != NULL, FALSE);
g_return_val_if_fail (G_IS_MOUNT (mount), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* check if autoplaying video CDs and DVDs is enabled */
autoplay = xfconf_channel_get_bool (context->channel,
"/autoplay-video-cds/enabled", FALSE);
if (autoplay)
{
/* check if we have a video CD or video DVD here */
if (tvm_file_test (mount, "vcd", G_FILE_TEST_IS_DIR)
|| tvm_file_test (mount, "video_ts", G_FILE_TEST_IS_DIR))
{
/* determine the autoplay command for video CDs/DVDs */
autoplay_command = xfconf_channel_get_string (context->channel,
"/autoplay-video-cds/command",
"parole");
/* try to spawn the preferred video CD/DVD player */
result = tvm_run_command (context, mount, autoplay_command, &err);
/* free the command string */
g_free (autoplay_command);
/* forward errors to the caller */
if (err != NULL)
g_propagate_error (error, err);
/* return success/failure to the caller */
return result;
}
}
/* check if autorun is enabled */
autorun = xfconf_channel_get_bool (context->channel, "/autorun/enabled", FALSE);
if (autorun)
{
/* Autostart files according to the Desktop Application Autostart
* Specification */
static const gchar *autorun_files[] = { ".autorun", "autorun", "autorun.sh" };
for (n = 0; n < G_N_ELEMENTS (autorun_files); ++n)
{
/* check if one of the autorun files is present and executable */
if (tvm_file_test (mount, autorun_files[n], G_FILE_TEST_IS_EXECUTABLE)
&& tvm_file_test (mount, autorun_files[n], G_FILE_TEST_IS_REGULAR))
{
/* prompt the user to execute the file */
message = g_strdup_printf (_("Would you like to allow \"%s\" to run?"),
autorun_files[n]);
response = tvm_prompt (context, "gnome-fs-executable",
_("Auto-Run Confirmation"),
_("Auto-Run capability detected"), message,
_("Ig_nore"), GTK_RESPONSE_CANCEL,
_("_Allow Auto-Run"), TVM_RESPONSE_AUTORUN,
NULL);
g_free (message);
/* check if we should autorun */
if (response == TVM_RESPONSE_AUTORUN)
{
/* determine the mount point as a string */
mount_point = g_mount_get_root (mount);
mount_path = g_file_get_path (mount_point);
g_object_unref (mount_point);
/* prepare argv to launch the autorun file */
argv = g_new0 (gchar *, 2);
argv[0] = g_build_filename (mount_path, autorun_files[n], NULL);
argv[1] = NULL;
/* try to launch the autorun file */
result = g_spawn_async (mount_path, argv, NULL, 0, NULL, NULL, NULL,
&err);
/* free strings */
g_strfreev (argv);
g_free (mount_path);
if (err != NULL)
g_propagate_error (error, err);
return result;
}
}
}
static gboolean
tvm_block_device_autoipod (TvmContext *context,
GMount *mount,
GError **error)
{
gboolean autoipod;
gboolean is_audio_player = FALSE;
gboolean is_ipod = FALSE;
gboolean result = FALSE;
GFile *mount_point;
gchar *autoipod_command;
gchar *autophoto_command;
gchar *mount_path;
gchar *path_dcim = NULL;
gint response = TVM_RESPONSE_NONE;
g_return_val_if_fail (context != NULL, FALSE);
g_return_val_if_fail (G_IS_MOUNT (mount), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
autoipod = xfconf_channel_get_bool (context->channel, "/autoipod/enabled", FALSE);
if (autoipod)
{
/* check if we have a portable audio player here */
is_audio_player = g_udev_device_has_property (context->device,
"ID_MEDIA_PLAYER");
/* check if we have an iPod */
is_ipod = g_str_has_prefix (g_udev_device_get_property (context->device,
"ID_MODEL"), "iPod");
if (is_ipod)
{
/* determine the mount point path */
mount_point = g_mount_get_root (mount);
mount_path = g_file_get_path (mount_point);
g_object_unref (mount_point);
/* build dcim path */
path_dcim = g_build_filename (mount_path, "dcim", NULL);
g_free (mount_path);
/* check if the iPod has photos */
if (!g_file_test (path_dcim, G_FILE_TEST_IS_DIR))
{
/* no photos */
g_free (path_dcim);
path_dcim = NULL;
}
}
autoipod_command = xfconf_channel_get_string (context->channel,
"/autoipod/command", NULL);
autophoto_command = xfconf_channel_get_string (context->channel,
"/autophoto/command", NULL);
/* check if autophoto command is specified, otherwise we cannot handle the photos
* on the iPod anyway */
if (autophoto_command == NULL || *autophoto_command == '\0')
{
g_free (path_dcim);
path_dcim = NULL;
}
/* iPods can carry music and photos... */
if (path_dcim != NULL)
{
/* ...so we need to prompt what to do */
response = tvm_prompt (context, "multimedia-player", _("Photos and Music"),
_("Photos were found on your portable music player"),
_("Would you like to import the photos or manage the "
"music?"),
_("Ig_nore"), GTK_RESPONSE_CANCEL,
_("Import _Photos"), TVM_RESPONSE_PHOTOS,
_("Manage _Music"), TVM_RESPONSE_MUSIC,
NULL);
}
else if (is_audio_player || is_ipod)
{
response = TVM_RESPONSE_MUSIC;
}
/* check what to do */
if (response == TVM_RESPONSE_MUSIC)
{
/* run the preferred application to manage music players */
result = tvm_run_command (context, mount, autoipod_command, error);
}
else if (response == TVM_RESPONSE_PHOTOS)
{
/* run the preferred application to manage photos */
result = tvm_run_command (context, mount, autophoto_command, error);
}
else if (path_dcim != NULL)
{
/* when the user has decided to ignore photos/music, we don't want
* to ask him again in autophoto and we don't want to mount the
* device either... I guess? */
result = TRUE;
}
g_free (autophoto_command);
g_free (autoipod_command);
g_free (path_dcim);
}
return result;
}
void
tvm_usb_device_added (TvmContext *context)
{
const gchar *icon;
const gchar *summary;
const gchar *message;
const gchar *driver;
const gchar *enabled_property = NULL;
const gchar *command_property = NULL;
gboolean enabled;
gboolean is_camera;
gchar *command;
g_return_if_fail (context != NULL);
/* collect device information */
driver = g_udev_device_get_property (context->device, "DRIVER");
is_camera = g_udev_device_get_property_as_boolean (context->device, "ID_GPHOTO2");
if (is_camera)
{
enabled_property = "/autophoto/enabled";
command_property = "/autophoto/command";
icon = "camera-photo";
summary = _("Camera detected");
message = _("A photo camera was detected");
}
else if (g_strcmp0 (driver, "usblp") == 0)
{
enabled_property = "/autoprinter/enabled";
command_property = "/autoprinter/command";
icon = "printer";
summary = _("Printer detected");
message = _("A USB printer was detected");
}
/* check if we have a device that we support */
if (enabled_property != NULL && command_property != NULL)
{
/* check whether handling the printer or whatever is enabled */
enabled = xfconf_channel_get_bool (context->channel, enabled_property, FALSE);
if (enabled)
{
#ifdef HAVE_LIBNOTIFY
/* display a detection notification */
tvm_notify (icon, summary, message);
#endif
/* fetch the command for the input device type and try to run it */
command = xfconf_channel_get_string (context->channel, command_property, NULL);
if (command != NULL && *command != '\0')
{
tvm_run_command (context, NULL, command, context->error);
}
g_free (command);
}
}
else
{
/* return an error because we cannot handle the usb device */
g_set_error (context->error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Unsupported USB device type \"%s\""), driver);
}
/* finish processing the device */
tvm_device_handler_finished (context);
}
/* Create and set up GtkBuilder */
static gboolean _xfdashboard_settings_create_builder(XfdashboardSettings *self)
{
XfdashboardSettingsPrivate *priv;
gchar *builderFile;
GtkBuilder *builder;
GError *error;
g_return_val_if_fail(XFDASHBOARD_IS_SETTINGS(self), FALSE);
priv=self->priv;
builderFile=NULL;
builder=NULL;
error=NULL;
/* If builder is already set up return immediately */
if(priv->builder) return(TRUE);
/* Find UI file */
builderFile=g_build_filename(PACKAGE_DATADIR, "xfdashboard", PREFERENCES_UI_FILE, NULL);
g_debug("Trying UI file: %s", builderFile);
if(!g_file_test(builderFile, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
{
g_critical(_("Could not find UI file '%s'."), builderFile);
/* Release allocated resources */
g_free(builderFile);
/* Return fail result */
return(FALSE);
}
/* Create builder */
builder=gtk_builder_new();
if(!gtk_builder_add_from_file(builder, builderFile, &error))
{
g_critical(_("Could not load UI resources from '%s': %s"),
builderFile,
error ? error->message : _("Unknown error"));
/* Release allocated resources */
g_free(builderFile);
g_object_unref(builder);
if(error) g_error_free(error);
/* Return fail result */
return(FALSE);
}
/* Loading UI resource was successful so take extra reference
* from builder object to keep it alive. Also get widget, set up
* xfconf bindings and connect signals.
* REMEMBER: Set (widget's) default value _before_ setting up
* xfconf binding.
*/
priv->builder=GTK_BUILDER(g_object_ref(builder));
g_debug("Loaded UI resources from '%s' successfully.", builderFile);
/* Tab: General */
priv->widgetResetSearchOnResume=GTK_WIDGET(gtk_builder_get_object(priv->builder, "reset-search-on-resume"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetResetSearchOnResume), DEFAULT_RESET_SEARCH_ON_RESUME);
xfconf_g_property_bind(priv->xfconfChannel,
"/reset-search-on-resume",
G_TYPE_BOOLEAN,
priv->widgetResetSearchOnResume,
"active");
priv->widgetSwitchViewOnResume=GTK_WIDGET(gtk_builder_get_object(priv->builder, "switch-view-on-resume"));
if(priv->widgetSwitchViewOnResume)
{
GtkCellRenderer *renderer;
GtkListStore *listStore;
GtkTreeIter listStoreIter;
GtkTreeIter *defaultListStoreIter;
XfdashboardSettingsResumableViews *iter;
gchar *defaultValue;
/* Get default value from settings */
defaultValue=xfconf_channel_get_string(priv->xfconfChannel, "/switch-view-on-resume", DEFAULT_SWITCH_VIEW_ON_RESUME);
if(!defaultValue) defaultValue=g_strdup("");
/* Clear combo box */
gtk_cell_layout_clear(GTK_CELL_LAYOUT(priv->widgetSwitchViewOnResume));
/* Set up renderer for combo box */
renderer=gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->widgetSwitchViewOnResume), renderer, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->widgetSwitchViewOnResume), renderer, "text", 0);
/* Set up list to show at combo box */
defaultListStoreIter=NULL;
listStore=gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
for(iter=resumableViews; iter->displayName; ++iter)
{
gtk_list_store_append(listStore, &listStoreIter);
gtk_list_store_set(listStore, &listStoreIter, 0, _(iter->displayName), 1, iter->viewName, -1);
if(!g_strcmp0(iter->viewName, defaultValue))
{
defaultListStoreIter=gtk_tree_iter_copy(&listStoreIter);
}
}
gtk_combo_box_set_model(GTK_COMBO_BOX(priv->widgetSwitchViewOnResume), GTK_TREE_MODEL(listStore));
g_object_unref(G_OBJECT(listStore));
/* Set up default value */
if(defaultListStoreIter)
{
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(priv->widgetSwitchViewOnResume), defaultListStoreIter);
gtk_tree_iter_free(defaultListStoreIter);
defaultListStoreIter=NULL;
}
/* Connect signals */
g_signal_connect_swapped(priv->widgetSwitchViewOnResume,
"changed",
G_CALLBACK(_xfdashboard_settings_widget_changed_switch_view_on_resume),
self);
g_signal_connect_swapped(priv->xfconfChannel,
"property-changed::/switch-view-on-resume",
G_CALLBACK(_xfdashboard_settings_xfconf_changed_switch_view_on_resume),
self);
/* Release allocated resources */
if(defaultValue) g_free(defaultValue);
}
priv->widgetNotificationTimeout=GTK_WIDGET(gtk_builder_get_object(priv->builder, "notification-timeout"));
if(priv->widgetNotificationTimeout)
{
GtkAdjustment *adjustment;
gdouble defaultValue;
/* Get default value */
defaultValue=xfconf_channel_get_uint(priv->xfconfChannel, "/min-notification-timeout", DEFAULT_NOTIFICATION_TIMEOUT)/1000.0;
/* Set up scaling settings of widget */
adjustment=GTK_ADJUSTMENT(gtk_builder_get_object(priv->builder, "notification-timeout-adjustment"));
gtk_range_set_adjustment(GTK_RANGE(priv->widgetNotificationTimeout), adjustment);
/* Set up default value */
gtk_range_set_value(GTK_RANGE(priv->widgetNotificationTimeout), defaultValue);
/* Connect signals */
g_signal_connect(priv->widgetNotificationTimeout,
"format-value",
G_CALLBACK(_xfdashboard_settings_on_format_notification_timeout_value),
NULL);
g_signal_connect_swapped(priv->widgetNotificationTimeout,
"value-changed",
G_CALLBACK(_xfdashboard_settings_widget_changed_notification_timeout),
self);
g_signal_connect_swapped(priv->xfconfChannel,
"property-changed::/min-notification-timeout",
G_CALLBACK(_xfdashboard_settings_xfconf_changed_notification_timeout),
self);
}
priv->widgetEnableUnmappedWindowWorkaround=GTK_WIDGET(gtk_builder_get_object(priv->builder, "enable-unmapped-window-workaround"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetEnableUnmappedWindowWorkaround), FALSE);
xfconf_g_property_bind(priv->xfconfChannel,
"/enable-unmapped-window-workaround",
G_TYPE_BOOLEAN,
priv->widgetEnableUnmappedWindowWorkaround,
"active");
priv->widgetShowAllApps=GTK_WIDGET(gtk_builder_get_object(priv->builder, "show-all-apps"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetShowAllApps), FALSE);
xfconf_g_property_bind(priv->xfconfChannel,
"/components/applications-view/show-all-apps",
G_TYPE_BOOLEAN,
priv->widgetShowAllApps,
"active");
priv->widgetScrollEventChangedWorkspace=GTK_WIDGET(gtk_builder_get_object(priv->builder, "scroll-event-changes-workspace"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetScrollEventChangedWorkspace), FALSE);
xfconf_g_property_bind(priv->xfconfChannel,
"/components/windows-view/scroll-event-changes-workspace",
G_TYPE_BOOLEAN,
priv->widgetScrollEventChangedWorkspace,
"active");
priv->widgetCloseButton=GTK_WIDGET(gtk_builder_get_object(priv->builder, "close-button"));
g_signal_connect_swapped(priv->widgetCloseButton,
"clicked",
G_CALLBACK(_xfdashboard_settings_on_close_clicked),
self);
/* Tab: Themes */
priv->widgetThemeScreenshot=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-screenshot"));
priv->widgetThemeNameLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-name-label"));
priv->widgetThemeName=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-name"));
priv->widgetThemeAuthorLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-author-label"));
priv->widgetThemeAuthor=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-author"));
priv->widgetThemeVersionLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-version-label"));
priv->widgetThemeVersion=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-version"));
priv->widgetThemeDescriptionLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-description-label"));
priv->widgetThemeDescription=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-description"));
priv->widgetThemes=GTK_WIDGET(gtk_builder_get_object(priv->builder, "themes"));
if(priv->widgetThemes)
{
gchar *currentTheme;
GValue defaultValue=G_VALUE_INIT;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
/* Get default value */
currentTheme=xfconf_channel_get_string(priv->xfconfChannel, "/theme", DEFAULT_THEME);
g_value_init(&defaultValue, G_TYPE_STRING);
g_value_set_string(&defaultValue, currentTheme);
g_free(currentTheme);
/* Themes widget has only one column displaying theme's name.
* Set up column and renderer.
*/
renderer=gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(priv->widgetThemes),
0,
_("Theme"),
renderer,
"text",
COLUMN_THEME_NAME,
NULL);
/* Ensure only one selection at time is possible */
selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->widgetThemes));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
/* Populate list of available themes */
_xfdashboard_settings_populate_themes_list(self, priv->widgetThemes);
/* Select default value */
_xfdashboard_settings_xfconf_changed_theme(self,
"/theme",
&defaultValue,
priv->xfconfChannel);
_xfdashboard_settings_widget_changed_theme(self, selection);
/* Connect signals */
g_signal_connect_swapped(selection,
"changed",
G_CALLBACK(_xfdashboard_settings_widget_changed_theme),
self);
g_signal_connect_swapped(priv->xfconfChannel,
"property-changed::/theme",
G_CALLBACK(_xfdashboard_settings_xfconf_changed_theme),
self);
/* Release allocated resources */
g_value_unset(&defaultValue);
}
/* Release allocated resources */
g_free(builderFile);
g_object_unref(builder);
/* Return success result */
return(TRUE);
}
/* 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);
}
