initial

1 files changed, 8855 insertions, 0 deletions

diff --git a/src/fr-window.c b/src/fr-window.c
new file mode 100644
index 0000000..41407c6
--- /dev/null
+++ b/src/fr-window.c
@@ -0,0 +1,8855 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/*
+ *  File-Roller
+ *
+ *  Copyright (C) 2007 Free Software Foundation, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <math.h>
+#include <string.h>
+
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "actions.h"
+#include "dlg-batch-add.h"
+#include "dlg-delete.h"
+#include "dlg-extract.h"
+#include "dlg-open-with.h"
+#include "dlg-ask-password.h"
+#include "dlg-package-installer.h"
+#include "dlg-update.h"
+#include "eggtreemultidnd.h"
+#include "fr-marshal.h"
+#include "fr-list-model.h"
+#include "fr-archive.h"
+#include "fr-error.h"
+#include "fr-stock.h"
+#include "fr-window.h"
+#include "file-data.h"
+#include "file-utils.h"
+#include "glib-utils.h"
+#include "main.h"
+#include "gtk-utils.h"
+#include "mateconf-utils.h"
+#include "open-file.h"
+#include "typedefs.h"
+#include "ui.h"
+
+
+#define LAST_OUTPUT_DIALOG_NAME "last-output"
+#define MAX_HISTORY_LEN 5
+#define ACTIVITY_DELAY 100
+#define ACTIVITY_PULSE_STEP (0.033)
+#define MAX_MESSAGE_LENGTH 50
+
+#define PROGRESS_DIALOG_DEFAULT_WIDTH 400
+#define PROGRESS_TIMEOUT_MSECS 5000
+#define PROGRESS_BAR_HEIGHT 10
+#undef  LOG_PROGRESS
+
+#define HIDE_PROGRESS_TIMEOUT_MSECS 500
+#define DEFAULT_NAME_COLUMN_WIDTH 250
+#define OTHER_COLUMNS_WIDTH 100
+#define RECENT_ITEM_MAX_WIDTH 25
+
+#define DEF_WIN_WIDTH 600
+#define DEF_WIN_HEIGHT 480
+#define DEF_SIDEBAR_WIDTH 200
+
+#define FILE_LIST_ICON_SIZE GTK_ICON_SIZE_LARGE_TOOLBAR
+#define DIR_TREE_ICON_SIZE GTK_ICON_SIZE_MENU
+
+#define BAD_CHARS "/\\*"
+
+static GHashTable     *pixbuf_hash = NULL;
+static GHashTable     *tree_pixbuf_hash = NULL;
+static GtkIconTheme   *icon_theme = NULL;
+static int             file_list_icon_size = 0;
+static int             dir_tree_icon_size = 0;
+
+#define XDS_FILENAME "xds.txt"
+#define MAX_XDS_ATOM_VAL_LEN 4096
+#define XDS_ATOM   gdk_atom_intern  ("XdndDirectSave0", FALSE)
+#define TEXT_ATOM  gdk_atom_intern  ("text/plain", FALSE)
+#define OCTET_ATOM gdk_atom_intern  ("application/octet-stream", FALSE)
+#define XFR_ATOM   gdk_atom_intern  ("XdndFileRoller0", FALSE)
+
+#define FR_CLIPBOARD (gdk_atom_intern_static_string ("_FILE_ROLLER_SPECIAL_CLIPBOARD"))
+#define FR_SPECIAL_URI_LIST (gdk_atom_intern_static_string ("application/file-roller-uri-list"))
+
+static GtkTargetEntry clipboard_targets[] = {
+	{ "application/file-roller-uri-list", 0, 1 }
+};
+
+static GtkTargetEntry target_table[] = {
+	{ "XdndFileRoller0", 0, 0 },
+	{ "text/uri-list", 0, 1 },
+};
+
+static GtkTargetEntry folder_tree_targets[] = {
+	{ "XdndFileRoller0", 0, 0 },
+	{ "XdndDirectSave0", 0, 2 }
+};
+
+
+typedef struct {
+	FrBatchActionType type;
+	void *            data;
+	GFreeFunc         free_func;
+} FRBatchAction;
+
+
+typedef struct {
+	guint      converting : 1;
+	char      *temp_dir;
+	FrArchive *new_archive;
+	char      *password;
+	gboolean   encrypt_header;
+	guint      volume_size;
+	char      *new_file;
+} FRConvertData;
+
+
+typedef enum {
+	FR_CLIPBOARD_OP_CUT,
+	FR_CLIPBOARD_OP_COPY
+} FRClipboardOp;
+
+
+typedef struct {
+	GList    *file_list;
+	char     *extract_to_dir;
+	char     *base_dir;
+	gboolean  skip_older;
+	gboolean  overwrite;
+	gboolean  junk_paths;
+	char     *password;
+	gboolean  extract_here;
+} ExtractData;
+
+
+typedef enum {
+	FR_WINDOW_AREA_MENUBAR,
+	FR_WINDOW_AREA_TOOLBAR,
+	FR_WINDOW_AREA_LOCATIONBAR,
+	FR_WINDOW_AREA_CONTENTS,
+	FR_WINDOW_AREA_FILTERBAR,
+	FR_WINDOW_AREA_STATUSBAR,
+} FrWindowArea;
+
+
+typedef enum {
+	DIALOG_RESPONSE_NONE = 1,
+	DIALOG_RESPONSE_OPEN_ARCHIVE,
+	DIALOG_RESPONSE_OPEN_DESTINATION_FOLDER,
+	DIALOG_RESPONSE_QUIT
+} DialogResponse;
+
+
+/* -- FrClipboardData -- */
+
+
+typedef struct {
+	int            refs;
+	char          *archive_filename;
+	char          *archive_password;
+	FRClipboardOp  op;
+	char          *base_dir;
+	GList         *files;
+	char          *tmp_dir;
+	char          *current_dir;
+} FrClipboardData;
+
+
+static FrClipboardData*
+fr_clipboard_data_new (void)
+{
+	FrClipboardData *data;
+
+	data = g_new0 (FrClipboardData, 1);
+	data->refs = 1;
+
+	return data;
+}
+
+
+static FrClipboardData *
+fr_clipboard_data_ref (FrClipboardData *clipboard_data)
+{
+	clipboard_data->refs++;
+	return clipboard_data;
+}
+
+
+static void
+fr_clipboard_data_unref (FrClipboardData *clipboard_data)
+{
+	if (clipboard_data == NULL)
+		return;
+	if (--clipboard_data->refs > 0)
+		return;
+
+	g_free (clipboard_data->archive_filename);
+	g_free (clipboard_data->archive_password);
+	g_free (clipboard_data->base_dir);
+	g_free (clipboard_data->tmp_dir);
+	g_free (clipboard_data->current_dir);
+	g_list_foreach (clipboard_data->files, (GFunc) g_free, NULL);
+	g_list_free (clipboard_data->files);
+	g_free (clipboard_data);
+}
+
+
+static void
+fr_clipboard_data_set_password (FrClipboardData *clipboard_data,
+				const char      *password)
+{
+	if (clipboard_data->archive_password != password)
+		g_free (clipboard_data->archive_password);
+	if (password != NULL)
+		clipboard_data->archive_password = g_strdup (password);
+}
+
+
+/**/
+
+enum {
+	ARCHIVE_LOADED,
+	LAST_SIGNAL
+};
+
+static GtkWindowClass *parent_class = NULL;
+static guint fr_window_signals[LAST_SIGNAL] = { 0 };
+
+struct _FrWindowPrivateData {
+	GtkWidget         *layout;
+	GtkWidget         *contents;
+	GtkWidget         *list_view;
+	GtkListStore      *list_store;
+	GtkWidget         *tree_view;
+	GtkTreeStore      *tree_store;
+	GtkWidget         *toolbar;
+	GtkWidget         *statusbar;
+	GtkWidget         *progress_bar;
+	GtkWidget         *location_bar;
+	GtkWidget         *location_entry;
+	GtkWidget         *location_label;
+	GtkWidget         *filter_bar;
+	GtkWidget         *filter_entry;
+	GtkWidget         *paned;
+	GtkWidget         *sidepane;
+	GtkTreePath       *tree_hover_path;
+	GtkTreePath       *list_hover_path;
+	GtkTreeViewColumn *filename_column;
+
+	gboolean         filter_mode;
+	gint             current_view_length;
+
+	guint            help_message_cid;
+	guint            list_info_cid;
+	guint            progress_cid;
+	char *           last_status_message;
+
+	GtkWidget *      up_arrows[5];
+	GtkWidget *      down_arrows[5];
+
+	FrAction         action;
+	gboolean         archive_present;
+	gboolean         archive_new;        /* A new archive has been created
+					      * but it doesn't contain any
+					      * file yet.  The real file will
+					      * be created only when the user
+					      * adds some file to the
+					      * archive.*/
+
+	char *           archive_uri;
+	char *           open_default_dir;    /* default directory to be used
+					       * in the Open dialog. */
+	char *           add_default_dir;     /* default directory to be used
+					       * in the Add dialog. */
+	char *           extract_default_dir; /* default directory to be used
+					       * in the Extract dialog. */
+	gboolean         freeze_default_dir;
+	gboolean         asked_for_password;
+	gboolean         ask_to_open_destination_after_extraction;
+	gboolean         destroy_with_error_dialog;
+
+	FRBatchAction    current_batch_action;
+
+	gboolean         give_focus_to_the_list;
+	gboolean         single_click;
+	GtkTreePath     *path_clicked;
+
+	FrWindowSortMethod sort_method;
+	GtkSortType      sort_type;
+
+	char *           last_location;
+
+	gboolean         view_folders;
+	FrWindowListMode list_mode;
+	FrWindowListMode last_list_mode;
+	GList *          history;
+	GList *          history_current;
+	char *           password;
+	char *           password_for_paste;
+	gboolean         encrypt_header;
+	FrCompression    compression;
+	guint            volume_size;
+
+	guint            activity_timeout_handle;   /* activity timeout
+						     * handle. */
+	gint             activity_ref;              /* when > 0 some activity
+						     * is present. */
+
+	guint            update_timeout_handle;     /* update file list
+						     * timeout handle. */
+
+	FRConvertData    convert_data;
+
+	gboolean         stoppable;
+	gboolean         closing;
+
+	FrClipboardData *clipboard_data;
+	FrClipboardData *copy_data;
+
+	FrArchive       *copy_from_archive;
+
+	GtkActionGroup  *actions;
+
+	GtkRecentManager *recent_manager;
+	GtkWidget        *recent_chooser_menu;
+	GtkWidget        *recent_chooser_toolbar;
+
+	GtkWidget        *file_popup_menu;
+	GtkWidget        *folder_popup_menu;
+	GtkWidget        *sidebar_folder_popup_menu;
+	GtkWidget        *mitem_recents_menu;
+	GtkWidget        *recent_toolbar_menu;
+	GtkAction        *open_action;
+
+	/* dragged files data */
+
+	char             *drag_destination_folder;
+	char             *drag_base_dir;
+	GError           *drag_error;
+	GList            *drag_file_list;        /* the list of files we are
+					 	  * dragging*/
+
+	/* progress dialog data */
+
+	GtkWidget        *progress_dialog;
+	GtkWidget        *pd_action;
+	GtkWidget        *pd_archive;
+	GtkWidget        *pd_message;
+	GtkWidget        *pd_progress_bar;
+	GtkWidget        *pd_cancel_button;
+	GtkWidget        *pd_close_button;
+	GtkWidget        *pd_open_archive_button;
+	GtkWidget        *pd_open_destination_button;
+	GtkWidget        *pd_quit_button;
+	gboolean          progress_pulse;
+	guint             progress_timeout;  /* Timeout to display the progress dialog. */
+	guint             hide_progress_timeout;  /* Timeout to hide the progress dialog. */
+	FrAction          pd_last_action;
+	char             *pd_last_archive;
+	char             *working_archive;
+
+	/* update dialog data */
+
+	gpointer          update_dialog;
+	GList            *open_files;
+
+	/* batch mode data */
+
+	gboolean          batch_mode;          /* whether we are in a non interactive
+					 	* mode. */
+	GList            *batch_action_list;   /* FRBatchAction * elements */
+	GList            *batch_action;        /* current action. */
+
+	/* misc */
+
+	guint             cnxn_id[MATECONF_NOTIFICATIONS];
+
+	gulong            theme_changed_handler_id;
+	gboolean          non_interactive;
+	char             *extract_here_dir;
+	gboolean          extract_interact_use_default_dir;
+	gboolean          update_dropped_files;
+	gboolean          batch_adding_one_file;
+
+	GtkWindow        *load_error_parent_window;
+	gboolean          showing_error_dialog;
+	GtkWindow        *error_dialog_parent;
+};
+
+
+/* -- fr_window_free_private_data -- */
+
+
+static void
+fr_window_remove_notifications (FrWindow *window)
+{
+	int i;
+
+	for (i = 0; i < MATECONF_NOTIFICATIONS; i++)
+		if (window->priv->cnxn_id[i] != -1)
+			eel_mateconf_notification_remove (window->priv->cnxn_id[i]);
+}
+
+
+static void
+fr_window_free_batch_data (FrWindow *window)
+{
+	GList *scan;
+
+	for (scan = window->priv->batch_action_list; scan; scan = scan->next) {
+		FRBatchAction *adata = scan->data;
+
+		if ((adata->data != NULL) && (adata->free_func != NULL))
+			(*adata->free_func) (adata->data);
+		g_free (adata);
+	}
+
+	g_list_free (window->priv->batch_action_list);
+	window->priv->batch_action_list = NULL;
+	window->priv->batch_action = NULL;
+}
+
+
+static void
+gh_unref_pixbuf (gpointer key,
+		 gpointer value,
+		 gpointer user_data)
+{
+	g_object_unref (value);
+}
+
+
+static void
+fr_window_clipboard_remove_file_list (FrWindow *window,
+				      GList    *file_list)
+{
+	GList *scan1;
+
+	if (window->priv->copy_data == NULL)
+		return;
+
+	if (file_list == NULL) {
+		fr_clipboard_data_unref	 (window->priv->copy_data);
+		window->priv->copy_data = NULL;
+		return;
+	}
+
+	for (scan1 = file_list; scan1; scan1 = scan1->next) {
+		const char *name1 = scan1->data;
+		GList      *scan2;
+
+		for (scan2 = window->priv->copy_data->files; scan2;) {
+			const char *name2 = scan2->data;
+
+			if (strcmp (name1, name2) == 0) {
+				GList *tmp = scan2->next;
+				window->priv->copy_data->files = g_list_remove_link (window->priv->copy_data->files, scan2);
+				g_free (scan2->data);
+				g_list_free (scan2);
+				scan2 = tmp;
+			}
+			else
+				scan2 = scan2->next;
+		}
+	}
+
+	if (window->priv->copy_data->files == NULL) {
+		fr_clipboard_data_unref (window->priv->copy_data);
+		window->priv->copy_data = NULL;
+	}
+}
+
+
+static void
+fr_window_history_clear (FrWindow *window)
+{
+	if (window->priv->history != NULL)
+		path_list_free (window->priv->history);
+	window->priv->history = NULL;
+	window->priv->history_current = NULL;
+	g_free (window->priv->last_location);
+	window->priv->last_location = NULL;
+}
+
+
+static void
+fr_window_free_open_files (FrWindow *window)
+{
+	GList *scan;
+
+	for (scan = window->priv->open_files; scan; scan = scan->next) {
+		OpenFile *file = scan->data;
+
+		if (file->monitor != NULL)
+			g_file_monitor_cancel (file->monitor);
+		open_file_free (file);
+	}
+	g_list_free (window->priv->open_files);
+	window->priv->open_files = NULL;
+}
+
+
+static void
+fr_window_convert_data_free (FrWindow   *window,
+			     gboolean    all)
+{
+	if (all) {
+		g_free (window->priv->convert_data.new_file);
+		window->priv->convert_data.new_file = NULL;
+	}
+
+	window->priv->convert_data.converting = FALSE;
+
+	if (window->priv->convert_data.temp_dir != NULL) {
+		g_free (window->priv->convert_data.temp_dir);
+		window->priv->convert_data.temp_dir = NULL;
+	}
+
+	if (window->priv->convert_data.new_archive != NULL) {
+		g_object_unref (window->priv->convert_data.new_archive);
+		window->priv->convert_data.new_archive = NULL;
+	}
+
+	if (window->priv->convert_data.password != NULL) {
+		g_free (window->priv->convert_data.password);
+		window->priv->convert_data.password = NULL;
+	}
+}
+
+
+static void
+fr_window_free_private_data (FrWindow *window)
+{
+	FrWindowPrivateData *priv = window->priv;
+
+	if (priv->update_timeout_handle != 0) {
+		g_source_remove (priv->update_timeout_handle);
+		priv->update_timeout_handle = 0;
+	}
+
+	fr_window_remove_notifications (window);
+
+	if (priv->open_action != NULL) {
+		g_object_unref (priv->open_action);
+		priv->open_action = NULL;
+	}
+
+	if (priv->recent_toolbar_menu != NULL) {
+		gtk_widget_destroy (priv->recent_toolbar_menu);
+		priv->recent_toolbar_menu = NULL;
+	}
+
+	while (priv->activity_ref > 0)
+		fr_window_stop_activity_mode (window);
+
+	if (priv->progress_timeout != 0) {
+		g_source_remove (priv->progress_timeout);
+		priv->progress_timeout = 0;
+	}
+
+	if (priv->hide_progress_timeout != 0) {
+		g_source_remove (priv->hide_progress_timeout);
+		priv->hide_progress_timeout = 0;
+	}
+
+	if (priv->theme_changed_handler_id != 0)
+		g_signal_handler_disconnect (icon_theme, priv->theme_changed_handler_id);
+
+	fr_window_history_clear (window);
+
+	g_free (priv->open_default_dir);
+	g_free (priv->add_default_dir);
+	g_free (priv->extract_default_dir);
+	g_free (priv->archive_uri);
+
+	g_free (priv->password);
+	g_free (priv->password_for_paste);
+
+	g_object_unref (priv->list_store);
+
+	if (window->priv->clipboard_data != NULL) {
+		fr_clipboard_data_unref (window->priv->clipboard_data);
+		window->priv->clipboard_data = NULL;
+	}
+	if (window->priv->copy_data != NULL) {
+		fr_clipboard_data_unref (window->priv->copy_data);
+		window->priv->copy_data = NULL;
+	}
+	if (priv->copy_from_archive != NULL) {
+		g_object_unref (priv->copy_from_archive);
+		priv->copy_from_archive = NULL;
+	}
+
+	fr_window_free_open_files (window);
+
+	fr_window_convert_data_free (window, TRUE);
+
+	g_clear_error (&priv->drag_error);
+	path_list_free (priv->drag_file_list);
+	priv->drag_file_list = NULL;
+
+	if (priv->file_popup_menu != NULL) {
+		gtk_widget_destroy (priv->file_popup_menu);
+		priv->file_popup_menu = NULL;
+	}
+
+	if (priv->folder_popup_menu != NULL) {
+		gtk_widget_destroy (priv->folder_popup_menu);
+		priv->folder_popup_menu = NULL;
+	}
+
+	if (priv->sidebar_folder_popup_menu != NULL) {
+		gtk_widget_destroy (priv->sidebar_folder_popup_menu);
+		priv->sidebar_folder_popup_menu = NULL;
+	}
+
+	g_free (window->priv->last_location);
+
+	fr_window_free_batch_data (window);
+	fr_window_reset_current_batch_action (window);
+
+	g_free (priv->pd_last_archive);
+	g_free (priv->extract_here_dir);
+	g_free (priv->last_status_message);
+
+	preferences_set_sort_method (priv->sort_method);
+	preferences_set_sort_type (priv->sort_type);
+	preferences_set_list_mode (priv->last_list_mode);
+}
+
+
+static void
+fr_window_finalize (GObject *object)
+{
+	FrWindow *window = FR_WINDOW (object);
+
+	fr_window_free_open_files (window);
+
+	if (window->archive != NULL) {
+		g_object_unref (window->archive);
+		window->archive = NULL;
+	}
+
+	if (window->priv != NULL) {
+		fr_window_free_private_data (window);
+		g_free (window->priv);
+		window->priv = NULL;
+	}
+
+	WindowList = g_list_remove (WindowList, window);
+
+	G_OBJECT_CLASS (parent_class)->finalize (object);
+
+	if (WindowList == NULL) {
+		if (pixbuf_hash != NULL) {
+			g_hash_table_foreach (pixbuf_hash,
+					      gh_unref_pixbuf,
+					      NULL);
+			g_hash_table_destroy (pixbuf_hash);
+		}
+		if (tree_pixbuf_hash != NULL) {
+			g_hash_table_foreach (tree_pixbuf_hash,
+					      gh_unref_pixbuf,
+					      NULL);
+			g_hash_table_destroy (tree_pixbuf_hash);
+		}
+
+		gtk_main_quit ();
+	}
+}
+
+
+static gboolean
+close__step2 (gpointer data)
+{
+	gtk_widget_destroy (GTK_WIDGET (data));
+	return FALSE;
+}
+
+
+void
+fr_window_close (FrWindow *window)
+{
+	if (window->priv->activity_ref > 0)
+		return;
+
+	window->priv->closing = TRUE;
+
+	if (gtk_widget_get_realized (GTK_WIDGET (window))) {
+		int width, height;
+
+		#if GTK_CHECK_VERSION(3, 0, 0)
+			width = gdk_window_get_width(gtk_widget_get_window(GTK_WIDGET(window)));
+			height = gdk_window_get_height(gtk_widget_get_window(GTK_WIDGET(window)));
+		#else
+			gdk_drawable_get_size(gtk_widget_get_window(GTK_WIDGET(window)), &width, &height);
+		#endif
+
+		eel_mateconf_set_integer (PREF_UI_WINDOW_WIDTH, width);
+		eel_mateconf_set_integer (PREF_UI_WINDOW_HEIGHT, height);
+
+		width = gtk_paned_get_position (GTK_PANED (window->priv->paned));
+		if (width > 0)
+			eel_mateconf_set_integer (PREF_UI_SIDEBAR_WIDTH, width);
+
+		width = gtk_tree_view_column_get_width (window->priv->filename_column);
+		if (width > 0)
+			eel_mateconf_set_integer (PREF_NAME_COLUMN_WIDTH, width);
+	}
+
+	g_idle_add (close__step2, window);
+}
+
+
+static void
+fr_window_class_init (FrWindowClass *class)
+{
+	GObjectClass   *gobject_class;
+	GtkWidgetClass *widget_class;
+
+	parent_class = g_type_class_peek_parent (class);
+
+	fr_window_signals[ARCHIVE_LOADED] =
+		g_signal_new ("archive-loaded",
+			      G_TYPE_FROM_CLASS (class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (FrWindowClass, archive_loaded),
+			      NULL, NULL,
+			      fr_marshal_VOID__BOOLEAN,
+			      G_TYPE_NONE, 1,
+			      G_TYPE_BOOLEAN);
+
+	gobject_class = (GObjectClass*) class;
+	gobject_class->finalize = fr_window_finalize;
+
+	widget_class = (GtkWidgetClass*) class;
+}
+
+
+static void fr_window_update_paste_command_sensitivity (FrWindow *, GtkClipboard *);
+
+
+static void
+clipboard_owner_change_cb (GtkClipboard *clipboard,
+			   GdkEvent     *event,
+			   gpointer      user_data)
+{
+	fr_window_update_paste_command_sensitivity ((FrWindow *) user_data, clipboard);
+}
+
+
+static void
+fr_window_realized (GtkWidget *window,
+		    gpointer  *data)
+{
+	GtkClipboard *clipboard;
+
+	clipboard = gtk_widget_get_clipboard (window, FR_CLIPBOARD);
+	g_signal_connect (clipboard,
+			  "owner_change",
+			  G_CALLBACK (clipboard_owner_change_cb),
+			  window);
+}
+
+
+static void
+fr_window_unrealized (GtkWidget *window,
+		      gpointer  *data)
+{
+	GtkClipboard *clipboard;
+
+	clipboard = gtk_widget_get_clipboard (window, FR_CLIPBOARD);
+	g_signal_handlers_disconnect_by_func (clipboard,
+					      G_CALLBACK (clipboard_owner_change_cb),
+					      window);
+}
+
+
+static void
+fr_window_init (FrWindow *window)
+{
+	window->priv = g_new0 (FrWindowPrivateData, 1);
+	window->priv->update_dropped_files = FALSE;
+	window->priv->filter_mode = FALSE;
+
+	g_signal_connect (window,
+			  "realize",
+			  G_CALLBACK (fr_window_realized),
+			  NULL);
+	g_signal_connect (window,
+			  "unrealize",
+			  G_CALLBACK (fr_window_unrealized),
+			  NULL);
+
+	WindowList = g_list_prepend (WindowList, window);
+}
+
+
+GType
+fr_window_get_type (void)
+{
+	static GType type = 0;
+
+	if (! type) {
+		GTypeInfo type_info = {
+			sizeof (FrWindowClass),
+			NULL,
+			NULL,
+			(GClassInitFunc) fr_window_class_init,
+			NULL,
+			NULL,
+			sizeof (FrWindow),
+			0,
+			(GInstanceInitFunc) fr_window_init
+		};
+
+		type = g_type_register_static (GTK_TYPE_WINDOW,
+					       "FrWindow",
+					       &type_info,
+					       0);
+	}
+
+	return type;
+}
+
+
+/* -- window history -- */
+
+
+#if 0
+static void
+fr_window_history_print (FrWindow *window)
+{
+	GList *list;
+
+	debug (DEBUG_INFO, "history:\n");
+	for (list = window->priv->history; list; list = list->next)
+		g_print ("\t%s %s\n",
+			 (char*) list->data,
+			 (list == window->priv->history_current)? "<-": "");
+	g_print ("\n");
+}
+#endif
+
+
+static void
+fr_window_history_add (FrWindow   *window,
+		       const char *path)
+{
+	if ((window->priv->history != NULL) && (window->priv->history_current != NULL)) {
+		if (strcmp (window->priv->history_current->data, path) == 0)
+			return;
+
+		/* Add locations visited using the back button to the history
+		 * list. */
+		if (window->priv->history != window->priv->history_current) {
+			GList *scan = window->priv->history->next;
+			while (scan != window->priv->history_current->next) {
+				window->priv->history = g_list_prepend (window->priv->history, g_strdup (scan->data));
+				scan = scan->next;
+			}
+		}
+	}
+
+	window->priv->history = g_list_prepend (window->priv->history, g_strdup (path));
+	window->priv->history_current = window->priv->history;
+}
+
+
+static void
+fr_window_history_pop (FrWindow *window)
+{
+	GList *first;
+
+	if (window->priv->history == NULL)
+		return;
+
+	first = window->priv->history;
+	window->priv->history = g_list_remove_link (window->priv->history, first);
+	if (window->priv->history_current == first)
+		window->priv->history_current = window->priv->history;
+	g_free (first->data);
+	g_list_free (first);
+}
+
+
+/* -- window_update_file_list -- */
+
+
+static GPtrArray *
+fr_window_get_current_dir_list (FrWindow *window)
+{
+	GPtrArray *files;
+	int        i;
+
+	files = g_ptr_array_sized_new (128);
+
+	for (i = 0; i < window->archive->command->files->len; i++) {
+		FileData *fdata = g_ptr_array_index (window->archive->command->files, i);
+
+		if (fdata->list_name == NULL)
+			continue;
+		g_ptr_array_add (files, fdata);
+	}
+
+	return files;
+}
+
+
+static gint
+sort_by_name (gconstpointer  ptr1,
+	      gconstpointer  ptr2)
+{
+	FileData *fdata1 = *((FileData **) ptr1);
+	FileData *fdata2 = *((FileData **) ptr2);
+
+	if (file_data_is_dir (fdata1) != file_data_is_dir (fdata2)) {
+		if (file_data_is_dir (fdata1))
+			return -1;
+		else
+			return 1;
+	}
+
+	return strcasecmp (fdata1->list_name, fdata2->list_name);
+}
+
+
+static gint
+sort_by_size (gconstpointer  ptr1,
+	      gconstpointer  ptr2)
+{
+	FileData *fdata1 = *((FileData **) ptr1);
+	FileData *fdata2 = *((FileData **) ptr2);
+
+	if (file_data_is_dir (fdata1) != file_data_is_dir (fdata2)) {
+		if (file_data_is_dir (fdata1))
+			return -1;
+		else
+			return 1;
+	}
+	else if (file_data_is_dir (fdata1) && file_data_is_dir (fdata2)) {
+		if (fdata1->dir_size > fdata2->dir_size)
+			return 1;
+		else
+			return -1;
+	}
+
+	if (fdata1->size == fdata2->size)
+		return sort_by_name (ptr1, ptr2);
+	else if (fdata1->size > fdata2->size)
+		return 1;
+	else
+		return -1;
+}
+
+
+static gint
+sort_by_type (gconstpointer  ptr1,
+	      gconstpointer  ptr2)
+{
+	FileData    *fdata1 = *((FileData **) ptr1);
+	FileData    *fdata2 = *((FileData **) ptr2);
+	int          result;
+	const char  *desc1, *desc2;
+
+	if (file_data_is_dir (fdata1) != file_data_is_dir (fdata2)) {
+		if (file_data_is_dir (fdata1))
+			return -1;
+		else
+			return 1;
+	}
+	else if (file_data_is_dir (fdata1) && file_data_is_dir (fdata2))
+		return sort_by_name (ptr1, ptr2);
+
+	desc1 = g_content_type_get_description (fdata1->content_type);
+	desc2 = g_content_type_get_description (fdata2->content_type);
+
+	result = strcasecmp (desc1, desc2);
+	if (result == 0)
+		return sort_by_name (ptr1, ptr2);
+	else
+		return result;
+}
+
+
+static gint
+sort_by_time (gconstpointer  ptr1,
+	      gconstpointer  ptr2)
+{
+	FileData *fdata1 = *((FileData **) ptr1);
+	FileData *fdata2 = *((FileData **) ptr2);
+
+	if (file_data_is_dir (fdata1) != file_data_is_dir (fdata2)) {
+		if (file_data_is_dir (fdata1))
+			return -1;
+		else
+			return 1;
+	}
+	else if (file_data_is_dir (fdata1) && file_data_is_dir (fdata2))
+		return sort_by_name (ptr1, ptr2);
+
+	if (fdata1->modified == fdata2->modified)
+		return sort_by_name (ptr1, ptr2);
+	else if (fdata1->modified > fdata2->modified)
+		return 1;
+	else
+		return -1;
+}
+
+
+static gint
+sort_by_path (gconstpointer  ptr1,
+	      gconstpointer  ptr2)
+{
+	FileData *fdata1 = *((FileData **) ptr1);
+	FileData *fdata2 = *((FileData **) ptr2);
+	int       result;
+
+	if (file_data_is_dir (fdata1) != file_data_is_dir (fdata2)) {
+		if (file_data_is_dir (fdata1))
+			return -1;
+		else
+			return 1;
+	}
+	else if (file_data_is_dir (fdata1) && file_data_is_dir (fdata2))
+		return sort_by_name (ptr1, ptr2);
+
+	/* 2 files */
+
+	result = strcasecmp (fdata1->path, fdata2->path);
+	if (result == 0)
+		return sort_by_name (ptr1, ptr2);
+	else
+		return result;
+}
+
+
+static guint64
+get_dir_size (FrWindow   *window,
+	      const char *current_dir,
+	      const char *name)
+{
+	guint64  size;
+	char    *dirname;
+	int      dirname_l;
+	int      i;
+
+	dirname = g_strconcat (current_dir, name, "/", NULL);
+	dirname_l = strlen (dirname);
+
+	size = 0;
+	for (i = 0; i < window->archive->command->files->len; i++) {
+		FileData *fd = g_ptr_array_index (window->archive->command->files, i);
+
+		if (strncmp (dirname, fd->full_path, dirname_l) == 0)
+			size += fd->size;
+	}
+
+	g_free (dirname);
+
+	return size;
+}
+
+
+static gboolean
+file_data_respects_filter (FrWindow *window,
+			   FileData *fdata)
+{
+	const char *filter;
+
+	filter = gtk_entry_get_text (GTK_ENTRY (window->priv->filter_entry));
+	if ((fdata == NULL) || (filter == NULL) || (*filter == '\0'))
+		return TRUE;
+
+	if (fdata->dir || (fdata->name == NULL))
+		return FALSE;
+
+	return strncasecmp (fdata->name, filter, strlen (filter)) == 0;
+}
+
+
+static gboolean
+compute_file_list_name (FrWindow   *window,
+			FileData   *fdata,
+			const char *current_dir,
+			int         current_dir_len,
+			GHashTable *names_hash,
+			gboolean   *different_name)
+{
+	register char *scan, *end;
+
+	*different_name = FALSE;
+
+	if (! file_data_respects_filter (window, fdata))
+		return FALSE;
+
+	if (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT) {
+		fdata->list_name = g_strdup (fdata->name);
+		if (fdata->dir)
+			fdata->dir_size = 0;
+		return FALSE;
+	}
+
+	if (strncmp (fdata->full_path, current_dir, current_dir_len) != 0) {
+		*different_name = TRUE;
+		return FALSE;
+	}
+
+	if (strlen (fdata->full_path) == current_dir_len)
+		return FALSE;
+
+	scan = fdata->full_path + current_dir_len;
+	end = strchr (scan, '/');
+	if ((end == NULL) && ! fdata->dir) { /* file */
+		fdata->list_name = g_strdup (scan);
+	}
+	else { /* folder */
+		char *dir_name;
+
+		if (end != NULL)
+			dir_name = g_strndup (scan, end - scan);
+		else
+			dir_name = g_strdup (scan);
+
+		/* avoid to insert duplicated folders */
+		if (g_hash_table_lookup (names_hash, dir_name) != NULL) {
+			g_free (dir_name);
+			return FALSE;
+		}
+		g_hash_table_insert (names_hash, dir_name, GINT_TO_POINTER (1));
+
+		if ((end != NULL) && (*(end + 1) != '\0'))
+			fdata->list_dir = TRUE;
+		fdata->list_name = dir_name;
+		fdata->dir_size = get_dir_size (window, current_dir, dir_name);
+	}
+
+	return TRUE;
+}
+
+
+static void
+fr_window_compute_list_names (FrWindow  *window,
+			      GPtrArray *files)
+{
+	const char *current_dir;
+	int         current_dir_len;
+	GHashTable *names_hash;
+	int         i;
+	gboolean    visible_list_started = FALSE;
+	gboolean    visible_list_completed = FALSE;
+	gboolean    different_name;
+
+	current_dir = fr_window_get_current_location (window);
+	current_dir_len = strlen (current_dir);
+	names_hash = g_hash_table_new (g_str_hash, g_str_equal);
+
+	for (i = 0; i < files->len; i++) {
+		FileData *fdata = g_ptr_array_index (files, i);
+
+		g_free (fdata->list_name);
+		fdata->list_name = NULL;
+		fdata->list_dir = FALSE;
+
+		/* the files array is sorted by path, when the visible list
+		 * is started and we find a path that doesn't match the
+		 * current_dir path, the following files can't match
+		 * the current_dir path. */
+
+		if (visible_list_completed)
+			continue;
+
+		if (compute_file_list_name (window, fdata, current_dir, current_dir_len, names_hash, &different_name)) {
+			visible_list_started = TRUE;
+		}
+		else if (visible_list_started && different_name)
+			visible_list_completed = TRUE;
+	}
+
+	g_hash_table_destroy (names_hash);
+}
+
+
+static gboolean
+fr_window_dir_exists_in_archive (FrWindow   *window,
+				 const char *dir_name)
+{
+	int dir_name_len;
+	int i;
+
+	if (dir_name == NULL)
+		return FALSE;
+
+	dir_name_len = strlen (dir_name);
+	if (dir_name_len == 0)
+		return TRUE;
+
+	if (strcmp (dir_name, "/") == 0)
+		return TRUE;
+
+	for (i = 0; i < window->archive->command->files->len; i++) {
+		FileData *fdata = g_ptr_array_index (window->archive->command->files, i);
+
+		if (strncmp (dir_name, fdata->full_path, dir_name_len) == 0) {
+			return TRUE;
+		}
+		else if (fdata->dir
+			 && (fdata->full_path[strlen (fdata->full_path)] != '/')
+			 && (strncmp (dir_name, fdata->full_path, dir_name_len - 1) == 0))
+		{
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+
+static char *
+get_parent_dir (const char *current_dir)
+{
+	char *dir;
+	char *new_dir;
+	char *retval;
+
+	if (current_dir == NULL)
+		return NULL;
+	if (strcmp (current_dir, "/") == 0)
+		return g_strdup ("/");
+
+	dir = g_strdup (current_dir);
+	dir[strlen (dir) - 1] = 0;
+	new_dir = remove_level_from_path (dir);
+	g_free (dir);
+
+	if (new_dir[strlen (new_dir) - 1] == '/')
+		retval = new_dir;
+	else {
+		retval = g_strconcat (new_dir, "/", NULL);
+		g_free (new_dir);
+	}
+
+	return retval;
+}
+
+
+static void fr_window_update_statusbar_list_info (FrWindow *window);
+
+
+static GdkPixbuf *
+get_mime_type_icon (const char *mime_type)
+{
+	GdkPixbuf *pixbuf = NULL;
+
+	pixbuf = g_hash_table_lookup (tree_pixbuf_hash, mime_type);
+	if (pixbuf != NULL) {
+		g_object_ref (G_OBJECT (pixbuf));
+		return pixbuf;
+	}
+
+	pixbuf = get_mime_type_pixbuf (mime_type, file_list_icon_size, icon_theme);
+	if (pixbuf == NULL)
+		return NULL;
+
+	pixbuf = gdk_pixbuf_copy (pixbuf);
+	g_hash_table_insert (tree_pixbuf_hash, (gpointer) mime_type, pixbuf);
+	g_object_ref (G_OBJECT (pixbuf));
+
+	return pixbuf;
+}
+
+
+static GdkPixbuf *
+get_icon (GtkWidget *widget,
+	  FileData  *fdata)
+{
+	GdkPixbuf  *pixbuf = NULL;
+	const char *content_type;
+	GIcon      *icon;
+
+	if (file_data_is_dir (fdata))
+		content_type = MIME_TYPE_DIRECTORY;
+	else
+		content_type = fdata->content_type;
+
+	/* look in the hash table. */
+
+	pixbuf = g_hash_table_lookup (pixbuf_hash, content_type);
+	if (pixbuf != NULL) {
+		g_object_ref (G_OBJECT (pixbuf));
+		return pixbuf;
+	}
+
+	icon = g_content_type_get_icon (content_type);
+	pixbuf = get_icon_pixbuf (icon, file_list_icon_size, icon_theme);
+	g_object_unref (icon);
+
+	if (pixbuf == NULL)
+		return NULL;
+
+	pixbuf = gdk_pixbuf_copy (pixbuf);
+	g_hash_table_insert (pixbuf_hash, (gpointer) content_type, pixbuf);
+	g_object_ref (G_OBJECT (pixbuf));
+
+	return pixbuf;
+}
+
+
+static GdkPixbuf *
+get_emblem (GtkWidget *widget,
+	    FileData  *fdata)
+{
+	GdkPixbuf *pixbuf = NULL;
+
+	if (! fdata->encrypted)
+		return NULL;
+
+	/* encrypted */
+
+	pixbuf = g_hash_table_lookup (pixbuf_hash, "emblem-nowrite");
+	if (pixbuf != NULL) {
+		g_object_ref (G_OBJECT (pixbuf));
+		return pixbuf;
+	}
+
+	pixbuf = gtk_icon_theme_load_icon (icon_theme,
+					   "emblem-nowrite",
+					   file_list_icon_size,
+					   0,
+					   NULL);
+	if (pixbuf == NULL)
+		return NULL;
+
+	pixbuf = gdk_pixbuf_copy (pixbuf);
+	g_hash_table_insert (pixbuf_hash, (gpointer) "emblem-nowrite", pixbuf);
+	g_object_ref (G_OBJECT (pixbuf));
+
+	return pixbuf;
+}
+
+
+static int
+get_column_from_sort_method (FrWindowSortMethod sort_method)
+{
+	switch (sort_method) {
+	case FR_WINDOW_SORT_BY_NAME: return COLUMN_NAME;
+	case FR_WINDOW_SORT_BY_SIZE: return COLUMN_SIZE;
+	case FR_WINDOW_SORT_BY_TYPE: return COLUMN_TYPE;
+	case FR_WINDOW_SORT_BY_TIME: return COLUMN_TIME;
+	case FR_WINDOW_SORT_BY_PATH: return COLUMN_PATH;
+	default:
+		break;
+	}
+
+	return COLUMN_NAME;
+}
+
+
+static int
+get_sort_method_from_column (int column_id)
+{
+	switch (column_id) {
+	case COLUMN_NAME: return FR_WINDOW_SORT_BY_NAME;
+	case COLUMN_SIZE: return FR_WINDOW_SORT_BY_SIZE;
+	case COLUMN_TYPE: return FR_WINDOW_SORT_BY_TYPE;
+	case COLUMN_TIME: return FR_WINDOW_SORT_BY_TIME;
+	case COLUMN_PATH: return FR_WINDOW_SORT_BY_PATH;
+	default:
+		break;
+	}
+
+	return FR_WINDOW_SORT_BY_NAME;
+}
+
+
+static void
+add_selected_from_list_view (GtkTreeModel *model,
+			     GtkTreePath  *path,
+			     GtkTreeIter  *iter,
+			     gpointer      data)
+{
+	GList    **list = data;
+	FileData  *fdata;
+
+	gtk_tree_model_get (model, iter,
+			    COLUMN_FILE_DATA, &fdata,
+			    -1);
+	*list = g_list_prepend (*list, fdata);
+}
+
+
+static void
+add_selected_from_tree_view (GtkTreeModel *model,
+			     GtkTreePath  *path,
+			     GtkTreeIter  *iter,
+			     gpointer      data)
+{
+	GList **list = data;
+	char   *dir_path;
+
+	gtk_tree_model_get (model, iter,
+			    TREE_COLUMN_PATH, &dir_path,
+			    -1);
+	*list = g_list_prepend (*list, dir_path);
+}
+
+
+static void
+add_selected_fd (GtkTreeModel *model,
+		 GtkTreePath  *path,
+		 GtkTreeIter  *iter,
+		 gpointer      data)
+{
+	GList    **list = data;
+	FileData  *fdata;
+
+	gtk_tree_model_get (model, iter,
+			    COLUMN_FILE_DATA, &fdata,
+			    -1);
+	if (! fdata->list_dir)
+		*list = g_list_prepend (*list, fdata);
+}
+
+
+static GList *
+get_selection_as_fd (FrWindow *window)
+{
+	GtkTreeSelection *selection;
+	GList            *list = NULL;
+
+	if (! gtk_widget_get_realized (window->priv->list_view))
+		return NULL;
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+	if (selection == NULL)
+		return NULL;
+	gtk_tree_selection_selected_foreach (selection, add_selected_fd, &list);
+
+	return list;
+}
+
+
+static void
+fr_window_update_statusbar_list_info (FrWindow *window)
+{
+	char    *info, *archive_info, *selected_info;
+	char    *size_txt, *sel_size_txt;
+	int      tot_n, sel_n;
+	goffset  tot_size, sel_size;
+	GList   *scan;
+
+	if (window == NULL)
+		return;
+
+	if ((window->archive == NULL) || (window->archive->command == NULL)) {
+		gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar), window->priv->list_info_cid);
+		return;
+	}
+
+	tot_n = 0;
+	tot_size = 0;
+
+	if (window->priv->archive_present) {
+		GPtrArray *files = fr_window_get_current_dir_list (window);
+		int        i;
+
+		for (i = 0; i < files->len; i++) {
+			FileData *fd = g_ptr_array_index (files, i);
+
+			tot_n++;
+			if (! file_data_is_dir (fd))
+				tot_size += fd->size;
+			else
+				tot_size += fd->dir_size;
+		}
+		g_ptr_array_free (files, TRUE);
+	}
+
+	sel_n = 0;
+	sel_size = 0;
+
+	if (window->priv->archive_present) {
+		GList *selection = get_selection_as_fd (window);
+
+		for (scan = selection; scan; scan = scan->next) {
+			FileData *fd = scan->data;
+
+			sel_n++;
+			if (! file_data_is_dir (fd))
+				sel_size += fd->size;
+		}
+		g_list_free (selection);
+	}
+
+	size_txt = g_format_size_for_display (tot_size);
+	sel_size_txt = g_format_size_for_display (sel_size);
+
+	if (tot_n == 0)
+		archive_info = g_strdup ("");
+	else
+		archive_info = g_strdup_printf (ngettext ("%d object (%s)", "%d objects (%s)", tot_n), tot_n, size_txt);
+
+	if (sel_n == 0)
+		selected_info = g_strdup ("");
+	else
+		selected_info = g_strdup_printf (ngettext ("%d object selected (%s)", "%d objects selected (%s)", sel_n), sel_n, sel_size_txt);
+
+	info = g_strconcat (archive_info,
+			    ((sel_n == 0) ? NULL : ", "),
+			    selected_info,
+			    NULL);
+
+	gtk_statusbar_push (GTK_STATUSBAR (window->priv->statusbar), window->priv->list_info_cid, info);
+
+	g_free (size_txt);
+	g_free (sel_size_txt);
+	g_free (archive_info);
+	g_free (selected_info);
+	g_free (info);
+}
+
+
+static void
+fr_window_populate_file_list (FrWindow  *window,
+			      GPtrArray *files)
+{
+	int i;
+
+	gtk_list_store_clear (window->priv->list_store);
+
+	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (window->priv->list_store),
+	 				      GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
+	 				      GTK_SORT_ASCENDING);
+
+	for (i = 0; i < files->len; i++) {
+		FileData    *fdata = g_ptr_array_index (files, i);
+		GtkTreeIter  iter;
+		GdkPixbuf   *icon, *emblem;
+		char        *utf8_name;
+
+		if (fdata->list_name == NULL)
+			continue;
+
+		gtk_list_store_append (window->priv->list_store, &iter);
+
+		icon = get_icon (GTK_WIDGET (window), fdata);
+		utf8_name = g_filename_display_name (fdata->list_name);
+		emblem = get_emblem (GTK_WIDGET (window), fdata);
+
+		if (file_data_is_dir (fdata)) {
+			char *utf8_path;
+			char *tmp;
+			char *s_size;
+			char *s_time;
+
+			if (fdata->list_dir)
+				tmp = remove_ending_separator (fr_window_get_current_location (window));
+
+			else
+				tmp = remove_level_from_path (fdata->path);
+			utf8_path = g_filename_display_name (tmp);
+			g_free (tmp);
+
+			s_size = g_format_size_for_display (fdata->dir_size);
+
+			if (fdata->list_dir)
+				s_time = g_strdup ("");
+			else
+				s_time = get_time_string (fdata->modified);
+
+			gtk_list_store_set (window->priv->list_store, &iter,
+					    COLUMN_FILE_DATA, fdata,
+					    COLUMN_ICON, icon,
+					    COLUMN_NAME, utf8_name,
+					    COLUMN_EMBLEM, emblem,
+					    COLUMN_TYPE, _("Folder"),
+					    COLUMN_SIZE, s_size,
+					    COLUMN_TIME, s_time,
+					    COLUMN_PATH, utf8_path,
+					    -1);
+			g_free (utf8_path);
+			g_free (s_size);
+			g_free (s_time);
+		}
+		else {
+			char       *utf8_path;
+			char       *s_size;
+			char       *s_time;
+			const char *desc;
+
+			utf8_path = g_filename_display_name (fdata->path);
+
+			s_size = g_format_size_for_display (fdata->size);
+			s_time = get_time_string (fdata->modified);
+			desc = g_content_type_get_description (fdata->content_type);
+
+			gtk_list_store_set (window->priv->list_store, &iter,
+					    COLUMN_FILE_DATA, fdata,
+					    COLUMN_ICON, icon,
+					    COLUMN_NAME, utf8_name,
+					    COLUMN_EMBLEM, emblem,
+					    COLUMN_TYPE, desc,
+					    COLUMN_SIZE, s_size,
+					    COLUMN_TIME, s_time,
+					    COLUMN_PATH, utf8_path,
+					    -1);
+			g_free (utf8_path);
+			g_free (s_size);
+			g_free (s_time);
+		}
+		g_free (utf8_name);
+		if (icon != NULL)
+			g_object_unref (icon);
+		if (emblem != NULL)
+			g_object_unref (emblem);
+	}
+
+	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (window->priv->list_store),
+					      get_column_from_sort_method (window->priv->sort_method),
+					      window->priv->sort_type);
+
+	fr_window_update_statusbar_list_info (window);
+	fr_window_stop_activity_mode (window);
+}
+
+
+static int
+path_compare (gconstpointer a,
+	      gconstpointer b)
+{
+	char *path_a = *((char**) a);
+	char *path_b = *((char**) b);
+
+	return strcmp (path_a, path_b);
+}
+
+
+static gboolean
+get_tree_iter_from_path (FrWindow    *window,
+			 const char  *path,
+			 GtkTreeIter *parent,
+			 GtkTreeIter *iter)
+{
+	gboolean    result = FALSE;
+
+	if (! gtk_tree_model_iter_children (GTK_TREE_MODEL (window->priv->tree_store), iter, parent))
+		return FALSE;
+
+	do {
+		GtkTreeIter  tmp;
+		char        *iter_path;
+
+		if (get_tree_iter_from_path (window, path, iter, &tmp)) {
+			*iter = tmp;
+			return TRUE;
+		}
+
+		gtk_tree_model_get (GTK_TREE_MODEL (window->priv->tree_store),
+				    iter,
+				    TREE_COLUMN_PATH, &iter_path,
+				    -1);
+
+		if ((iter_path != NULL) && (strcmp (path, iter_path) == 0)) {
+			result = TRUE;
+			g_free (iter_path);
+			break;
+		}
+		g_free (iter_path);
+	} while (gtk_tree_model_iter_next (GTK_TREE_MODEL (window->priv->tree_store), iter));
+
+	return result;
+}
+
+
+static void
+set_sensitive (FrWindow   *window,
+	       const char *action_name,
+	       gboolean    sensitive)
+{
+	GtkAction *action;
+
+	action = gtk_action_group_get_action (window->priv->actions, action_name);
+	g_object_set (action, "sensitive", sensitive, NULL);
+}
+
+
+static void
+fr_window_update_current_location (FrWindow *window)
+{
+	const char *current_dir = fr_window_get_current_location (window);
+	char       *path;
+	GtkTreeIter iter;
+
+	if (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT) {
+		gtk_widget_hide (window->priv->location_bar);
+		return;
+	}
+
+	gtk_widget_show (window->priv->location_bar);
+
+	gtk_entry_set_text (GTK_ENTRY (window->priv->location_entry), window->priv->archive_present? current_dir: "");
+
+	set_sensitive (window, "GoBack", window->priv->archive_present && (current_dir != NULL) && (window->priv->history_current != NULL) && (window->priv->history_current->next != NULL));
+	set_sensitive (window, "GoForward", window->priv->archive_present && (current_dir != NULL) && (window->priv->history_current != NULL) && (window->priv->history_current->prev != NULL));
+	set_sensitive (window, "GoUp", window->priv->archive_present && (current_dir != NULL) && (strcmp (current_dir, "/") != 0));
+	set_sensitive (window, "GoHome", window->priv->archive_present);
+	gtk_widget_set_sensitive (window->priv->location_entry, window->priv->archive_present);
+	gtk_widget_set_sensitive (window->priv->location_label, window->priv->archive_present);
+	gtk_widget_set_sensitive (window->priv->filter_entry, window->priv->archive_present);
+
+#if 0
+	fr_window_history_print (window);
+#endif
+
+	path = remove_ending_separator (current_dir);
+	if (get_tree_iter_from_path (window, path, NULL, &iter)) {
+		GtkTreeSelection *selection;
+		GtkTreePath      *t_path;
+
+		t_path = gtk_tree_model_get_path (GTK_TREE_MODEL (window->priv->tree_store), &iter);
+		gtk_tree_view_expand_to_path (GTK_TREE_VIEW (window->priv->tree_view), t_path);
+		gtk_tree_path_free (t_path);
+
+		selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->tree_view));
+		gtk_tree_selection_select_iter (selection, &iter);
+	}
+	g_free (path);
+}
+
+
+void
+fr_window_update_dir_tree (FrWindow *window)
+{
+	GPtrArray  *dirs;
+	GHashTable *dir_cache;
+	int         i;
+	GdkPixbuf  *icon;
+
+	gtk_tree_store_clear (window->priv->tree_store);
+
+	if (! window->priv->view_folders
+	    || ! window->priv->archive_present
+	    || (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT))
+	{
+		gtk_widget_set_sensitive (window->priv->tree_view, FALSE);
+		gtk_widget_hide (window->priv->sidepane);
+		return;
+	}
+	else {
+		gtk_widget_set_sensitive (window->priv->tree_view, TRUE);
+		if (! gtk_widget_get_visible (window->priv->sidepane))
+			gtk_widget_show_all (window->priv->sidepane);
+	}
+
+	if (gtk_widget_get_realized (window->priv->tree_view))
+		gtk_tree_view_scroll_to_point (GTK_TREE_VIEW (window->priv->tree_view), 0, 0);
+
+	/**/
+
+	dirs = g_ptr_array_sized_new (128);
+
+	dir_cache = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL);
+	for (i = 0; i < window->archive->command->files->len; i++) {
+		FileData *fdata = g_ptr_array_index (window->archive->command->files, i);
+		char     *dir;
+
+		if (gtk_entry_get_text (GTK_ENTRY (window->priv->filter_entry)) != NULL) {
+			if (! file_data_respects_filter (window, fdata))
+				continue;
+		}
+
+		if (fdata->dir)
+			dir = remove_ending_separator (fdata->full_path);
+		else
+			dir = remove_level_from_path (fdata->full_path);
+
+		while ((dir != NULL) && (strcmp (dir, "/") != 0)) {
+			char *new_dir;
+
+			if (g_hash_table_lookup (dir_cache, dir) != NULL)
+				break;
+
+			new_dir = dir;
+			g_ptr_array_add (dirs, new_dir);
+			g_hash_table_replace (dir_cache, new_dir, "1");
+
+			dir = remove_level_from_path (new_dir);
+		}
+
+		g_free (dir);
+	}
+	g_hash_table_destroy (dir_cache);
+
+	g_ptr_array_sort (dirs, path_compare);
+	dir_cache = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) gtk_tree_path_free);
+
+	/**/
+
+	icon = get_mime_type_icon (MIME_TYPE_ARCHIVE);
+	{
+		GtkTreeIter  node;
+		char        *uri;
+		char        *name;
+
+		uri = g_file_get_uri (window->archive->file);
+		name = g_uri_display_basename (uri);
+
+		gtk_tree_store_append (window->priv->tree_store, &node, NULL);
+		gtk_tree_store_set (window->priv->tree_store, &node,
+				    TREE_COLUMN_ICON, icon,
+				    TREE_COLUMN_NAME, name,
+				    TREE_COLUMN_PATH, "/",
+				    TREE_COLUMN_WEIGHT, PANGO_WEIGHT_BOLD,
+				    -1);
+		g_hash_table_replace (dir_cache, "/", gtk_tree_model_get_path (GTK_TREE_MODEL (window->priv->tree_store), &node));
+
+		g_free (name);
+		g_free (uri);
+	}
+	g_object_unref (icon);
+
+	/**/
+
+	icon = get_mime_type_icon (MIME_TYPE_DIRECTORY);
+	for (i = 0; i < dirs->len; i++) {
+		char        *dir = g_ptr_array_index (dirs, i);
+		char        *parent_dir;
+		GtkTreePath *parent_path;
+		GtkTreeIter  parent;
+		GtkTreeIter  node;
+
+		parent_dir = remove_level_from_path (dir);
+		if (parent_dir == NULL)
+			continue;
+
+		parent_path = g_hash_table_lookup (dir_cache, parent_dir);
+		gtk_tree_model_get_iter (GTK_TREE_MODEL (window->priv->tree_store),
+					 &parent,
+					 parent_path);
+		gtk_tree_store_append (window->priv->tree_store, &node, &parent);
+		gtk_tree_store_set (window->priv->tree_store, &node,
+				    TREE_COLUMN_ICON, icon,
+				    TREE_COLUMN_NAME, file_name_from_path (dir),
+				    TREE_COLUMN_PATH, dir,
+				    TREE_COLUMN_WEIGHT, PANGO_WEIGHT_NORMAL,
+				    -1);
+		g_hash_table_replace (dir_cache, dir, gtk_tree_model_get_path (GTK_TREE_MODEL (window->priv->tree_store), &node));
+
+		g_free (parent_dir);
+	}
+	g_hash_table_destroy (dir_cache);
+	if (icon != NULL)
+		g_object_unref (icon);
+
+	g_ptr_array_free (dirs, TRUE);
+
+	fr_window_update_current_location (window);
+}
+
+
+static void
+fr_window_update_filter_bar_visibility (FrWindow *window)
+{
+	const char *filter;
+
+	filter = gtk_entry_get_text (GTK_ENTRY (window->priv->filter_entry));
+	if ((filter == NULL) || (*filter == '\0'))
+		gtk_widget_hide (window->priv->filter_bar);
+	else
+		gtk_widget_show (window->priv->filter_bar);
+}
+
+
+static void
+fr_window_update_file_list (FrWindow *window,
+			    gboolean  update_view)
+{
+	GPtrArray  *files;
+	gboolean    free_files = FALSE;
+
+	if (gtk_widget_get_realized (window->priv->list_view))
+		gtk_tree_view_scroll_to_point (GTK_TREE_VIEW (window->priv->list_view), 0, 0);
+
+	if (! window->priv->archive_present || window->priv->archive_new) {
+		if (update_view)
+			gtk_list_store_clear (window->priv->list_store);
+
+		window->priv->current_view_length = 0;
+
+		if (window->priv->archive_new) {
+			gtk_widget_set_sensitive (window->priv->list_view, TRUE);
+			gtk_widget_show_all (gtk_widget_get_parent (window->priv->list_view));
+		}
+		else {
+			gtk_widget_set_sensitive (window->priv->list_view, FALSE);
+			gtk_widget_hide_all (gtk_widget_get_parent (window->priv->list_view));
+		}
+
+		return;
+	}
+	else {
+		gtk_widget_set_sensitive (window->priv->list_view, TRUE);
+		if (! gtk_widget_get_visible (window->priv->list_view))
+			gtk_widget_show_all (gtk_widget_get_parent (window->priv->list_view));
+	}
+
+	if (window->priv->give_focus_to_the_list) {
+		gtk_widget_grab_focus (window->priv->list_view);
+		window->priv->give_focus_to_the_list = FALSE;
+	}
+
+	/**/
+
+	fr_window_start_activity_mode (window);
+
+	if (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT) {
+		fr_window_compute_list_names (window, window->archive->command->files);
+		files = window->archive->command->files;
+		free_files = FALSE;
+	}
+	else {
+		char *current_dir = g_strdup (fr_window_get_current_location (window));
+
+		while (! fr_window_dir_exists_in_archive (window, current_dir)) {
+			char *tmp;
+
+			fr_window_history_pop (window);
+
+			tmp = get_parent_dir (current_dir);
+			g_free (current_dir);
+			current_dir = tmp;
+
+			fr_window_history_add (window, current_dir);
+		}
+		g_free (current_dir);
+
+		fr_window_compute_list_names (window, window->archive->command->files);
+		files = fr_window_get_current_dir_list (window);
+		free_files = TRUE;
+	}
+
+	if (files != NULL)
+		window->priv->current_view_length = files->len;
+	else
+		window->priv->current_view_length = 0;
+
+	if (update_view)
+		fr_window_populate_file_list (window, files);
+
+	if (free_files)
+		g_ptr_array_free (files, TRUE);
+}
+
+
+void
+fr_window_update_list_order (FrWindow *window)
+{
+	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (window->priv->list_store), get_column_from_sort_method (window->priv->sort_method), window->priv->sort_type);
+}
+
+
+static void
+fr_window_update_title (FrWindow *window)
+{
+	if (! window->priv->archive_present)
+		gtk_window_set_title (GTK_WINDOW (window), _("Archive Manager"));
+	else {
+		char *title;
+		char *name;
+
+		name = g_uri_display_basename (fr_window_get_archive_uri (window));
+		title = g_strdup_printf ("%s %s",
+					 name,
+					 window->archive->read_only ? _("[read only]") : "");
+
+		gtk_window_set_title (GTK_WINDOW (window), title);
+		g_free (title);
+		g_free (name);
+	}
+}
+
+
+static void
+check_whether_has_a_dir (GtkTreeModel *model,
+			 GtkTreePath  *path,
+			 GtkTreeIter  *iter,
+			 gpointer      data)
+{
+	gboolean *has_a_dir = data;
+	FileData *fdata;
+
+	gtk_tree_model_get (model, iter,
+			    COLUMN_FILE_DATA, &fdata,
+			    -1);
+	if (file_data_is_dir (fdata))
+		*has_a_dir = TRUE;
+}
+
+
+static gboolean
+selection_has_a_dir (FrWindow *window)
+{
+	GtkTreeSelection *selection;
+	gboolean          has_a_dir = FALSE;
+
+	if (! gtk_widget_get_realized (window->priv->list_view))
+		return FALSE;
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+	if (selection == NULL)
+		return FALSE;
+
+	gtk_tree_selection_selected_foreach (selection,
+					     check_whether_has_a_dir,
+					     &has_a_dir);
+
+	return has_a_dir;
+}
+
+
+static void
+set_active (FrWindow   *window,
+	    const char *action_name,
+	    gboolean    is_active)
+{
+	GtkAction *action;
+
+	action = gtk_action_group_get_action (window->priv->actions, action_name);
+	gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), is_active);
+}
+
+
+static void
+fr_window_update_paste_command_sensitivity (FrWindow     *window,
+					    GtkClipboard *clipboard)
+{
+	gboolean running;
+	gboolean no_archive;
+	gboolean ro;
+	gboolean compr_file;
+
+	if (window->priv->closing)
+		return;
+
+	if (clipboard == NULL)
+		clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window), FR_CLIPBOARD);
+	running    = window->priv->activity_ref > 0;
+	no_archive = (window->archive == NULL) || ! window->priv->archive_present;
+	ro         = ! no_archive && window->archive->read_only;
+	compr_file = ! no_archive && window->archive->is_compressed_file;
+
+	set_sensitive (window, "Paste", ! no_archive && ! ro && ! running && ! compr_file && (window->priv->list_mode != FR_WINDOW_LIST_MODE_FLAT) && gtk_clipboard_wait_is_target_available (clipboard, FR_SPECIAL_URI_LIST));
+}
+
+
+static void
+fr_window_update_sensitivity (FrWindow *window)
+{
+	gboolean no_archive;
+	gboolean ro;
+	gboolean file_op;
+	gboolean running;
+	gboolean compr_file;
+	gboolean sel_not_null;
+	gboolean one_file_selected;
+	gboolean dir_selected;
+	int      n_selected;
+
+	if (window->priv->batch_mode)
+		return;
+
+	running           = window->priv->activity_ref > 0;
+	no_archive        = (window->archive == NULL) || ! window->priv->archive_present;
+	ro                = ! no_archive && window->archive->read_only;
+	file_op           = ! no_archive && ! window->priv->archive_new  && ! running;
+	compr_file        = ! no_archive && window->archive->is_compressed_file;
+	n_selected        = fr_window_get_n_selected_files (window);
+	sel_not_null      = n_selected > 0;
+	one_file_selected = n_selected == 1;
+	dir_selected      = selection_has_a_dir (window);
+
+	set_sensitive (window, "AddFiles", ! no_archive && ! ro && ! running && ! compr_file);
+	set_sensitive (window, "AddFiles_Toolbar", ! no_archive && ! ro && ! running && ! compr_file);
+	set_sensitive (window, "AddFolder", ! no_archive && ! ro && ! running && ! compr_file);
+	set_sensitive (window, "AddFolder_Toolbar", ! no_archive && ! ro && ! running && ! compr_file);
+	set_sensitive (window, "Copy", ! no_archive && ! ro && ! running && ! compr_file && sel_not_null && (window->priv->list_mode != FR_WINDOW_LIST_MODE_FLAT));
+	set_sensitive (window, "Cut", ! no_archive && ! ro && ! running && ! compr_file && sel_not_null && (window->priv->list_mode != FR_WINDOW_LIST_MODE_FLAT));
+	set_sensitive (window, "Delete", ! no_archive && ! ro && ! window->priv->archive_new && ! running && ! compr_file);
+	set_sensitive (window, "DeselectAll", ! no_archive && sel_not_null);
+	set_sensitive (window, "Extract", file_op);
+	set_sensitive (window, "Extract_Toolbar", file_op);
+	set_sensitive (window, "Find", ! no_archive);
+	set_sensitive (window, "LastOutput", ((window->archive != NULL)
+					      && (window->archive->process != NULL)
+					      && (window->archive->process->out.raw != NULL)));
+	set_sensitive (window, "New", ! running);
+	set_sensitive (window, "Open", ! running);
+	set_sensitive (window, "Open_Toolbar", ! running);
+	set_sensitive (window, "OpenSelection", file_op && sel_not_null && ! dir_selected);
+	set_sensitive (window, "OpenFolder", file_op && one_file_selected && dir_selected);
+	set_sensitive (window, "Password", ! running && (window->priv->asked_for_password || (! no_archive && window->archive->command->propPassword)));
+	set_sensitive (window, "Properties", file_op);
+	set_sensitive (window, "Close", !running || window->priv->stoppable);
+	set_sensitive (window, "Reload", ! (no_archive || running));
+	set_sensitive (window, "Rename", ! no_archive && ! ro && ! running && ! compr_file && one_file_selected);
+	set_sensitive (window, "SaveAs", ! no_archive && ! compr_file && ! running);
+	set_sensitive (window, "SelectAll", ! no_archive);
+	set_sensitive (window, "Stop", running && window->priv->stoppable);
+	set_sensitive (window, "TestArchive", ! no_archive && ! running && window->archive->command->propTest);
+	set_sensitive (window, "ViewSelection", file_op && one_file_selected && ! dir_selected);
+	set_sensitive (window, "ViewSelection_Toolbar", file_op && one_file_selected && ! dir_selected);
+
+	if (window->priv->progress_dialog != NULL)
+		gtk_dialog_set_response_sensitive (GTK_DIALOG (window->priv->progress_dialog),
+						   GTK_RESPONSE_OK,
+						   running && window->priv->stoppable);
+
+	fr_window_update_paste_command_sensitivity (window, NULL);
+
+	set_sensitive (window, "SelectAll", (window->priv->current_view_length > 0) && (window->priv->current_view_length != n_selected));
+	set_sensitive (window, "DeselectAll", n_selected > 0);
+	set_sensitive (window, "OpenRecentMenu", ! running);
+
+	set_sensitive (window, "ViewFolders", (window->priv->list_mode == FR_WINDOW_LIST_MODE_AS_DIR));
+
+	set_sensitive (window, "ViewAllFiles", ! window->priv->filter_mode);
+	set_sensitive (window, "ViewAsFolder", ! window->priv->filter_mode);
+}
+
+
+static gboolean
+location_entry_key_press_event_cb (GtkWidget   *widget,
+				   GdkEventKey *event,
+				   FrWindow    *window)
+{
+	if ((event->keyval == GDK_Return)
+	    || (event->keyval == GDK_KP_Enter)
+	    || (event->keyval == GDK_ISO_Enter))
+	{
+		fr_window_go_to_location (window, gtk_entry_get_text (GTK_ENTRY (window->priv->location_entry)), FALSE);
+	}
+
+	return FALSE;
+}
+
+
+static gboolean
+real_close_progress_dialog (gpointer data)
+{
+	FrWindow *window = data;
+
+	if (window->priv->hide_progress_timeout != 0) {
+		g_source_remove (window->priv->hide_progress_timeout);
+		window->priv->hide_progress_timeout = 0;
+	}
+
+	if (window->priv->progress_dialog != NULL)
+		gtk_widget_hide (window->priv->progress_dialog);
+
+	return FALSE;
+}
+
+
+static void
+close_progress_dialog (FrWindow *window,
+		       gboolean  close_now)
+{
+	if (window->priv->progress_timeout != 0) {
+		g_source_remove (window->priv->progress_timeout);
+		window->priv->progress_timeout = 0;
+	}
+
+	if (! window->priv->batch_mode && gtk_widget_get_mapped (GTK_WIDGET (window)))
+		gtk_widget_hide (window->priv->progress_bar);
+
+	if (window->priv->progress_dialog == NULL)
+		return;
+
+	if (close_now) {
+		if (window->priv->hide_progress_timeout != 0) {
+			g_source_remove (window->priv->hide_progress_timeout);
+			window->priv->hide_progress_timeout = 0;
+		}
+		real_close_progress_dialog (window);
+	}
+	else {
+		if (window->priv->hide_progress_timeout != 0)
+			return;
+		window->priv->hide_progress_timeout = g_timeout_add (HIDE_PROGRESS_TIMEOUT_MSECS,
+								     real_close_progress_dialog,
+								     window);
+	}
+}
+
+
+static gboolean
+progress_dialog_delete_event (GtkWidget *caller,
+			      GdkEvent  *event,
+			      FrWindow  *window)
+{
+	if (window->priv->stoppable) {
+		activate_action_stop (NULL, window);
+		close_progress_dialog (window, TRUE);
+	}
+
+	return TRUE;
+}
+
+
+static void
+open_folder (GtkWindow  *parent,
+	     const char *folder)
+{
+	GError *error = NULL;
+
+	if (folder == NULL)
+		return;
+
+	if (! show_uri (gtk_window_get_screen (parent), folder, GDK_CURRENT_TIME, &error)) {
+		GtkWidget *d;
+		char      *utf8_name;
+		char      *message;
+
+		utf8_name = g_filename_display_name (folder);
+		message = g_strdup_printf (_("Could not display the folder \"%s\""), utf8_name);
+		g_free (utf8_name);
+
+		d = _gtk_error_dialog_new (parent,
+					   GTK_DIALOG_MODAL,
+					   NULL,
+					   message,
+					   "%s",
+					   error->message);
+		gtk_dialog_run (GTK_DIALOG (d));
+		gtk_widget_destroy (d);
+
+		g_free (message);
+		g_clear_error (&error);
+	}
+}
+
+
+static void
+fr_window_view_extraction_destination_folder (FrWindow *window)
+{
+	open_folder (GTK_WINDOW (window), fr_archive_get_last_extraction_destination (window->archive));
+}
+
+
+static void
+progress_dialog_response (GtkDialog *dialog,
+			  int        response_id,
+			  FrWindow  *window)
+{
+	GtkWidget *new_window;
+
+	switch (response_id) {
+	case GTK_RESPONSE_CANCEL:
+		if (window->priv->stoppable) {
+			activate_action_stop (NULL, window);
+			close_progress_dialog (window, TRUE);
+		}
+		break;
+	case GTK_RESPONSE_CLOSE:
+		close_progress_dialog (window, TRUE);
+		break;
+	case DIALOG_RESPONSE_OPEN_ARCHIVE:
+		new_window = fr_window_new ();
+		gtk_widget_show (new_window);
+		fr_window_archive_open (FR_WINDOW (new_window), window->priv->convert_data.new_file, GTK_WINDOW (new_window));
+		close_progress_dialog (window, TRUE);
+		break;
+	case DIALOG_RESPONSE_OPEN_DESTINATION_FOLDER:
+		fr_window_view_extraction_destination_folder (window);
+		close_progress_dialog (window, TRUE);
+		break;
+	case DIALOG_RESPONSE_QUIT:
+		fr_window_close (window);
+		break;
+	default:
+		break;
+	}
+}
+
+
+static const char*
+get_message_from_action (FrAction action)
+{
+	char *message = "";
+
+	switch (action) {
+	case FR_ACTION_CREATING_NEW_ARCHIVE:
+		message = _("Creating archive");
+		break;
+	case FR_ACTION_LOADING_ARCHIVE:
+		message = _("Loading archive");
+		break;
+	case FR_ACTION_LISTING_CONTENT:
+		message = _("Reading archive");
+		break;
+	case FR_ACTION_DELETING_FILES:
+		message = _("Deleting files from archive");
+		break;
+	case FR_ACTION_TESTING_ARCHIVE:
+		message = _("Testing archive");
+		break;
+	case FR_ACTION_GETTING_FILE_LIST:
+		message = _("Getting the file list");
+		break;
+	case FR_ACTION_COPYING_FILES_FROM_REMOTE:
+		message = _("Copying the file list");
+		break;
+	case FR_ACTION_ADDING_FILES:
+		message = _("Adding files to archive");
+		break;
+	case FR_ACTION_EXTRACTING_FILES:
+		message = _("Extracting files from archive");
+		break;
+	case FR_ACTION_COPYING_FILES_TO_REMOTE:
+		message = _("Copying the file list");
+		break;
+	case FR_ACTION_CREATING_ARCHIVE:
+		message = _("Creating archive");
+		break;
+	case FR_ACTION_SAVING_REMOTE_ARCHIVE:
+		message = _("Saving archive");
+		break;
+	default:
+		message = "";
+		break;
+	}
+
+	return message;
+}
+
+
+static void
+progress_dialog__set_last_action (FrWindow *window,
+				  FrAction  action)
+{
+	const char *title;
+	char       *markup;
+
+	window->priv->pd_last_action = action;
+	title = get_message_from_action (window->priv->pd_last_action);
+	gtk_window_set_title (GTK_WINDOW (window->priv->progress_dialog), title);
+	markup = g_markup_printf_escaped ("<span weight=\"bold\" size=\"larger\">%s</span>", title);
+	gtk_label_set_markup (GTK_LABEL (window->priv->pd_action), markup);
+	g_free (markup);
+}
+
+
+static void
+pd_update_archive_name (FrWindow *window)
+{
+	char *current_archive;
+
+	if (window->priv->convert_data.converting)
+		current_archive = window->priv->convert_data.new_file;
+	else if (window->priv->working_archive != NULL)
+		current_archive = window->priv->working_archive;
+	else
+		current_archive = window->priv->archive_uri;
+
+	if (strcmp_null_tolerant (window->priv->pd_last_archive, current_archive) != 0) {
+		g_free (window->priv->pd_last_archive);
+		if (current_archive == NULL) {
+			window->priv->pd_last_archive = NULL;
+			gtk_label_set_text (GTK_LABEL (window->priv->pd_archive), "");
+#ifdef LOG_PROGRESS
+			g_print ("archive name > (none)\n");
+#endif
+		}
+		else {
+			char *name;
+
+			window->priv->pd_last_archive = g_strdup (current_archive);
+
+			name = g_uri_display_basename (window->priv->pd_last_archive);
+			gtk_label_set_text (GTK_LABEL (window->priv->pd_archive), name);
+#ifdef LOG_PROGRESS
+			g_print ("archive name > %s\n", name);
+#endif
+			g_free (name);
+		}
+	}
+}
+
+
+static gboolean
+fr_window_working_archive_cb (FrCommand  *command,
+			      const char *archive_filename,
+			      FrWindow   *window)
+{
+	g_free (window->priv->working_archive);
+	window->priv->working_archive = NULL;
+	if (archive_filename != NULL)
+		window->priv->working_archive = g_strdup (archive_filename);
+	pd_update_archive_name (window);
+
+	return TRUE;
+}
+
+
+static gboolean
+fr_window_message_cb (FrCommand  *command,
+		      const char *msg,
+		      FrWindow   *window)
+{
+	if (window->priv->progress_dialog == NULL)
+		return TRUE;
+
+	if (msg != NULL) {
+		while (*msg == ' ')
+			msg++;
+		if (*msg == 0)
+			msg = NULL;
+	}
+
+	if (msg == NULL) {
+		gtk_label_set_text (GTK_LABEL (window->priv->pd_message), "");
+	}
+	else {
+		char *utf8_msg;
+
+		if (! g_utf8_validate (msg, -1, NULL))
+			utf8_msg = g_locale_to_utf8 (msg, -1 , 0, 0, 0);
+		else
+			utf8_msg = g_strdup (msg);
+		if (utf8_msg == NULL)
+			return TRUE;
+
+		if (g_utf8_validate (utf8_msg, -1, NULL))
+			gtk_label_set_text (GTK_LABEL (window->priv->pd_message), utf8_msg);
+#ifdef LOG_PROGRESS
+		g_print ("message > %s\n", utf8_msg);
+#endif
+		g_free (utf8_msg);
+	}
+
+	if (window->priv->convert_data.converting) {
+		if (window->priv->pd_last_action != FR_ACTION_CREATING_ARCHIVE)
+			progress_dialog__set_last_action (window, FR_ACTION_CREATING_ARCHIVE);
+	}
+	else if (window->priv->pd_last_action != window->priv->action)
+		progress_dialog__set_last_action (window, window->priv->action);
+
+	pd_update_archive_name (window);
+
+	return TRUE;
+}
+
+
+static void
+create_the_progress_dialog (FrWindow *window)
+{
+	GtkWindow     *parent;
+	GtkDialog     *d;
+	GtkWidget     *vbox;
+	GtkWidget     *align;
+	GtkWidget     *progress_vbox;
+	GtkWidget     *lbl;
+	const char    *title;
+	char          *markup;
+	PangoAttrList *attr_list;
+
+	if (window->priv->progress_dialog != NULL)
+		return;
+
+	if (window->priv->batch_mode)
+		parent = NULL;
+	else
+		parent = GTK_WINDOW (window);
+
+	window->priv->pd_last_action = window->priv->action;
+	title = get_message_from_action (window->priv->pd_last_action);
+	window->priv->progress_dialog = gtk_dialog_new_with_buttons (title,
+								     parent,
+								     GTK_DIALOG_DESTROY_WITH_PARENT,
+								     NULL);
+
+	window->priv->pd_quit_button = gtk_dialog_add_button (GTK_DIALOG (window->priv->progress_dialog), GTK_STOCK_QUIT, DIALOG_RESPONSE_QUIT);
+	window->priv->pd_open_archive_button = gtk_dialog_add_button (GTK_DIALOG (window->priv->progress_dialog), _("_Open the Archive"), DIALOG_RESPONSE_OPEN_ARCHIVE);
+	window->priv->pd_open_destination_button = gtk_dialog_add_button (GTK_DIALOG (window->priv->progress_dialog), _("_Show the Files"), DIALOG_RESPONSE_OPEN_DESTINATION_FOLDER);
+	window->priv->pd_close_button = gtk_dialog_add_button (GTK_DIALOG (window->priv->progress_dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
+	window->priv->pd_cancel_button = gtk_dialog_add_button (GTK_DIALOG (window->priv->progress_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
+
+	d = GTK_DIALOG (window->priv->progress_dialog);
+	gtk_dialog_set_has_separator (d, FALSE);
+	gtk_window_set_resizable (GTK_WINDOW (d), TRUE);
+	gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_OK);
+	gtk_window_set_default_size (GTK_WINDOW (d), PROGRESS_DIALOG_DEFAULT_WIDTH, -1);
+
+	/* Main */
+
+	vbox = gtk_vbox_new (FALSE, 5);
+	gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (d)), vbox, FALSE, FALSE, 10);
+
+	/* action label */
+
+	lbl = window->priv->pd_action = gtk_label_new ("");
+
+	markup = g_markup_printf_escaped ("<span weight=\"bold\" size=\"larger\">%s</span>", title);
+	gtk_label_set_markup (GTK_LABEL (lbl), markup);
+	g_free (markup);
+
+	align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
+	gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 12, 0, 0);
+
+	gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
+	gtk_misc_set_padding (GTK_MISC (lbl), 0, 0);
+	gtk_label_set_ellipsize (GTK_LABEL (lbl), PANGO_ELLIPSIZE_END);
+
+	gtk_container_add (GTK_CONTAINER (align), lbl);
+	gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
+
+	/* archive name */
+
+	g_free (window->priv->pd_last_archive);
+	window->priv->pd_last_archive = NULL;
+	if (window->priv->archive_uri != NULL) {
+		GtkWidget *hbox;
+		char      *name;
+
+		hbox = gtk_hbox_new (FALSE, 6);
+		gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+		lbl = gtk_label_new ("");
+		markup = g_markup_printf_escaped ("<b>%s</b>", _("Archive:"));
+		gtk_label_set_markup (GTK_LABEL (lbl), markup);
+		g_free (markup);
+		gtk_box_pack_start (GTK_BOX (hbox), lbl, FALSE, FALSE, 0);
+
+		window->priv->pd_last_archive = g_strdup (window->priv->archive_uri);
+		name = g_uri_display_basename (window->priv->pd_last_archive);
+		lbl = window->priv->pd_archive = gtk_label_new (name);
+		g_free (name);
+
+		gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
+		gtk_label_set_ellipsize (GTK_LABEL (lbl), PANGO_ELLIPSIZE_END);
+		gtk_box_pack_start (GTK_BOX (hbox), lbl, TRUE, TRUE, 0);
+	}
+
+	/* progress and details */
+
+	align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
+	gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 6, 0, 0);
+
+	progress_vbox = gtk_vbox_new (FALSE, 6);
+	gtk_container_add (GTK_CONTAINER (align), progress_vbox);
+	gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
+
+	/* progress bar */
+
+	window->priv->pd_progress_bar = gtk_progress_bar_new ();
+	gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (window->priv->pd_progress_bar), ACTIVITY_PULSE_STEP);
+	gtk_box_pack_start (GTK_BOX (progress_vbox), window->priv->pd_progress_bar, TRUE, TRUE, 0);
+
+	/* details label */
+
+	lbl = window->priv->pd_message = gtk_label_new ("");
+
+	attr_list = pango_attr_list_new ();
+	pango_attr_list_insert (attr_list, pango_attr_style_new (PANGO_STYLE_ITALIC));
+	gtk_label_set_attributes (GTK_LABEL (lbl), attr_list);
+	pango_attr_list_unref (attr_list);
+
+	gtk_misc_set_alignment (GTK_MISC (lbl), 0.0, 0.5);
+	gtk_label_set_ellipsize (GTK_LABEL (lbl), PANGO_ELLIPSIZE_END);
+	gtk_box_pack_start (GTK_BOX (progress_vbox), lbl, TRUE, TRUE, 0);
+
+	gtk_widget_show_all (vbox);
+
+	/* signals */
+
+	g_signal_connect (G_OBJECT (window->priv->progress_dialog),
+			  "response",
+			  G_CALLBACK (progress_dialog_response),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->progress_dialog),
+			  "delete_event",
+			  G_CALLBACK (progress_dialog_delete_event),
+			  window);
+}
+
+
+static gboolean
+display_progress_dialog (gpointer data)
+{
+	FrWindow *window = data;
+
+	if (window->priv->progress_timeout != 0)
+		g_source_remove (window->priv->progress_timeout);
+
+	if (window->priv->progress_dialog != NULL) {
+		gtk_dialog_set_response_sensitive (GTK_DIALOG (window->priv->progress_dialog),
+						   GTK_RESPONSE_OK,
+						   window->priv->stoppable);
+		if (! window->priv->non_interactive)
+			gtk_widget_show (GTK_WIDGET (window));
+		gtk_widget_hide (window->priv->progress_bar);
+		gtk_widget_show (window->priv->progress_dialog);
+		fr_window_message_cb (NULL, window->priv->last_status_message, window);
+	}
+
+	window->priv->progress_timeout = 0;
+
+	return FALSE;
+}
+
+
+static void
+open_progress_dialog (FrWindow *window,
+		      gboolean  open_now)
+{
+	if (window->priv->hide_progress_timeout != 0) {
+		g_source_remove (window->priv->hide_progress_timeout);
+		window->priv->hide_progress_timeout = 0;
+	}
+
+	if (open_now) {
+		if (window->priv->progress_timeout != 0)
+			g_source_remove (window->priv->progress_timeout);
+		window->priv->progress_timeout = 0;
+	}
+
+	if ((window->priv->progress_timeout != 0)
+	    || ((window->priv->progress_dialog != NULL) && gtk_widget_get_visible (window->priv->progress_dialog)))
+		return;
+
+	if (! window->priv->batch_mode && ! open_now)
+		gtk_widget_show (window->priv->progress_bar);
+
+	create_the_progress_dialog (window);
+	gtk_widget_show (window->priv->pd_cancel_button);
+	gtk_widget_hide (window->priv->pd_open_archive_button);
+	gtk_widget_hide (window->priv->pd_open_destination_button);
+	gtk_widget_hide (window->priv->pd_quit_button);
+	gtk_widget_hide (window->priv->pd_close_button);
+
+	if (open_now)
+		display_progress_dialog (window);
+	else
+		window->priv->progress_timeout = g_timeout_add (PROGRESS_TIMEOUT_MSECS,
+								display_progress_dialog,
+								window);
+}
+
+
+static gboolean
+fr_window_progress_cb (FrCommand  *command,
+		       double      fraction,
+		       FrWindow   *window)
+{
+	window->priv->progress_pulse = (fraction < 0.0);
+	if (! window->priv->progress_pulse) {
+		fraction = CLAMP (fraction, 0.0, 1.0);
+		if (window->priv->progress_dialog != NULL)
+			gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (window->priv->pd_progress_bar), fraction);
+		gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (window->priv->progress_bar), fraction);
+#ifdef LOG_PROGRESS
+		g_print ("progress > %2.2f\n", fraction);
+#endif
+	}
+	return TRUE;
+}
+
+
+static void
+open_progress_dialog_with_open_destination (FrWindow *window)
+{
+	window->priv->ask_to_open_destination_after_extraction = FALSE;
+
+	if (window->priv->hide_progress_timeout != 0) {
+		g_source_remove (window->priv->hide_progress_timeout);
+		window->priv->hide_progress_timeout = 0;
+	}
+	if (window->priv->progress_timeout != 0) {
+		g_source_remove (window->priv->progress_timeout);
+		window->priv->progress_timeout = 0;
+	}
+
+	create_the_progress_dialog (window);
+	gtk_widget_hide (window->priv->pd_cancel_button);
+	gtk_widget_hide (window->priv->pd_open_archive_button);
+	gtk_widget_show (window->priv->pd_open_destination_button);
+	gtk_widget_show (window->priv->pd_quit_button);
+	gtk_widget_show (window->priv->pd_close_button);
+	display_progress_dialog (window);
+	fr_window_progress_cb (NULL, 1.0, window);
+	fr_window_message_cb (NULL, _("Extraction completed successfully"), window);
+}
+
+
+static void
+open_progress_dialog_with_open_archive (FrWindow *window)
+{
+	if (window->priv->hide_progress_timeout != 0) {
+		g_source_remove (window->priv->hide_progress_timeout);
+		window->priv->hide_progress_timeout = 0;
+	}
+	if (window->priv->progress_timeout != 0) {
+		g_source_remove (window->priv->progress_timeout);
+		window->priv->progress_timeout = 0;
+	}
+
+	create_the_progress_dialog (window);
+	gtk_widget_hide (window->priv->pd_cancel_button);
+	gtk_widget_hide (window->priv->pd_open_destination_button);
+	gtk_widget_show (window->priv->pd_open_archive_button);
+	gtk_widget_show (window->priv->pd_close_button);
+	display_progress_dialog (window);
+	fr_window_progress_cb (NULL, 1.0, window);
+	fr_window_message_cb (NULL, _("Archive created successfully"), window);
+}
+
+
+void
+fr_window_push_message (FrWindow   *window,
+			const char *msg)
+{
+	if (! gtk_widget_get_mapped (GTK_WIDGET (window)))
+		return;
+
+	g_free (window->priv->last_status_message);
+	window->priv->last_status_message = g_strdup (msg);
+
+	gtk_statusbar_push (GTK_STATUSBAR (window->priv->statusbar), window->priv->progress_cid, window->priv->last_status_message);
+	if (window->priv->progress_dialog != NULL)
+		gtk_label_set_text (GTK_LABEL (window->priv->pd_message), window->priv->last_status_message);
+}
+
+
+void
+fr_window_pop_message (FrWindow *window)
+{
+	if (! gtk_widget_get_mapped (GTK_WIDGET (window)))
+		return;
+	gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar), window->priv->progress_cid);
+	if (window->priv->progress_dialog != NULL)
+		gtk_label_set_text (GTK_LABEL (window->priv->pd_message), "");
+}
+
+
+static void
+action_started (FrArchive *archive,
+		FrAction   action,
+		gpointer   data)
+{
+	FrWindow   *window = data;
+	const char *message;
+	char       *full_msg;
+
+	window->priv->action = action;
+	fr_window_start_activity_mode (window);
+
+#ifdef DEBUG
+	debug (DEBUG_INFO, "%s [START] (FR::Window)\n", action_names[action]);
+#endif
+
+	message = get_message_from_action (action);
+	full_msg = g_strdup_printf ("%s, %s", message, _("please wait..."));
+	fr_window_push_message (window, full_msg);
+
+	switch (action) {
+	case FR_ACTION_EXTRACTING_FILES:
+		open_progress_dialog (window, window->priv->ask_to_open_destination_after_extraction || window->priv->convert_data.converting || window->priv->batch_mode);
+		break;
+	default:
+		open_progress_dialog (window, window->priv->batch_mode);
+		break;
+	}
+
+	if (archive->command != NULL) {
+		fr_command_progress (archive->command, -1.0);
+		fr_command_message (archive->command, message);
+	}
+
+	g_free (full_msg);
+}
+
+
+static void
+fr_window_add_to_recent_list (FrWindow *window,
+			      char     *uri)
+{
+	if (window->priv->batch_mode)
+		return;
+
+	if (is_temp_dir (uri))
+		return;
+
+	if (window->archive->content_type != NULL) {
+		GtkRecentData *recent_data;
+
+		recent_data = g_new0 (GtkRecentData, 1);
+		recent_data->mime_type = g_content_type_get_mime_type (window->archive->content_type);
+		recent_data->app_name = "File Roller";
+		recent_data->app_exec = "file-roller";
+		gtk_recent_manager_add_full (window->priv->recent_manager, uri, recent_data);
+
+		g_free (recent_data);
+	}
+	else
+		gtk_recent_manager_add_item (window->priv->recent_manager, uri);
+}
+
+
+static void
+fr_window_remove_from_recent_list (FrWindow *window,
+				   char     *filename)
+{
+	if (filename != NULL)
+		gtk_recent_manager_remove_item (window->priv->recent_manager, filename, NULL);
+}
+
+
+static void
+error_dialog_response_cb (GtkDialog *dialog,
+			  gint       arg1,
+			  gpointer   user_data)
+{
+	FrWindow  *window = user_data;
+	GtkWindow *dialog_parent = window->priv->error_dialog_parent;
+
+	window->priv->showing_error_dialog = FALSE;
+	window->priv->error_dialog_parent = NULL;
+
+	if ((dialog_parent != NULL) && (gtk_widget_get_toplevel (GTK_WIDGET (dialog_parent)) != (GtkWidget*) dialog_parent))
+		gtk_window_set_modal (dialog_parent, TRUE);
+	gtk_widget_destroy (GTK_WIDGET (dialog));
+	if (window->priv->destroy_with_error_dialog)
+		gtk_widget_destroy (GTK_WIDGET (window));
+}
+
+
+static void
+fr_window_show_error_dialog (FrWindow  *window,
+			     GtkWidget *dialog,
+			     GtkWindow *dialog_parent)
+{
+	close_progress_dialog (window, TRUE);
+
+	if (dialog_parent != NULL)
+		gtk_window_set_modal (dialog_parent, FALSE);
+	g_signal_connect (dialog,
+			  "response",
+			  (window->priv->batch_mode) ? G_CALLBACK (gtk_main_quit) : G_CALLBACK (error_dialog_response_cb),
+			  window);
+	gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+	gtk_widget_show (dialog);
+
+	window->priv->showing_error_dialog = TRUE;
+	window->priv->error_dialog_parent = dialog_parent;
+}
+
+
+void
+fr_window_destroy_with_error_dialog (FrWindow *window)
+{
+	window->priv->destroy_with_error_dialog = TRUE;
+}
+
+
+static gboolean
+handle_errors (FrWindow    *window,
+	       FrArchive   *archive,
+	       FrAction     action,
+	       FrProcError *error)
+{
+	if (error->type == FR_PROC_ERROR_ASK_PASSWORD) {
+		close_progress_dialog (window, TRUE);
+		dlg_ask_password (window);
+		return FALSE;
+	}
+	else if (error->type == FR_PROC_ERROR_UNSUPPORTED_FORMAT) {
+		close_progress_dialog (window, TRUE);
+		dlg_package_installer (window, archive, action);
+		return FALSE;
+	}
+#if 0
+	else if (error->type == FR_PROC_ERROR_BAD_CHARSET) {
+		close_progress_dialog (window, TRUE);
+		/* dlg_ask_archive_charset (window); FIXME: implement after feature freeze */
+		return FALSE;
+	}
+#endif
+	else if (error->type == FR_PROC_ERROR_STOPPED) {
+		/* nothing */
+	}
+	else if (error->type != FR_PROC_ERROR_NONE) {
+		char      *msg = NULL;
+		char      *utf8_name;
+		char      *details = NULL;
+		GtkWindow *dialog_parent;
+		GtkWidget *dialog;
+		FrProcess *process = archive->process;
+		GList     *output = NULL;
+
+		if (window->priv->batch_mode) {
+			dialog_parent = NULL;
+			window->priv->load_error_parent_window = NULL;
+		}
+		else {
+			dialog_parent = (GtkWindow *) window;
+			if (window->priv->load_error_parent_window == NULL)
+				window->priv->load_error_parent_window = (GtkWindow *) window;
+		}
+
+		if ((action == FR_ACTION_LISTING_CONTENT) || (action == FR_ACTION_LOADING_ARCHIVE))
+			fr_window_archive_close (window);
+
+		switch (action) {
+		case FR_ACTION_CREATING_NEW_ARCHIVE:
+			dialog_parent = window->priv->load_error_parent_window;
+			msg = _("Could not create the archive");
+			break;
+
+		case FR_ACTION_EXTRACTING_FILES:
+		case FR_ACTION_COPYING_FILES_TO_REMOTE:
+			msg = _("An error occurred while extracting files.");
+			break;
+
+		case FR_ACTION_LOADING_ARCHIVE:
+			dialog_parent = window->priv->load_error_parent_window;
+			utf8_name = g_uri_display_basename (window->priv->archive_uri);
+			msg = g_strdup_printf (_("Could not open \"%s\""), utf8_name);
+			g_free (utf8_name);
+			break;
+
+		case FR_ACTION_LISTING_CONTENT:
+			msg = _("An error occurred while loading the archive.");
+			break;
+
+		case FR_ACTION_DELETING_FILES:
+			msg = _("An error occurred while deleting files from the archive.");
+			break;
+
+		case FR_ACTION_ADDING_FILES:
+		case FR_ACTION_GETTING_FILE_LIST:
+		case FR_ACTION_COPYING_FILES_FROM_REMOTE:
+			msg = _("An error occurred while adding files to the archive.");
+			break;
+
+		case FR_ACTION_TESTING_ARCHIVE:
+			msg = _("An error occurred while testing archive.");
+			break;
+
+		case FR_ACTION_SAVING_REMOTE_ARCHIVE:
+			msg = _("An error occurred while saving the archive.");
+			break;
+
+		default:
+			msg = _("An error occurred.");
+			break;
+		}
+
+		switch (error->type) {
+		case FR_PROC_ERROR_COMMAND_NOT_FOUND:
+			details = _("Command not found.");
+			break;
+		case FR_PROC_ERROR_EXITED_ABNORMALLY:
+			details = _("Command exited abnormally.");
+			break;
+		case FR_PROC_ERROR_SPAWN:
+			details = error->gerror->message;
+			break;
+		default:
+			if (error->gerror != NULL)
+				details = error->gerror->message;
+			else
+				details = NULL;
+			break;
+		}
+
+		if (error->type != FR_PROC_ERROR_GENERIC)
+			output = (process->err.raw != NULL) ? process->err.raw : process->out.raw;
+
+		dialog = _gtk_error_dialog_new (dialog_parent,
+						0,
+						output,
+						msg,
+						((details != NULL) ? "%s" : NULL),
+						details);
+		fr_window_show_error_dialog (window, dialog, dialog_parent);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+
+static void
+convert__action_performed (FrArchive   *archive,
+			   FrAction     action,
+			   FrProcError *error,
+			   gpointer     data)
+{
+	FrWindow *window = data;
+
+#ifdef DEBUG
+	debug (DEBUG_INFO, "%s [CONVERT::DONE] (FR::Window)\n", action_names[action]);
+#endif
+
+	if ((action == FR_ACTION_GETTING_FILE_LIST) || (action == FR_ACTION_ADDING_FILES)) {
+		fr_window_stop_activity_mode (window);
+		fr_window_pop_message (window);
+		close_progress_dialog (window, FALSE);
+	}
+
+	if (action != FR_ACTION_ADDING_FILES)
+		return;
+
+	handle_errors (window, archive, action, error);
+
+	if (error->type == FR_PROC_ERROR_NONE)
+		open_progress_dialog_with_open_archive (window);
+
+	remove_local_directory (window->priv->convert_data.temp_dir);
+	fr_window_convert_data_free (window, FALSE);
+
+	fr_window_update_sensitivity (window);
+	fr_window_update_statusbar_list_info (window);
+}
+
+
+static void fr_window_exec_next_batch_action (FrWindow *window);
+
+
+static void
+action_performed (FrArchive   *archive,
+		  FrAction     action,
+		  FrProcError *error,
+		  gpointer     data)
+{
+	FrWindow *window = data;
+	gboolean  continue_batch = FALSE;
+	char     *archive_dir;
+	gboolean  temp_dir;
+
+#ifdef DEBUG
+	debug (DEBUG_INFO, "%s [DONE] (FR::Window)\n", action_names[action]);
+#endif
+
+	fr_window_stop_activity_mode (window);
+	fr_window_pop_message (window);
+
+	continue_batch = handle_errors (window, archive, action, error);
+
+	if ((error->type == FR_PROC_ERROR_ASK_PASSWORD)
+	    || (error->type == FR_PROC_ERROR_UNSUPPORTED_FORMAT)
+	    /*|| (error->type == FR_PROC_ERROR_BAD_CHARSET)*/)
+	{
+		return;
+	}
+
+	switch (action) {
+	case FR_ACTION_CREATING_NEW_ARCHIVE:
+	case FR_ACTION_CREATING_ARCHIVE:
+		close_progress_dialog (window, FALSE);
+		if (error->type != FR_PROC_ERROR_STOPPED) {
+			fr_window_history_clear (window);
+			fr_window_go_to_location (window, "/", TRUE);
+			fr_window_update_dir_tree (window);
+			fr_window_update_title (window);
+			fr_window_update_sensitivity (window);
+		}
+		break;
+
+	case FR_ACTION_LOADING_ARCHIVE:
+		close_progress_dialog (window, FALSE);
+		if (error->type != FR_PROC_ERROR_NONE) {
+			fr_window_remove_from_recent_list (window, window->priv->archive_uri);
+			if (window->priv->non_interactive) {
+				fr_window_archive_close (window);
+				fr_window_stop_batch (window);
+			}
+		}
+		else {
+			fr_window_add_to_recent_list (window, window->priv->archive_uri);
+			if (! window->priv->non_interactive)
+				gtk_window_present (GTK_WINDOW (window));
+		}
+		continue_batch = FALSE;
+		g_signal_emit (window,
+			       fr_window_signals[ARCHIVE_LOADED],
+			       0,
+			       error->type == FR_PROC_ERROR_NONE);
+		break;
+
+	case FR_ACTION_LISTING_CONTENT:
+		/* update the uri because multi-volume archives can have
+		 * a different name after loading. */
+		g_free (window->priv->archive_uri);
+		window->priv->archive_uri = g_file_get_uri (window->archive->file);
+
+		close_progress_dialog (window, FALSE);
+		if (error->type != FR_PROC_ERROR_NONE) {
+			fr_window_remove_from_recent_list (window, window->priv->archive_uri);
+			fr_window_archive_close (window);
+			fr_window_set_password (window, NULL);
+			break;
+		}
+
+		archive_dir = remove_level_from_path (window->priv->archive_uri);
+		temp_dir = is_temp_dir (archive_dir);
+		if (! window->priv->archive_present) {
+			window->priv->archive_present = TRUE;
+
+			fr_window_history_clear (window);
+			fr_window_history_add (window, "/");
+
+			if (! temp_dir) {
+				fr_window_set_open_default_dir (window, archive_dir);
+				fr_window_set_add_default_dir (window, archive_dir);
+				if (! window->priv->freeze_default_dir)
+					fr_window_set_extract_default_dir (window, archive_dir, FALSE);
+			}
+
+			window->priv->archive_new = FALSE;
+		}
+		g_free (archive_dir);
+
+		if (! temp_dir)
+			fr_window_add_to_recent_list (window, window->priv->archive_uri);
+
+		fr_window_update_title (window);
+		fr_window_go_to_location (window, fr_window_get_current_location (window), TRUE);
+		fr_window_update_dir_tree (window);
+		if (! window->priv->batch_mode && window->priv->non_interactive)
+			gtk_window_present (GTK_WINDOW (window));
+		break;
+
+	case FR_ACTION_DELETING_FILES:
+		close_progress_dialog (window, FALSE);
+		fr_window_archive_reload (window);
+		return;
+
+	case FR_ACTION_ADDING_FILES:
+		close_progress_dialog (window, FALSE);
+
+		/* update the uri because multi-volume archives can have
+		 * a different name after creation. */
+		g_free (window->priv->archive_uri);
+		window->priv->archive_uri = g_file_get_uri (window->archive->file);
+
+		if (error->type == FR_PROC_ERROR_NONE) {
+			if (window->priv->archive_new)
+				window->priv->archive_new = FALSE;
+			fr_window_add_to_recent_list (window, window->priv->archive_uri);
+		}
+		if (! window->priv->batch_mode) {
+			fr_window_archive_reload (window);
+			return;
+		}
+		break;
+
+	case FR_ACTION_TESTING_ARCHIVE:
+		close_progress_dialog (window, FALSE);
+		if (error->type == FR_PROC_ERROR_NONE)
+			fr_window_view_last_output (window, _("Test Result"));
+		return;
+
+	case FR_ACTION_EXTRACTING_FILES:
+		if (error->type != FR_PROC_ERROR_NONE) {
+			if (window->priv->convert_data.converting) {
+				remove_local_directory (window->priv->convert_data.temp_dir);
+				fr_window_convert_data_free (window, TRUE);
+			}
+			break;
+		}
+		if (window->priv->convert_data.converting) {
+			char *source_dir;
+
+			source_dir = g_filename_to_uri (window->priv->convert_data.temp_dir, NULL, NULL);
+			fr_archive_add_with_wildcard (
+				  window->priv->convert_data.new_archive,
+				  "*",
+				  NULL,
+				  NULL,
+				  source_dir,
+				  NULL,
+				  FALSE,
+				  TRUE,
+				  window->priv->convert_data.password,
+				  window->priv->convert_data.encrypt_header,
+				  window->priv->compression,
+				  window->priv->convert_data.volume_size);
+			g_free (source_dir);
+		}
+		else {
+			if (window->priv->ask_to_open_destination_after_extraction)
+				open_progress_dialog_with_open_destination (window);
+			else
+				close_progress_dialog (window, FALSE);
+		}
+		break;
+
+	default:
+		close_progress_dialog (window, FALSE);
+		continue_batch = FALSE;
+		break;
+	}
+
+	if (window->priv->batch_action == NULL) {
+		fr_window_update_sensitivity (window);
+		fr_window_update_statusbar_list_info (window);
+	}
+
+	if (continue_batch) {
+		if (error->type != FR_PROC_ERROR_NONE)
+			fr_window_stop_batch (window);
+		else
+			fr_window_exec_next_batch_action (window);
+	}
+}
+
+
+/* -- selections -- */
+
+
+static GList *
+get_dir_list_from_path (FrWindow *window,
+	      		char     *path)
+{
+	char  *dirname;
+	int    dirname_l;
+	GList *list = NULL;
+	int    i;
+
+	if (path[strlen (path) - 1] != '/')
+		dirname = g_strconcat (path, "/", NULL);
+	else
+		dirname = g_strdup (path);
+	dirname_l = strlen (dirname);
+	for (i = 0; i < window->archive->command->files->len; i++) {
+		FileData *fd = g_ptr_array_index (window->archive->command->files, i);
+
+		if (strncmp (dirname, fd->full_path, dirname_l) == 0)
+			list = g_list_prepend (list, g_strdup (fd->original_path));
+	}
+	g_free (dirname);
+
+	return g_list_reverse (list);
+}
+
+
+static GList *
+get_dir_list_from_file_data (FrWindow *window,
+				   FileData *fdata)
+{
+	char  *dirname;
+	GList *list;
+
+	dirname = g_strconcat (fr_window_get_current_location (window),
+			       fdata->list_name,
+			       NULL);
+	list = get_dir_list_from_path (window, dirname);
+	g_free (dirname);
+
+	return list;
+}
+
+
+GList *
+fr_window_get_file_list_selection (FrWindow *window,
+				   gboolean  recursive,
+				   gboolean *has_dirs)
+{
+	GtkTreeSelection *selection;
+	GList            *selections = NULL, *list, *scan;
+
+	g_return_val_if_fail (window != NULL, NULL);
+
+	if (has_dirs != NULL)
+		*has_dirs = FALSE;
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+	if (selection == NULL)
+		return NULL;
+	gtk_tree_selection_selected_foreach (selection, add_selected_from_list_view, &selections);
+
+	list = NULL;
+	for (scan = selections; scan; scan = scan->next) {
+		FileData *fd = scan->data;
+
+		if (!fd)
+			continue;
+
+		if (file_data_is_dir (fd)) {
+			if (has_dirs != NULL)
+				*has_dirs = TRUE;
+
+			if (recursive)
+				list = g_list_concat (list, get_dir_list_from_file_data (window, fd));
+		}
+		else
+			list = g_list_prepend (list, g_strdup (fd->original_path));
+	}
+	if (selections)
+		g_list_free (selections);
+
+	return g_list_reverse (list);
+}
+
+
+GList *
+fr_window_get_folder_tree_selection (FrWindow *window,
+				     gboolean  recursive,
+				     gboolean *has_dirs)
+{
+	GtkTreeSelection *tree_selection;
+	GList            *selections, *list, *scan;
+
+	g_return_val_if_fail (window != NULL, NULL);
+
+	if (has_dirs != NULL)
+		*has_dirs = FALSE;
+
+	tree_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->tree_view));
+	if (tree_selection == NULL)
+		return NULL;
+
+	selections = NULL;
+	gtk_tree_selection_selected_foreach (tree_selection, add_selected_from_tree_view, &selections);
+	if (selections == NULL)
+		return NULL;
+
+	if (has_dirs != NULL)
+		*has_dirs = TRUE;
+
+	list = NULL;
+	for (scan = selections; scan; scan = scan->next) {
+		char *path = scan->data;
+
+		if (recursive)
+			list = g_list_concat (list, get_dir_list_from_path (window, path));
+	}
+	path_list_free (selections);
+
+	return g_list_reverse (list);
+}
+
+
+GList *
+fr_window_get_file_list_from_path_list (FrWindow *window,
+					GList    *path_list,
+					gboolean *has_dirs)
+{
+	GtkTreeModel *model;
+	GList        *selections, *list, *scan;
+
+	g_return_val_if_fail (window != NULL, NULL);
+
+	model = GTK_TREE_MODEL (window->priv->list_store);
+	selections = NULL;
+
+	if (has_dirs != NULL)
+		*has_dirs = FALSE;
+
+	for (scan = path_list; scan; scan = scan->next) {
+		GtkTreeRowReference *reference = scan->data;
+		GtkTreePath         *path;
+		GtkTreeIter          iter;
+		FileData            *fdata;
+
+		path = gtk_tree_row_reference_get_path (reference);
+		if (path == NULL)
+			continue;
+
+		if (! gtk_tree_model_get_iter (model, &iter, path))
+			continue;
+
+		gtk_tree_model_get (model, &iter,
+				    COLUMN_FILE_DATA, &fdata,
+				    -1);
+
+		selections = g_list_prepend (selections, fdata);
+	}
+
+	list = NULL;
+	for (scan = selections; scan; scan = scan->next) {
+		FileData *fd = scan->data;
+
+		if (!fd)
+			continue;
+
+		if (file_data_is_dir (fd)) {
+			if (has_dirs != NULL)
+				*has_dirs = TRUE;
+			list = g_list_concat (list, get_dir_list_from_file_data (window, fd));
+		}
+		else
+			list = g_list_prepend (list, g_strdup (fd->original_path));
+	}
+
+	if (selections != NULL)
+		g_list_free (selections);
+
+	return g_list_reverse (list);
+}
+
+
+GList *
+fr_window_get_file_list_pattern (FrWindow    *window,
+				 const char  *pattern)
+{
+	GRegex **regexps;
+	GList   *list;
+	int      i;
+
+	g_return_val_if_fail (window != NULL, NULL);
+
+	regexps = search_util_get_regexps (pattern, G_REGEX_CASELESS);
+	list = NULL;
+	for (i = 0; i < window->archive->command->files->len; i++) {
+		FileData *fd = g_ptr_array_index (window->archive->command->files, i);
+		char     *utf8_name;
+
+		/* FIXME: only files in the current location ? */
+
+		if (fd == NULL)
+			continue;
+
+		utf8_name = g_filename_to_utf8 (fd->name, -1, NULL, NULL, NULL);
+		if (match_regexps (regexps, utf8_name, 0))
+			list = g_list_prepend (list, g_strdup (fd->original_path));
+		g_free (utf8_name);
+	}
+	free_regexps (regexps);
+
+	return g_list_reverse (list);
+}
+
+
+int
+fr_window_get_n_selected_files (FrWindow *window)
+{
+	return _gtk_count_selected (gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view)));
+}
+
+
+/**/
+
+
+static int
+dir_tree_button_press_cb (GtkWidget      *widget,
+			  GdkEventButton *event,
+			  gpointer        data)
+{
+	FrWindow         *window = data;
+	GtkTreeSelection *selection;
+
+	if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (window->priv->tree_view)))
+		return FALSE;
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->tree_view));
+	if (selection == NULL)
+		return FALSE;
+
+	if ((event->type == GDK_BUTTON_PRESS) && (event->button == 3)) {
+		GtkTreePath *path;
+		GtkTreeIter  iter;
+
+		if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (window->priv->tree_view),
+						   event->x, event->y,
+						   &path, NULL, NULL, NULL)) {
+
+			if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (window->priv->tree_store), &iter, path)) {
+				gtk_tree_path_free (path);
+				return FALSE;
+			}
+			gtk_tree_path_free (path);
+
+			if (! gtk_tree_selection_iter_is_selected (selection, &iter)) {
+				gtk_tree_selection_unselect_all (selection);
+				gtk_tree_selection_select_iter (selection, &iter);
+			}
+
+			gtk_menu_popup (GTK_MENU (window->priv->sidebar_folder_popup_menu),
+					NULL, NULL, NULL,
+					window,
+					event->button,
+					event->time);
+		}
+		else
+			gtk_tree_selection_unselect_all (selection);
+
+		return TRUE;
+	}
+	else if ((event->type == GDK_BUTTON_PRESS) && (event->button == 8)) {
+		fr_window_go_back (window);
+		return TRUE;
+	}
+	else if ((event->type == GDK_BUTTON_PRESS) && (event->button == 9)) {
+		fr_window_go_forward (window);
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+static FileData *
+fr_window_get_selected_item_from_file_list (FrWindow *window)
+{
+	GtkTreeSelection *tree_selection;
+	GList            *selection;
+	FileData         *fdata = NULL;
+
+	g_return_val_if_fail (window != NULL, NULL);
+
+	tree_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+	if (tree_selection == NULL)
+		return NULL;
+
+	selection = NULL;
+	gtk_tree_selection_selected_foreach (tree_selection, add_selected_from_list_view, &selection);
+	if ((selection == NULL) || (selection->next != NULL)) {
+		/* return NULL if the selection contains more than one entry. */
+		g_list_free (selection);
+		return NULL;
+	}
+
+	fdata = file_data_copy (selection->data);
+	g_list_free (selection);
+
+	return fdata;
+}
+
+
+static char *
+fr_window_get_selected_folder_in_tree_view (FrWindow *window)
+{
+	GtkTreeSelection *tree_selection;
+	GList            *selections;
+	char             *path = NULL;
+
+	g_return_val_if_fail (window != NULL, NULL);
+
+	tree_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->tree_view));
+	if (tree_selection == NULL)
+		return NULL;
+
+	selections = NULL;
+	gtk_tree_selection_selected_foreach (tree_selection, add_selected_from_tree_view, &selections);
+
+	if (selections != NULL) {
+		path = selections->data;
+		g_list_free (selections);
+	}
+
+	return path;
+}
+
+
+void
+fr_window_current_folder_activated (FrWindow *window,
+				   gboolean   from_sidebar)
+{
+	char *dir_path;
+
+	if (! from_sidebar) {
+		FileData *fdata;
+		char     *dir_name;
+
+		fdata = fr_window_get_selected_item_from_file_list (window);
+		if ((fdata == NULL) || ! file_data_is_dir (fdata)) {
+			file_data_free (fdata);
+			return;
+		}
+		dir_name = g_strdup (fdata->list_name);
+		dir_path = g_strconcat (fr_window_get_current_location (window),
+					dir_name,
+					"/",
+					NULL);
+		g_free (dir_name);
+		file_data_free (fdata);
+	}
+	else
+		dir_path = fr_window_get_selected_folder_in_tree_view (window);
+
+	fr_window_go_to_location (window, dir_path, FALSE);
+
+	g_free (dir_path);
+}
+
+
+static gboolean
+row_activated_cb (GtkTreeView       *tree_view,
+		  GtkTreePath       *path,
+		  GtkTreeViewColumn *column,
+		  gpointer           data)
+{
+	FrWindow    *window = data;
+	FileData    *fdata;
+	GtkTreeIter  iter;
+
+	if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (window->priv->list_store),
+				       &iter,
+				       path))
+		return FALSE;
+
+	gtk_tree_model_get (GTK_TREE_MODEL (window->priv->list_store), &iter,
+			    COLUMN_FILE_DATA, &fdata,
+			    -1);
+
+	if (! file_data_is_dir (fdata)) {
+		GList *list = g_list_prepend (NULL, fdata->original_path);
+		fr_window_open_files (window, list, FALSE);
+		g_list_free (list);
+	}
+	else if (window->priv->list_mode == FR_WINDOW_LIST_MODE_AS_DIR) {
+		char *new_dir;
+		new_dir = g_strconcat (fr_window_get_current_location (window),
+				       fdata->list_name,
+				       "/",
+				       NULL);
+		fr_window_go_to_location (window, new_dir, FALSE);
+		g_free (new_dir);
+	}
+
+	return FALSE;
+}
+
+
+static int
+file_button_press_cb (GtkWidget      *widget,
+		      GdkEventButton *event,
+		      gpointer        data)
+{
+	FrWindow         *window = data;
+	GtkTreeSelection *selection;
+
+	if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (window->priv->list_view)))
+		return FALSE;
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+	if (selection == NULL)
+		return FALSE;
+
+	if (window->priv->path_clicked != NULL) {
+		gtk_tree_path_free (window->priv->path_clicked);
+		window->priv->path_clicked = NULL;
+	}
+
+	if ((event->type == GDK_BUTTON_PRESS) && (event->button == 3)) {
+		GtkTreePath *path;
+		GtkTreeIter  iter;
+		int          n_selected;
+
+		if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (window->priv->list_view),
+						   event->x, event->y,
+						   &path, NULL, NULL, NULL)) {
+
+			if (! gtk_tree_model_get_iter (GTK_TREE_MODEL (window->priv->list_store), &iter, path)) {
+				gtk_tree_path_free (path);
+				return FALSE;
+			}
+			gtk_tree_path_free (path);
+
+			if (! gtk_tree_selection_iter_is_selected (selection, &iter)) {
+				gtk_tree_selection_unselect_all (selection);
+				gtk_tree_selection_select_iter (selection, &iter);
+			}
+		}
+		else
+			gtk_tree_selection_unselect_all (selection);
+
+		n_selected = fr_window_get_n_selected_files (window);
+		if ((n_selected == 1) && selection_has_a_dir (window))
+			gtk_menu_popup (GTK_MENU (window->priv->folder_popup_menu),
+					NULL, NULL, NULL,
+					window,
+					event->button,
+					event->time);
+		else
+			gtk_menu_popup (GTK_MENU (window->priv->file_popup_menu),
+					NULL, NULL, NULL,
+					window,
+					event->button,
+					event->time);
+		return TRUE;
+	}
+	else if ((event->type == GDK_BUTTON_PRESS) && (event->button == 1)) {
+		GtkTreePath *path = NULL;
+
+		if (! gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (window->priv->list_view),
+						     event->x, event->y,
+						     &path, NULL, NULL, NULL)) {
+			gtk_tree_selection_unselect_all (selection);
+		}
+
+		if (window->priv->path_clicked != NULL) {
+			gtk_tree_path_free (window->priv->path_clicked);
+			window->priv->path_clicked = NULL;
+		}
+
+		if (path != NULL) {
+			window->priv->path_clicked = gtk_tree_path_copy (path);
+			gtk_tree_path_free (path);
+		}
+
+		return FALSE;
+	}
+	else if ((event->type == GDK_BUTTON_PRESS) && (event->button == 8)) {
+		// go back
+		fr_window_go_back (window);
+		return TRUE;
+	}
+	else if ((event->type == GDK_BUTTON_PRESS) && (event->button == 9)) {
+		// go forward
+		fr_window_go_forward (window);
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+static int
+file_button_release_cb (GtkWidget      *widget,
+			GdkEventButton *event,
+			gpointer        data)
+{
+	FrWindow         *window = data;
+	GtkTreeSelection *selection;
+
+	if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (window->priv->list_view)))
+		return FALSE;
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+	if (selection == NULL)
+		return FALSE;
+
+	if (window->priv->path_clicked == NULL)
+		return FALSE;
+
+	if ((event->type == GDK_BUTTON_RELEASE)
+	    && (event->button == 1)
+	    && (window->priv->path_clicked != NULL)) {
+		GtkTreePath *path = NULL;
+
+		if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (window->priv->list_view),
+						   event->x, event->y,
+						   &path, NULL, NULL, NULL)) {
+
+			if ((gtk_tree_path_compare (window->priv->path_clicked, path) == 0)
+			    && window->priv->single_click
+			    && ! ((event->state & GDK_CONTROL_MASK) || (event->state & GDK_SHIFT_MASK))) {
+				gtk_tree_view_set_cursor (GTK_TREE_VIEW (widget),
+							  path,
+							  NULL,
+							  FALSE);
+				gtk_tree_view_row_activated (GTK_TREE_VIEW (widget),
+							     path,
+							     NULL);
+			}
+		}
+
+		if (path != NULL)
+			gtk_tree_path_free (path);
+	}
+
+	if (window->priv->path_clicked != NULL) {
+		gtk_tree_path_free (window->priv->path_clicked);
+		window->priv->path_clicked = NULL;
+	}
+
+	return FALSE;
+}
+
+
+static gboolean
+file_motion_notify_callback (GtkWidget *widget,
+			     GdkEventMotion *event,
+			     gpointer user_data)
+{
+	FrWindow    *window = user_data;
+	GdkCursor   *cursor;
+	GtkTreePath *last_hover_path;
+	GtkTreeIter  iter;
+
+	if (! window->priv->single_click)
+		return FALSE;
+
+	if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (window->priv->list_view)))
+		return FALSE;
+
+	last_hover_path = window->priv->list_hover_path;
+
+	gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
+				       event->x, event->y,
+				       &window->priv->list_hover_path,
+				       NULL, NULL, NULL);
+
+	if (window->priv->list_hover_path != NULL)
+		cursor = gdk_cursor_new (GDK_HAND2);
+	else
+		cursor = NULL;
+
+	gdk_window_set_cursor (event->window, cursor);
+
+	/* only redraw if the hover row has changed */
+	if (!(last_hover_path == NULL && window->priv->list_hover_path == NULL) &&
+	    (!(last_hover_path != NULL && window->priv->list_hover_path != NULL) ||
+	     gtk_tree_path_compare (last_hover_path, window->priv->list_hover_path)))
+	{
+		if (last_hover_path) {
+			gtk_tree_model_get_iter (GTK_TREE_MODEL (window->priv->list_store),
+						 &iter, last_hover_path);
+			gtk_tree_model_row_changed (GTK_TREE_MODEL (window->priv->list_store),
+						    last_hover_path, &iter);
+		}
+
+		if (window->priv->list_hover_path) {
+			gtk_tree_model_get_iter (GTK_TREE_MODEL (window->priv->list_store),
+						 &iter, window->priv->list_hover_path);
+			gtk_tree_model_row_changed (GTK_TREE_MODEL (window->priv->list_store),
+						    window->priv->list_hover_path, &iter);
+		}
+	}
+
+	gtk_tree_path_free (last_hover_path);
+
+ 	return FALSE;
+}
+
+
+static gboolean
+file_leave_notify_callback (GtkWidget *widget,
+			    GdkEventCrossing *event,
+			    gpointer user_data)
+{
+	FrWindow    *window = user_data;
+	GtkTreeIter  iter;
+
+	if (window->priv->single_click && (window->priv->list_hover_path != NULL)) {
+		gtk_tree_model_get_iter (GTK_TREE_MODEL (window->priv->list_store),
+					 &iter,
+					 window->priv->list_hover_path);
+		gtk_tree_model_row_changed (GTK_TREE_MODEL (window->priv->list_store),
+					    window->priv->list_hover_path,
+					    &iter);
+
+		gtk_tree_path_free (window->priv->list_hover_path);
+		window->priv->list_hover_path = NULL;
+	}
+
+	return FALSE;
+}
+
+
+/* -- drag and drop -- */
+
+
+static GList *
+get_uri_list_from_selection_data (char *uri_list)
+{
+	GList  *list = NULL;
+	char  **uris;
+	int     i;
+
+	if (uri_list == NULL)
+		return NULL;
+
+	uris = g_uri_list_extract_uris (uri_list);
+	for (i = 0; uris[i] != NULL; i++)
+		list = g_list_prepend (list, g_strdup (uris[i]));
+	g_strfreev (uris);
+
+	return g_list_reverse (list);
+}
+
+
+static gboolean
+fr_window_drag_motion (GtkWidget      *widget,
+		       GdkDragContext *context,
+		       gint            x,
+		       gint            y,
+		       guint           time,
+		       gpointer        user_data)
+{
+	FrWindow  *window = user_data;
+
+	if ((gtk_drag_get_source_widget (context) == window->priv->list_view)
+	    || (gtk_drag_get_source_widget (context) == window->priv->tree_view))
+	{
+		gdk_drag_status (context, 0, time);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+
+static void fr_window_paste_from_clipboard_data (FrWindow *window, FrClipboardData *data);
+
+
+static FrClipboardData*
+get_clipboard_data_from_selection_data (FrWindow   *window,
+					const char *data)
+{
+	FrClipboardData  *clipboard_data;
+	char            **uris;
+	int               i;
+
+	clipboard_data = fr_clipboard_data_new ();
+
+	uris = g_strsplit (data, "\r\n", -1);
+
+	clipboard_data->archive_filename = g_strdup (uris[0]);
+	if (window->priv->password_for_paste != NULL)
+		clipboard_data->archive_password = g_strdup (window->priv->password_for_paste);
+	else if (strcmp (uris[1], "") != 0)
+		clipboard_data->archive_password = g_strdup (uris[1]);
+	clipboard_data->op = (strcmp (uris[2], "copy") == 0) ? FR_CLIPBOARD_OP_COPY : FR_CLIPBOARD_OP_CUT;
+	clipboard_data->base_dir = g_strdup (uris[3]);
+	for (i = 4; uris[i] != NULL; i++)
+		if (uris[i][0] != '\0')
+			clipboard_data->files = g_list_prepend (clipboard_data->files, g_strdup (uris[i]));
+	clipboard_data->files = g_list_reverse (clipboard_data->files);
+
+	g_strfreev (uris);
+
+	return clipboard_data;
+}
+
+
+static void
+fr_window_drag_data_received  (GtkWidget          *widget,
+			       GdkDragContext     *context,
+			       gint                x,
+			       gint                y,
+			       GtkSelectionData   *data,
+			       guint               info,
+			       guint               time,
+			       gpointer            extra_data)
+{
+	FrWindow  *window = extra_data;
+	GList     *list;
+	gboolean   one_file;
+	gboolean   is_an_archive;
+
+	debug (DEBUG_INFO, "::DragDataReceived -->\n");
+
+	if ((gtk_drag_get_source_widget (context) == window->priv->list_view)
+	    || (gtk_drag_get_source_widget (context) == window->priv->tree_view))
+	{
+		gtk_drag_finish (context, FALSE, FALSE, time);
+		return;
+	}
+
+	if (! ((gtk_selection_data_get_length (data) >= 0) && (gtk_selection_data_get_format (data) == 8))) {
+		gtk_drag_finish (context, FALSE, FALSE, time);
+		return;
+	}
+
+	if (window->priv->activity_ref > 0) {
+		gtk_drag_finish (context, FALSE, FALSE, time);
+		return;
+	}
+
+	gtk_drag_finish (context, TRUE, FALSE, time);
+
+	if (gtk_selection_data_get_target (data) == XFR_ATOM) {
+		FrClipboardData *dnd_data;
+
+		dnd_data = get_clipboard_data_from_selection_data (window, (char*) gtk_selection_data_get_data (data));
+		dnd_data->current_dir = g_strdup (fr_window_get_current_location (window));
+		fr_window_paste_from_clipboard_data (window, dnd_data);
+
+		return;
+	}
+
+	list = get_uri_list_from_selection_data ((char*) gtk_selection_data_get_data (data));
+	if (list == NULL) {
+		GtkWidget *d;
+
+		d = _gtk_error_dialog_new (GTK_WINDOW (window),
+					   GTK_DIALOG_MODAL,
+					   NULL,
+					   _("Could not perform the operation"),
+					   NULL);
+		gtk_dialog_run (GTK_DIALOG (d));
+		gtk_widget_destroy(d);
+
+ 		return;
+	}
+
+	one_file = (list->next == NULL);
+	if (one_file)
+		is_an_archive = uri_is_archive (list->data);
+	else
+		is_an_archive = FALSE;
+
+	if (window->priv->archive_present
+	    && (window->archive != NULL)
+	    && ! window->archive->read_only
+	    && ! window->archive->is_compressed_file)
+	{
+		if (one_file && is_an_archive) {
+			GtkWidget *d;
+			gint       r;
+
+			d = _gtk_message_dialog_new (GTK_WINDOW (window),
+						     GTK_DIALOG_MODAL,
+						     GTK_STOCK_DIALOG_QUESTION,
+						     _("Do you want to add this file to the current archive or open it as a new archive?"),
+						     NULL,
+						     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+						     GTK_STOCK_ADD, 0,
+						     GTK_STOCK_OPEN, 1,
+						     NULL);
+
+			gtk_dialog_set_default_response (GTK_DIALOG (d), 2);
+
+			r = gtk_dialog_run (GTK_DIALOG (d));
+			gtk_widget_destroy (GTK_WIDGET (d));
+
+			if (r == 0)  /* Add */
+				fr_window_archive_add_dropped_items (window, list, FALSE);
+			else if (r == 1)  /* Open */
+				fr_window_archive_open (window, list->data, GTK_WINDOW (window));
+ 		}
+ 		else
+			fr_window_archive_add_dropped_items (window, list, FALSE);
+	}
+	else {
+		if (one_file && is_an_archive)
+			fr_window_archive_open (window, list->data, GTK_WINDOW (window));
+		else {
+			GtkWidget *d;
+			int        r;
+
+			d = _gtk_message_dialog_new (GTK_WINDOW (window),
+						     GTK_DIALOG_MODAL,
+						     GTK_STOCK_DIALOG_QUESTION,
+						     _("Do you want to create a new archive with these files?"),
+						     NULL,
+						     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+						     _("Create _Archive"), GTK_RESPONSE_YES,
+						     NULL);
+
+			gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES);
+			r = gtk_dialog_run (GTK_DIALOG (d));
+			gtk_widget_destroy (GTK_WIDGET (d));
+
+			if (r == GTK_RESPONSE_YES) {
+				char       *first_item;
+				char       *folder;
+				char       *local_path = NULL;
+				char       *utf8_path = NULL;
+				const char *archive_name;
+
+				fr_window_free_batch_data (window);
+				fr_window_append_batch_action (window,
+							       FR_BATCH_ACTION_ADD,
+							       path_list_dup (list),
+							       (GFreeFunc) path_list_free);
+
+				first_item = (char*) list->data;
+				folder = remove_level_from_path (first_item);
+				if (folder != NULL)
+					fr_window_set_open_default_dir (window, folder);
+
+				if ((list->next != NULL) && (folder != NULL)) {
+					archive_name = file_name_from_path (folder);
+				}
+				else {
+					if (uri_is_local (first_item)) {
+						local_path = g_filename_from_uri (first_item, NULL, NULL);
+						if (local_path)
+							utf8_path = g_filename_to_utf8 (local_path, -1, NULL, NULL, NULL);
+						if (!utf8_path)
+							utf8_path= g_strdup (first_item);
+						g_free (local_path);
+					}
+					else {
+						utf8_path = g_strdup (first_item);
+					}
+					archive_name = file_name_from_path (utf8_path);
+				}
+
+				show_new_archive_dialog (window, archive_name);
+				g_free (utf8_path);
+
+				g_free (folder);
+			}
+		}
+	}
+
+	path_list_free (list);
+
+	debug (DEBUG_INFO, "::DragDataReceived <--\n");
+}
+
+
+static gboolean
+file_list_drag_begin (GtkWidget          *widget,
+		      GdkDragContext     *context,
+		      gpointer            data)
+{
+	FrWindow *window = data;
+
+	debug (DEBUG_INFO, "::DragBegin -->\n");
+
+	if (window->priv->activity_ref > 0)
+		return FALSE;
+
+	g_free (window->priv->drag_destination_folder);
+	window->priv->drag_destination_folder = NULL;
+
+	g_free (window->priv->drag_base_dir);
+	window->priv->drag_base_dir = NULL;
+
+	gdk_property_change (gdk_drag_context_get_source_window (context),
+			     XDS_ATOM, TEXT_ATOM,
+			     8, GDK_PROP_MODE_REPLACE,
+			     (guchar *) XDS_FILENAME,
+			     strlen (XDS_FILENAME));
+
+	return TRUE;
+}
+
+
+static void
+file_list_drag_end (GtkWidget      *widget,
+		    GdkDragContext *context,
+		    gpointer        data)
+{
+	FrWindow *window = data;
+
+	debug (DEBUG_INFO, "::DragEnd -->\n");
+
+	gdk_property_delete (gdk_drag_context_get_source_window (context), XDS_ATOM);
+
+	if (window->priv->drag_error != NULL) {
+		_gtk_error_dialog_run (GTK_WINDOW (window),
+				       _("Extraction not performed"),
+				       "%s",
+				       window->priv->drag_error->message);
+		g_clear_error (&window->priv->drag_error);
+	}
+	else if (window->priv->drag_destination_folder != NULL) {
+		fr_window_archive_extract (window,
+					   window->priv->drag_file_list,
+					   window->priv->drag_destination_folder,
+					   window->priv->drag_base_dir,
+					   FALSE,
+					   TRUE,
+					   FALSE,
+					   FALSE);
+		path_list_free (window->priv->drag_file_list);
+		window->priv->drag_file_list = NULL;
+	}
+
+	debug (DEBUG_INFO, "::DragEnd <--\n");
+}
+
+
+/* The following three functions taken from bugzilla
+ * (http://bugzilla.mate.org/attachment.cgi?id=49362&action=view)
+ * Author: Christian Neumair
+ * Copyright: 2005 Free Software Foundation, Inc
+ * License: GPL */
+static char *
+get_xds_atom_value (GdkDragContext *context)
+{
+	char *ret;
+
+	g_return_val_if_fail (context != NULL, NULL);
+	g_return_val_if_fail (gdk_drag_context_get_source_window (context) != NULL, NULL);
+
+	if (gdk_property_get (gdk_drag_context_get_source_window (context),
+			      XDS_ATOM, TEXT_ATOM,
+			      0, MAX_XDS_ATOM_VAL_LEN,
+			      FALSE, NULL, NULL, NULL,
+			      (unsigned char **) &ret))
+		return ret;
+
+	return NULL;
+}
+
+
+static gboolean
+context_offers_target (GdkDragContext *context,
+		       GdkAtom target)
+{
+	return (g_list_find (gdk_drag_context_list_targets (context), target) != NULL);
+}
+
+
+static gboolean
+caja_xds_dnd_is_valid_xds_context (GdkDragContext *context)
+{
+	char *tmp;
+	gboolean ret;
+
+	g_return_val_if_fail (context != NULL, FALSE);
+
+	tmp = NULL;
+	if (context_offers_target (context, XDS_ATOM)) {
+		tmp = get_xds_atom_value (context);
+	}
+
+	ret = (tmp != NULL);
+	g_free (tmp);
+
+	return ret;
+}
+
+
+static char *
+get_selection_data_from_clipboard_data (FrWindow        *window,
+		      			FrClipboardData *data)
+{
+	GString *list;
+	char    *local_filename;
+	GList   *scan;
+
+	list = g_string_new (NULL);
+
+	local_filename = g_file_get_uri (window->archive->local_copy);
+	g_string_append (list, local_filename);
+	g_free (local_filename);
+
+	g_string_append (list, "\r\n");
+	if (window->priv->password != NULL)
+		g_string_append (list, window->priv->password);
+	g_string_append (list, "\r\n");
+	g_string_append (list, (data->op == FR_CLIPBOARD_OP_COPY) ? "copy" : "cut");
+	g_string_append (list, "\r\n");
+	g_string_append (list, data->base_dir);
+	g_string_append (list, "\r\n");
+	for (scan = data->files; scan; scan = scan->next) {
+		g_string_append (list, scan->data);
+		g_string_append (list, "\r\n");
+	}
+
+	return g_string_free (list, FALSE);
+}
+
+
+static gboolean
+fr_window_folder_tree_drag_data_get (GtkWidget        *widget,
+				     GdkDragContext   *context,
+				     GtkSelectionData *selection_data,
+				     guint             info,
+				     guint             time,
+				     gpointer          user_data)
+{
+	FrWindow *window = user_data;
+	GList    *file_list;
+	char     *destination;
+	char     *destination_folder;
+
+	debug (DEBUG_INFO, "::DragDataGet -->\n");
+
+	if (window->priv->activity_ref > 0)
+		return FALSE;
+
+	file_list = fr_window_get_folder_tree_selection (window, TRUE, NULL);
+	if (file_list == NULL)
+		return FALSE;
+
+	if (gtk_selection_data_get_target (selection_data) == XFR_ATOM) {
+		FrClipboardData *tmp;
+		char            *data;
+
+		tmp = fr_clipboard_data_new ();
+		tmp->files = file_list;
+		tmp->op = FR_CLIPBOARD_OP_COPY;
+		tmp->base_dir = g_strdup (fr_window_get_current_location (window));
+
+		data = get_selection_data_from_clipboard_data (window, tmp);
+		gtk_selection_data_set (selection_data, XFR_ATOM, 8, (guchar *) data, strlen (data));
+
+		fr_clipboard_data_unref (tmp);
+		g_free (data);
+
+		return TRUE;
+	}
+
+	if (! caja_xds_dnd_is_valid_xds_context (context))
+		return FALSE;
+
+	destination = get_xds_atom_value (context);
+	g_return_val_if_fail (destination != NULL, FALSE);
+
+	destination_folder = remove_level_from_path (destination);
+	g_free (destination);
+
+	/* check whether the extraction can be performed in the destination
+	 * folder */
+
+	g_clear_error (&window->priv->drag_error);
+
+	if (! check_permissions (destination_folder, R_OK | W_OK)) {
+		char *destination_folder_display_name;
+
+		destination_folder_display_name = g_filename_display_name (destination_folder);
+		window->priv->drag_error = g_error_new (FR_ERROR, 0, _("You don't have the right permissions to extract archives in the folder \"%s\""), destination_folder_display_name);
+		g_free (destination_folder_display_name);
+	}
+
+	if (window->priv->drag_error == NULL) {
+		g_free (window->priv->drag_destination_folder);
+		g_free (window->priv->drag_base_dir);
+		path_list_free (window->priv->drag_file_list);
+		window->priv->drag_destination_folder = g_strdup (destination_folder);
+		window->priv->drag_base_dir = fr_window_get_selected_folder_in_tree_view (window);
+		window->priv->drag_file_list = file_list;
+	}
+
+	g_free (destination_folder);
+
+	/* sends back the response */
+
+	gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data), 8, (guchar *) ((window->priv->drag_error == NULL) ? "S" : "E"), 1);
+
+	debug (DEBUG_INFO, "::DragDataGet <--\n");
+
+	return TRUE;
+}
+
+
+gboolean
+fr_window_file_list_drag_data_get (FrWindow         *window,
+				   GdkDragContext   *context,
+				   GtkSelectionData *selection_data,
+				   GList            *path_list)
+{
+	char *destination;
+	char *destination_folder;
+
+	debug (DEBUG_INFO, "::DragDataGet -->\n");
+
+	if (window->priv->path_clicked != NULL) {
+		gtk_tree_path_free (window->priv->path_clicked);
+		window->priv->path_clicked = NULL;
+	}
+
+	if (window->priv->activity_ref > 0)
+		return FALSE;
+
+	if (gtk_selection_data_get_target (selection_data) == XFR_ATOM) {
+		FrClipboardData *tmp;
+		char            *data;
+
+		tmp = fr_clipboard_data_new ();
+		tmp->files = fr_window_get_file_list_selection (window, TRUE, NULL);
+		tmp->op = FR_CLIPBOARD_OP_COPY;
+		tmp->base_dir = g_strdup (fr_window_get_current_location (window));
+
+		data = get_selection_data_from_clipboard_data (window, tmp);
+		gtk_selection_data_set (selection_data, XFR_ATOM, 8, (guchar *) data, strlen (data));
+
+		fr_clipboard_data_unref (tmp);
+		g_free (data);
+
+		return TRUE;
+	}
+
+	if (! caja_xds_dnd_is_valid_xds_context (context))
+		return FALSE;
+
+	destination = get_xds_atom_value (context);
+	g_return_val_if_fail (destination != NULL, FALSE);
+
+	destination_folder = remove_level_from_path (destination);
+	g_free (destination);
+
+	/* check whether the extraction can be performed in the destination
+	 * folder */
+
+	g_clear_error (&window->priv->drag_error);
+
+	if (! check_permissions (destination_folder, R_OK | W_OK)) {
+		char *destination_folder_display_name;
+
+		destination_folder_display_name = g_filename_display_name (destination_folder);
+		window->priv->drag_error = g_error_new (FR_ERROR, 0, _("You don't have the right permissions to extract archives in the folder \"%s\""), destination_folder_display_name);
+		g_free (destination_folder_display_name);
+	}
+
+	if (window->priv->drag_error == NULL) {
+		g_free (window->priv->drag_destination_folder);
+		g_free (window->priv->drag_base_dir);
+		path_list_free (window->priv->drag_file_list);
+		window->priv->drag_destination_folder = g_strdup (destination_folder);
+		window->priv->drag_base_dir = g_strdup (fr_window_get_current_location (window));
+		window->priv->drag_file_list = fr_window_get_file_list_from_path_list (window, path_list, NULL);
+	}
+
+	g_free (destination_folder);
+
+	/* sends back the response */
+
+	gtk_selection_data_set (selection_data, gtk_selection_data_get_target (selection_data), 8, (guchar *) ((window->priv->drag_error == NULL) ? "S" : "E"), 1);
+
+	debug (DEBUG_INFO, "::DragDataGet <--\n");
+
+	return TRUE;
+}
+
+
+/* -- window_new -- */
+
+
+static void
+fr_window_deactivate_filter (FrWindow *window)
+{
+	window->priv->filter_mode = FALSE;
+	window->priv->list_mode = window->priv->last_list_mode;
+
+	gtk_entry_set_text (GTK_ENTRY (window->priv->filter_entry), "");
+	fr_window_update_filter_bar_visibility (window);
+
+	gtk_list_store_clear (window->priv->list_store);
+
+	fr_window_update_columns_visibility (window);
+	fr_window_update_file_list (window, TRUE);
+	fr_window_update_dir_tree (window);
+	fr_window_update_current_location (window);
+}
+
+
+static gboolean
+key_press_cb (GtkWidget   *widget,
+	      GdkEventKey *event,
+	      gpointer     data)
+{
+	FrWindow *window = data;
+	gboolean  retval = FALSE;
+	gboolean  alt;
+
+	if (gtk_widget_has_focus (window->priv->location_entry))
+		return FALSE;
+
+	if (gtk_widget_has_focus (window->priv->filter_entry)) {
+		switch (event->keyval) {
+		case GDK_Escape:
+			fr_window_deactivate_filter (window);
+			retval = TRUE;
+			break;
+		default:
+			break;
+		}
+		return retval;
+	}
+
+	alt = (event->state & GDK_MOD1_MASK) == GDK_MOD1_MASK;
+
+	switch (event->keyval) {
+	case GDK_Escape:
+		activate_action_stop (NULL, window);
+		if (window->priv->filter_mode)
+			fr_window_deactivate_filter (window);
+		retval = TRUE;
+		break;
+
+	case GDK_F10:
+		if (event->state & GDK_SHIFT_MASK) {
+			GtkTreeSelection *selection;
+
+			selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+			if (selection == NULL)
+				return FALSE;
+
+			gtk_menu_popup (GTK_MENU (window->priv->file_popup_menu),
+					NULL, NULL, NULL,
+					window,
+					3,
+					GDK_CURRENT_TIME);
+			retval = TRUE;
+		}
+		break;
+
+	case GDK_Up:
+	case GDK_KP_Up:
+		if (alt) {
+			fr_window_go_up_one_level (window);
+			retval = TRUE;
+		}
+		break;
+
+	case GDK_BackSpace:
+		fr_window_go_up_one_level (window);
+		retval = TRUE;
+		break;
+
+	case GDK_Right:
+	case GDK_KP_Right:
+		if (alt) {
+			fr_window_go_forward (window);
+			retval = TRUE;
+		}
+		break;
+
+	case GDK_Left:
+	case GDK_KP_Left:
+		if (alt) {
+			fr_window_go_back (window);
+			retval = TRUE;
+		}
+		break;
+
+	case GDK_Home:
+	case GDK_KP_Home:
+		if (alt) {
+			fr_window_go_to_location (window, "/", FALSE);
+			retval = TRUE;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return retval;
+}
+
+
+static gboolean
+dir_tree_selection_changed_cb (GtkTreeSelection *selection,
+			       gpointer          user_data)
+{
+	FrWindow    *window = user_data;
+	GtkTreeIter  iter;
+
+	if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
+		char *path;
+
+		gtk_tree_model_get (GTK_TREE_MODEL (window->priv->tree_store),
+				    &iter,
+				    TREE_COLUMN_PATH, &path,
+				    -1);
+		fr_window_go_to_location (window, path, FALSE);
+		g_free (path);
+	}
+
+	return FALSE;
+}
+
+
+static gboolean
+selection_changed_cb (GtkTreeSelection *selection,
+		      gpointer          user_data)
+{
+	FrWindow *window = user_data;
+
+	fr_window_update_statusbar_list_info (window);
+	fr_window_update_sensitivity (window);
+
+	return FALSE;
+}
+
+
+static void
+fr_window_delete_event_cb (GtkWidget *caller,
+			   GdkEvent  *event,
+			   FrWindow  *window)
+{
+	fr_window_close (window);
+}
+
+
+static gboolean
+is_single_click_policy (void)
+{
+	char     *value;
+	gboolean  result;
+
+	value = eel_mateconf_get_string (PREF_CAJA_CLICK_POLICY, "double");
+	result = strncmp (value, "single", 6) == 0;
+	g_free (value);
+
+	return result;
+}
+
+
+static void
+filename_cell_data_func (GtkTreeViewColumn *column,
+			 GtkCellRenderer   *renderer,
+			 GtkTreeModel      *model,
+			 GtkTreeIter       *iter,
+			 FrWindow          *window)
+{
+	char           *text;
+	GtkTreePath    *path;
+	PangoUnderline  underline;
+
+	gtk_tree_model_get (model, iter,
+			    COLUMN_NAME, &text,
+			    -1);
+
+	if (window->priv->single_click) {
+		path = gtk_tree_model_get_path (model, iter);
+
+		if ((window->priv->list_hover_path == NULL)
+		    || gtk_tree_path_compare (path, window->priv->list_hover_path))
+			underline = PANGO_UNDERLINE_NONE;
+		else
+			underline = PANGO_UNDERLINE_SINGLE;
+
+		gtk_tree_path_free (path);
+	}
+	else
+		underline = PANGO_UNDERLINE_NONE;
+
+	g_object_set (G_OBJECT (renderer),
+		      "text", text,
+		      "underline", underline,
+		      NULL);
+
+	g_free (text);
+}
+
+
+static void
+add_dir_tree_columns (FrWindow    *window,
+		      GtkTreeView *treeview)
+{
+	GtkCellRenderer   *renderer;
+	GtkTreeViewColumn *column;
+	GValue             value = { 0, };
+
+	/* First column. */
+
+	column = gtk_tree_view_column_new ();
+	gtk_tree_view_column_set_title (column, _("Folders"));
+
+	/* icon */
+
+	renderer = gtk_cell_renderer_pixbuf_new ();
+	gtk_tree_view_column_pack_start (column, renderer, FALSE);
+	gtk_tree_view_column_set_attributes (column, renderer,
+					     "pixbuf", TREE_COLUMN_ICON,
+					     NULL);
+
+	/* name */
+
+	renderer = gtk_cell_renderer_text_new ();
+
+	g_value_init (&value, PANGO_TYPE_ELLIPSIZE_MODE);
+	g_value_set_enum (&value, PANGO_ELLIPSIZE_END);
+	g_object_set_property (G_OBJECT (renderer), "ellipsize", &value);
+	g_value_unset (&value);
+
+	gtk_tree_view_column_pack_start (column,
+					 renderer,
+					 TRUE);
+	gtk_tree_view_column_set_attributes (column, renderer,
+					     "text", TREE_COLUMN_NAME,
+					     "weight", TREE_COLUMN_WEIGHT,
+					     NULL);
+
+	gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+	gtk_tree_view_column_set_sort_column_id (column, TREE_COLUMN_NAME);
+
+	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+}
+
+
+static void
+add_file_list_columns (FrWindow    *window,
+		       GtkTreeView *treeview)
+{
+	static char       *titles[] = {NC_("File", "Size"),
+				       NC_("File", "Type"),
+				       NC_("File", "Date Modified"),
+				       NC_("File", "Location")};
+	GtkCellRenderer   *renderer;
+	GtkTreeViewColumn *column;
+	GValue             value = { 0, };
+	int                i, j, w;
+
+	/* First column. */
+
+	window->priv->filename_column = column = gtk_tree_view_column_new ();
+	gtk_tree_view_column_set_title (column, C_("File", "Name"));
+
+	/* emblem */
+
+	renderer = gtk_cell_renderer_pixbuf_new ();
+	gtk_tree_view_column_pack_end (column, renderer, FALSE);
+	gtk_tree_view_column_set_attributes (column, renderer,
+					     "pixbuf", COLUMN_EMBLEM,
+					     NULL);
+
+	/* icon */
+
+	renderer = gtk_cell_renderer_pixbuf_new ();
+	gtk_tree_view_column_pack_start (column, renderer, FALSE);
+	gtk_tree_view_column_set_attributes (column, renderer,
+					     "pixbuf", COLUMN_ICON,
+					     NULL);
+
+	/* name */
+
+	window->priv->single_click = is_single_click_policy ();
+
+	renderer = gtk_cell_renderer_text_new ();
+
+	g_value_init (&value, PANGO_TYPE_ELLIPSIZE_MODE);
+	g_value_set_enum (&value, PANGO_ELLIPSIZE_END);
+	g_object_set_property (G_OBJECT (renderer), "ellipsize", &value);
+	g_value_unset (&value);
+
+	gtk_tree_view_column_pack_start (column,
+					 renderer,
+					 TRUE);
+	gtk_tree_view_column_set_attributes (column, renderer,
+					     "text", COLUMN_NAME,
+					     NULL);
+
+	gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
+	w = eel_mateconf_get_integer (PREF_NAME_COLUMN_WIDTH, DEFAULT_NAME_COLUMN_WIDTH);
+	if (w <= 0)
+		w = DEFAULT_NAME_COLUMN_WIDTH;
+	gtk_tree_view_column_set_fixed_width (column, w);
+	gtk_tree_view_column_set_resizable (column, TRUE);
+	gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
+	gtk_tree_view_column_set_cell_data_func (column, renderer,
+						 (GtkTreeCellDataFunc) filename_cell_data_func,
+						 window, NULL);
+
+	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+
+	/* Other columns */
+
+	for (j = 0, i = COLUMN_SIZE; i < NUMBER_OF_COLUMNS; i++, j++) {
+		GValue  value = { 0, };
+
+		renderer = gtk_cell_renderer_text_new ();
+		column = gtk_tree_view_column_new_with_attributes (_(titles[j]),
+								   renderer,
+								   "text", i,
+								   NULL);
+
+		gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
+		gtk_tree_view_column_set_fixed_width (column, OTHER_COLUMNS_WIDTH);
+		gtk_tree_view_column_set_resizable (column, TRUE);
+
+		gtk_tree_view_column_set_sort_column_id (column, i);
+
+		g_value_init (&value, PANGO_TYPE_ELLIPSIZE_MODE);
+		g_value_set_enum (&value, PANGO_ELLIPSIZE_END);
+		g_object_set_property (G_OBJECT (renderer), "ellipsize", &value);
+		g_value_unset (&value);
+
+		gtk_tree_view_append_column (treeview, column);
+	}
+}
+
+
+static int
+name_column_sort_func (GtkTreeModel *model,
+		       GtkTreeIter  *a,
+		       GtkTreeIter  *b,
+		       gpointer      user_data)
+{
+	FileData *fdata1, *fdata2;
+
+	gtk_tree_model_get (model, a, COLUMN_FILE_DATA, &fdata1, -1);
+	gtk_tree_model_get (model, b, COLUMN_FILE_DATA, &fdata2, -1);
+
+	return sort_by_name (&fdata1, &fdata2);
+}
+
+
+static int
+size_column_sort_func (GtkTreeModel *model,
+		       GtkTreeIter  *a,
+		       GtkTreeIter  *b,
+		       gpointer      user_data)
+{
+	FileData *fdata1, *fdata2;
+
+	gtk_tree_model_get (model, a, COLUMN_FILE_DATA, &fdata1, -1);
+	gtk_tree_model_get (model, b, COLUMN_FILE_DATA, &fdata2, -1);
+
+	return sort_by_size (&fdata1, &fdata2);
+}
+
+
+static int
+type_column_sort_func (GtkTreeModel *model,
+		       GtkTreeIter  *a,
+		       GtkTreeIter  *b,
+		       gpointer      user_data)
+{
+	FileData *fdata1, *fdata2;
+
+	gtk_tree_model_get (model, a, COLUMN_FILE_DATA, &fdata1, -1);
+	gtk_tree_model_get (model, b, COLUMN_FILE_DATA, &fdata2, -1);
+
+	return sort_by_type (&fdata1, &fdata2);
+}
+
+
+static int
+time_column_sort_func (GtkTreeModel *model,
+		       GtkTreeIter  *a,
+		       GtkTreeIter  *b,
+		       gpointer      user_data)
+{
+	FileData *fdata1, *fdata2;
+
+	gtk_tree_model_get (model, a, COLUMN_FILE_DATA, &fdata1, -1);
+	gtk_tree_model_get (model, b, COLUMN_FILE_DATA, &fdata2, -1);
+
+	return sort_by_time (&fdata1, &fdata2);
+}
+
+
+static int
+path_column_sort_func (GtkTreeModel *model,
+		       GtkTreeIter  *a,
+		       GtkTreeIter  *b,
+		       gpointer      user_data)
+{
+	FileData *fdata1, *fdata2;
+
+	gtk_tree_model_get (model, a, COLUMN_FILE_DATA, &fdata1, -1);
+	gtk_tree_model_get (model, b, COLUMN_FILE_DATA, &fdata2, -1);
+
+	return sort_by_path (&fdata1, &fdata2);
+}
+
+
+static int
+no_sort_column_sort_func (GtkTreeModel *model,
+			  GtkTreeIter  *a,
+			  GtkTreeIter  *b,
+			  gpointer      user_data)
+{
+	return -1;
+}
+
+
+static void
+sort_column_changed_cb (GtkTreeSortable *sortable,
+			gpointer         user_data)
+{
+	FrWindow    *window = user_data;
+	GtkSortType  order;
+	int          column_id;
+
+	if (! gtk_tree_sortable_get_sort_column_id (sortable,
+						    &column_id,
+						    &order))
+		return;
+
+	window->priv->sort_method = get_sort_method_from_column (column_id);
+	window->priv->sort_type = order;
+
+	/*set_active (window, get_action_from_sort_method (window->priv->sort_method), TRUE);
+	set_active (window, "SortReverseOrder", (window->priv->sort_type == GTK_SORT_DESCENDING));*/
+}
+
+
+static gboolean
+fr_window_show_cb (GtkWidget *widget,
+		   FrWindow  *window)
+{
+	fr_window_update_current_location (window);
+
+	set_active (window, "ViewToolbar", eel_mateconf_get_boolean (PREF_UI_TOOLBAR, TRUE));
+	set_active (window, "ViewStatusbar", eel_mateconf_get_boolean (PREF_UI_STATUSBAR, TRUE));
+
+	window->priv->view_folders = eel_mateconf_get_boolean (PREF_UI_FOLDERS, FALSE);
+	set_active (window, "ViewFolders", window->priv->view_folders);
+
+	fr_window_update_filter_bar_visibility (window);
+
+	return TRUE;
+}
+
+
+/* preferences changes notification callbacks */
+
+
+static void
+pref_history_len_changed (MateConfClient *client,
+			  guint        cnxn_id,
+			  MateConfEntry  *entry,
+			  gpointer     user_data)
+{
+	FrWindow *window = user_data;
+
+	gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (window->priv->recent_chooser_menu), eel_mateconf_get_integer (PREF_UI_HISTORY_LEN, MAX_HISTORY_LEN));
+	gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (window->priv->recent_chooser_toolbar), eel_mateconf_get_integer (PREF_UI_HISTORY_LEN, MAX_HISTORY_LEN));
+}
+
+
+static void
+pref_view_toolbar_changed (MateConfClient *client,
+			   guint        cnxn_id,
+			   MateConfEntry  *entry,
+			   gpointer     user_data)
+{
+	FrWindow *window = user_data;
+
+	g_return_if_fail (window != NULL);
+
+	fr_window_set_toolbar_visibility (window, mateconf_value_get_bool (mateconf_entry_get_value (entry)));
+}
+
+
+static void
+pref_view_statusbar_changed (MateConfClient *client,
+			     guint        cnxn_id,
+			     MateConfEntry  *entry,
+			     gpointer     user_data)
+{
+	FrWindow *window = user_data;
+
+	fr_window_set_statusbar_visibility (window, mateconf_value_get_bool (mateconf_entry_get_value (entry)));
+}
+
+
+static void
+pref_view_folders_changed (MateConfClient *client,
+			   guint        cnxn_id,
+			   MateConfEntry  *entry,
+			   gpointer     user_data)
+{
+	FrWindow *window = user_data;
+
+	fr_window_set_folders_visibility (window, mateconf_value_get_bool (mateconf_entry_get_value (entry)));
+}
+
+
+static void
+pref_show_field_changed (MateConfClient *client,
+			 guint        cnxn_id,
+			 MateConfEntry  *entry,
+			 gpointer     user_data)
+{
+	FrWindow *window = user_data;
+
+	fr_window_update_columns_visibility (window);
+}
+
+
+static void
+pref_click_policy_changed (MateConfClient *client,
+			   guint        cnxn_id,
+			   MateConfEntry  *entry,
+			   gpointer     user_data)
+{
+	FrWindow   *window = user_data;
+	GdkWindow  *win = gtk_tree_view_get_bin_window (GTK_TREE_VIEW (window->priv->list_view));
+	GdkDisplay *display;
+
+	window->priv->single_click = is_single_click_policy ();
+
+	gdk_window_set_cursor (win, NULL);
+	display = gtk_widget_get_display (GTK_WIDGET (window->priv->list_view));
+	if (display != NULL)
+		gdk_display_flush (display);
+}
+
+
+static void gh_unref_pixbuf (gpointer  key,
+			     gpointer  value,
+			     gpointer  user_data);
+
+
+static void
+pref_use_mime_icons_changed (MateConfClient *client,
+			     guint        cnxn_id,
+			     MateConfEntry  *entry,
+			     gpointer     user_data)
+{
+	FrWindow *window = user_data;
+
+	if (pixbuf_hash != NULL) {
+		g_hash_table_foreach (pixbuf_hash,
+				      gh_unref_pixbuf,
+				      NULL);
+		g_hash_table_destroy (pixbuf_hash);
+		pixbuf_hash = g_hash_table_new (g_str_hash, g_str_equal);
+	}
+	if (tree_pixbuf_hash != NULL) {
+		g_hash_table_foreach (tree_pixbuf_hash,
+				      gh_unref_pixbuf,
+				      NULL);
+		g_hash_table_destroy (tree_pixbuf_hash);
+		tree_pixbuf_hash = g_hash_table_new (g_str_hash, g_str_equal);
+	}
+
+	fr_window_update_file_list (window, FALSE);
+	fr_window_update_dir_tree (window);
+}
+
+
+static void
+theme_changed_cb (GtkIconTheme *theme, FrWindow *window)
+{
+	int icon_width, icon_height;
+
+	gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (window)),
+					   FILE_LIST_ICON_SIZE,
+					   &icon_width, &icon_height);
+	file_list_icon_size = MAX (icon_width, icon_height);
+
+	gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (window)),
+					   DIR_TREE_ICON_SIZE,
+					   &icon_width, &icon_height);
+	dir_tree_icon_size = MAX (icon_width, icon_height);
+
+	if (pixbuf_hash != NULL) {
+		g_hash_table_foreach (pixbuf_hash,
+				      gh_unref_pixbuf,
+				      NULL);
+		g_hash_table_destroy (pixbuf_hash);
+		pixbuf_hash = g_hash_table_new (g_str_hash, g_str_equal);
+	}
+	if (tree_pixbuf_hash != NULL) {
+		g_hash_table_foreach (tree_pixbuf_hash,
+				      gh_unref_pixbuf,
+				      NULL);
+		g_hash_table_destroy (tree_pixbuf_hash);
+		tree_pixbuf_hash = g_hash_table_new (g_str_hash, g_str_equal);
+	}
+
+	fr_window_update_file_list (window, TRUE);
+	fr_window_update_dir_tree (window);
+}
+
+
+static gboolean
+fr_window_stoppable_cb (FrCommand  *command,
+			gboolean    stoppable,
+			FrWindow   *window)
+{
+	window->priv->stoppable = stoppable;
+	set_sensitive (window, "Stop", stoppable);
+	if (window->priv->progress_dialog != NULL)
+		gtk_dialog_set_response_sensitive (GTK_DIALOG (window->priv->progress_dialog),
+						   GTK_RESPONSE_OK,
+						   stoppable);
+	return TRUE;
+}
+
+
+static gboolean
+fr_window_fake_load (FrArchive *archive,
+		     gpointer   data)
+{
+	/* fake loads are disabled to allow exact progress dialogs (#153281) */
+
+	return FALSE;
+
+#if 0
+	FrWindow *window = data;
+	gboolean  add_after_opening = FALSE;
+	gboolean  extract_after_opening = FALSE;
+	GList    *scan;
+
+	/* fake loads are used only in batch mode to avoid unnecessary
+	 * archive loadings. */
+
+	if (! window->priv->batch_mode)
+		return FALSE;
+
+	/* Check whether there is an ADD or EXTRACT action in the batch list. */
+
+	for (scan = window->priv->batch_action; scan; scan = scan->next) {
+		FRBatchAction *action;
+
+		action = (FRBatchAction *) scan->data;
+		if (action->type == FR_BATCH_ACTION_ADD) {
+			add_after_opening = TRUE;
+			break;
+		}
+		if ((action->type == FR_BATCH_ACTION_EXTRACT)
+		    || (action->type == FR_BATCH_ACTION_EXTRACT_HERE)
+		    || (action->type == FR_BATCH_ACTION_EXTRACT_INTERACT))
+		{
+			extract_after_opening = TRUE;
+			break;
+		}
+	}
+
+	/* use fake load when in batch mode and the archive type supports all
+	 * of the required features */
+
+	return (window->priv->batch_mode
+		&& ! (add_after_opening && window->priv->update_dropped_files && ! archive->command->propAddCanUpdate)
+		&& ! (add_after_opening && ! window->priv->update_dropped_files && ! archive->command->propAddCanReplace)
+		&& ! (extract_after_opening && !archive->command->propCanExtractAll));
+#endif
+}
+
+
+static gboolean
+fr_window_add_is_stoppable (FrArchive *archive,
+			    gpointer   data)
+{
+	FrWindow *window = data;
+	return window->priv->archive_new;
+}
+
+
+static void
+menu_item_select_cb (GtkMenuItem *proxy,
+		     FrWindow    *window)
+{
+	GtkAction *action;
+	char      *message;
+
+	action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (proxy));
+	g_return_if_fail (action != NULL);
+
+	g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
+	if (message) {
+		gtk_statusbar_push (GTK_STATUSBAR (window->priv->statusbar),
+				    window->priv->help_message_cid, message);
+		g_free (message);
+	}
+}
+
+
+static void
+menu_item_deselect_cb (GtkMenuItem *proxy,
+		       FrWindow    *window)
+{
+	gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar),
+			   window->priv->help_message_cid);
+}
+
+
+static void
+disconnect_proxy_cb (GtkUIManager *manager,
+		     GtkAction    *action,
+		     GtkWidget    *proxy,
+		     FrWindow     *window)
+{
+	if (GTK_IS_MENU_ITEM (proxy)) {
+		g_signal_handlers_disconnect_by_func
+			(proxy, G_CALLBACK (menu_item_select_cb), window);
+		g_signal_handlers_disconnect_by_func
+			(proxy, G_CALLBACK (menu_item_deselect_cb), window);
+	}
+}
+
+
+static void
+connect_proxy_cb (GtkUIManager *manager,
+		  GtkAction    *action,
+		  GtkWidget    *proxy,
+		  FrWindow     *window)
+{
+	if (GTK_IS_MENU_ITEM (proxy)) {
+		g_signal_connect (proxy, "select",
+				  G_CALLBACK (menu_item_select_cb), window);
+		g_signal_connect (proxy, "deselect",
+				  G_CALLBACK (menu_item_deselect_cb), window);
+	}
+}
+
+
+static void
+view_as_radio_action (GtkAction      *action,
+		      GtkRadioAction *current,
+		      gpointer        data)
+{
+	FrWindow *window = data;
+	fr_window_set_list_mode (window, gtk_radio_action_get_current_value (current));
+}
+
+
+static void
+sort_by_radio_action (GtkAction      *action,
+		      GtkRadioAction *current,
+		      gpointer        data)
+{
+	FrWindow *window = data;
+
+	window->priv->sort_method = gtk_radio_action_get_current_value (current);
+	window->priv->sort_type = GTK_SORT_ASCENDING;
+	fr_window_update_list_order (window);
+}
+
+
+static void
+recent_chooser_item_activated_cb (GtkRecentChooser *chooser,
+				  FrWindow         *window)
+{
+	char *uri;
+
+	uri = gtk_recent_chooser_get_current_uri (chooser);
+	if (uri != NULL) {
+		fr_window_archive_open (window, uri, GTK_WINDOW (window));
+		g_free (uri);
+	}
+}
+
+
+static void
+fr_window_init_recent_chooser (FrWindow         *window,
+			       GtkRecentChooser *chooser)
+{
+	GtkRecentFilter *filter;
+	int              i;
+
+	g_return_if_fail (chooser != NULL);
+
+	filter = gtk_recent_filter_new ();
+	gtk_recent_filter_set_name (filter, _("All archives"));
+	for (i = 0; open_type[i] != -1; i++)
+		gtk_recent_filter_add_mime_type (filter, mime_type_desc[open_type[i]].mime_type);
+	gtk_recent_filter_add_application (filter, "File Roller");
+	gtk_recent_chooser_add_filter (chooser, filter);
+
+	gtk_recent_chooser_set_local_only (chooser, FALSE);
+	gtk_recent_chooser_set_limit (chooser, eel_mateconf_get_integer (PREF_UI_HISTORY_LEN, MAX_HISTORY_LEN));
+	gtk_recent_chooser_set_show_not_found (chooser, TRUE);
+	gtk_recent_chooser_set_sort_type (chooser, GTK_RECENT_SORT_MRU);
+
+	g_signal_connect (G_OBJECT (chooser),
+			  "item_activated",
+			  G_CALLBACK (recent_chooser_item_activated_cb),
+			  window);
+}
+
+
+static void
+close_sidepane_button_clicked_cb (GtkButton *button,
+				  FrWindow  *window)
+{
+	fr_window_set_folders_visibility (window, FALSE);
+}
+
+
+static void
+fr_window_activate_filter (FrWindow *window)
+{
+	GtkTreeView       *tree_view = GTK_TREE_VIEW (window->priv->list_view);
+	GtkTreeViewColumn *column;
+
+	fr_window_update_filter_bar_visibility (window);
+	window->priv->list_mode = FR_WINDOW_LIST_MODE_FLAT;
+
+	gtk_list_store_clear (window->priv->list_store);
+
+	column = gtk_tree_view_get_column (tree_view, 4);
+	gtk_tree_view_column_set_visible (column, TRUE);
+
+	fr_window_update_file_list (window, TRUE);
+	fr_window_update_dir_tree (window);
+	fr_window_update_current_location (window);
+}
+
+
+static void
+filter_entry_activate_cb (GtkEntry *entry,
+			  FrWindow *window)
+{
+	fr_window_activate_filter (window);
+}
+
+
+static void
+filter_entry_icon_release_cb (GtkEntry             *entry,
+			      GtkEntryIconPosition  icon_pos,
+			      GdkEventButton       *event,
+			      gpointer              user_data)
+{
+	FrWindow *window = FR_WINDOW (user_data);
+
+	if ((event->button == 1) && (icon_pos == GTK_ENTRY_ICON_SECONDARY))
+		fr_window_deactivate_filter (window);
+}
+
+
+static void
+fr_window_attach (FrWindow      *window,
+		  GtkWidget     *child,
+		  FrWindowArea   area)
+{
+	int position;
+
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (FR_IS_WINDOW (window));
+	g_return_if_fail (child != NULL);
+	g_return_if_fail (GTK_IS_WIDGET (child));
+
+	switch (area) {
+	case FR_WINDOW_AREA_MENUBAR:
+		position = 0;
+		break;
+	case FR_WINDOW_AREA_TOOLBAR:
+		position = 1;
+		break;
+	case FR_WINDOW_AREA_LOCATIONBAR:
+		position = 2;
+		break;
+	case FR_WINDOW_AREA_CONTENTS:
+		position = 3;
+		if (window->priv->contents != NULL)
+			gtk_widget_destroy (window->priv->contents);
+		window->priv->contents = child;
+		break;
+	case FR_WINDOW_AREA_FILTERBAR:
+		position = 4;
+		break;
+	case FR_WINDOW_AREA_STATUSBAR:
+		position = 5;
+		break;
+	default:
+		g_critical ("%s: area not recognized!", G_STRFUNC);
+		return;
+		break;
+	}
+
+	gtk_table_attach (GTK_TABLE (window->priv->layout),
+			  child,
+			  0, 1,
+			  position, position + 1,
+			  GTK_EXPAND | GTK_FILL,
+			  ((area == FR_WINDOW_AREA_CONTENTS) ? GTK_EXPAND : 0) | GTK_FILL,
+			  0, 0);
+}
+
+
+static void
+set_action_important (GtkUIManager *ui,
+		      const char   *action_name)
+{
+	GtkAction *action;
+
+	action = gtk_ui_manager_get_action (ui, action_name);
+	g_object_set (action, "is_important", TRUE, NULL);
+	g_object_unref (action);
+}
+
+
+static void
+fr_window_construct (FrWindow *window)
+{
+	GtkWidget        *menubar;
+	GtkWidget        *toolbar;
+	GtkWidget        *list_scrolled_window;
+	GtkWidget        *location_box;
+	GtkStatusbar     *statusbar;
+	GtkWidget        *statusbar_box;
+	GtkWidget        *filter_box;
+	GtkWidget        *tree_scrolled_window;
+	GtkWidget        *sidepane_title;
+	GtkWidget        *sidepane_title_box;
+	GtkWidget        *sidepane_title_label;
+	GtkWidget        *close_sidepane_button;
+	GtkTreeSelection *selection;
+	int               i;
+	int               icon_width, icon_height;
+	GtkActionGroup   *actions;
+	GtkUIManager     *ui;
+	GtkToolItem      *open_recent_tool_item;
+	GtkWidget        *menu_item;
+	GError           *error = NULL;
+
+	/* data common to all windows. */
+
+	if (pixbuf_hash == NULL)
+		pixbuf_hash = g_hash_table_new (g_str_hash, g_str_equal);
+	if (tree_pixbuf_hash == NULL)
+		tree_pixbuf_hash = g_hash_table_new (g_str_hash, g_str_equal);
+
+	if (icon_theme == NULL)
+		icon_theme = gtk_icon_theme_get_default ();
+
+	/* Create the application. */
+
+	window->priv->layout = gtk_table_new (4, 1, FALSE);
+	gtk_container_add (GTK_CONTAINER (window), window->priv->layout);
+	gtk_widget_show (window->priv->layout);
+
+	gtk_window_set_title (GTK_WINDOW (window), _("Archive Manager"));
+
+	g_signal_connect (G_OBJECT (window),
+			  "delete_event",
+			  G_CALLBACK (fr_window_delete_event_cb),
+			  window);
+
+	g_signal_connect (G_OBJECT (window),
+			  "show",
+			  G_CALLBACK (fr_window_show_cb),
+			  window);
+
+	window->priv->theme_changed_handler_id =
+		g_signal_connect (icon_theme,
+				  "changed",
+				  G_CALLBACK (theme_changed_cb),
+				  window);
+
+	gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (window)),
+					   FILE_LIST_ICON_SIZE,
+					   &icon_width, &icon_height);
+	file_list_icon_size = MAX (icon_width, icon_height);
+
+	gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (window)),
+					   DIR_TREE_ICON_SIZE,
+					   &icon_width, &icon_height);
+	dir_tree_icon_size = MAX (icon_width, icon_height);
+
+	gtk_window_set_default_size (GTK_WINDOW (window),
+				     eel_mateconf_get_integer (PREF_UI_WINDOW_WIDTH, DEF_WIN_WIDTH),
+				     eel_mateconf_get_integer (PREF_UI_WINDOW_HEIGHT, DEF_WIN_HEIGHT));
+
+	gtk_drag_dest_set (GTK_WIDGET (window),
+			   GTK_DEST_DEFAULT_ALL,
+			   target_table, G_N_ELEMENTS (target_table),
+			   GDK_ACTION_COPY);
+
+	g_signal_connect (G_OBJECT (window),
+			  "drag_data_received",
+			  G_CALLBACK (fr_window_drag_data_received),
+			  window);
+	g_signal_connect (G_OBJECT (window),
+			  "drag_motion",
+			  G_CALLBACK (fr_window_drag_motion),
+			  window);
+
+	g_signal_connect (G_OBJECT (window),
+			  "key_press_event",
+			  G_CALLBACK (key_press_cb),
+			  window);
+
+	/* Initialize Data. */
+
+	window->archive = fr_archive_new ();
+	g_signal_connect (G_OBJECT (window->archive),
+			  "start",
+			  G_CALLBACK (action_started),
+			  window);
+	g_signal_connect (G_OBJECT (window->archive),
+			  "done",
+			  G_CALLBACK (action_performed),
+			  window);
+	g_signal_connect (G_OBJECT (window->archive),
+			  "progress",
+			  G_CALLBACK (fr_window_progress_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->archive),
+			  "message",
+			  G_CALLBACK (fr_window_message_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->archive),
+			  "stoppable",
+			  G_CALLBACK (fr_window_stoppable_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->archive),
+			  "working_archive",
+			  G_CALLBACK (fr_window_working_archive_cb),
+			  window);
+
+	fr_archive_set_fake_load_func (window->archive,
+				       fr_window_fake_load,
+				       window);
+	fr_archive_set_add_is_stoppable_func (window->archive,
+					      fr_window_add_is_stoppable,
+					      window);
+
+	window->priv->sort_method = preferences_get_sort_method ();
+	window->priv->sort_type = preferences_get_sort_type ();
+
+	window->priv->list_mode = window->priv->last_list_mode = preferences_get_list_mode ();
+	window->priv->history = NULL;
+	window->priv->history_current = NULL;
+
+	window->priv->action = FR_ACTION_NONE;
+
+	eel_mateconf_set_boolean (PREF_LIST_SHOW_PATH, (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT));
+
+	window->priv->open_default_dir = g_strdup (get_home_uri ());
+	window->priv->add_default_dir = g_strdup (get_home_uri ());
+	window->priv->extract_default_dir = g_strdup (get_home_uri ());
+
+	window->priv->give_focus_to_the_list = FALSE;
+
+	window->priv->activity_ref = 0;
+	window->priv->activity_timeout_handle = 0;
+
+	window->priv->update_timeout_handle = 0;
+
+	window->priv->archive_present = FALSE;
+	window->priv->archive_new = FALSE;
+	window->priv->archive_uri = NULL;
+
+	window->priv->drag_destination_folder = NULL;
+	window->priv->drag_base_dir = NULL;
+	window->priv->drag_error = NULL;
+	window->priv->drag_file_list = NULL;
+
+	window->priv->batch_mode = FALSE;
+	window->priv->batch_action_list = NULL;
+	window->priv->batch_action = NULL;
+	window->priv->extract_interact_use_default_dir = FALSE;
+	window->priv->non_interactive = FALSE;
+
+	window->priv->password = NULL;
+	window->priv->compression = preferences_get_compression_level ();
+	window->priv->encrypt_header = eel_mateconf_get_boolean (PREF_ENCRYPT_HEADER, FALSE);
+	window->priv->volume_size = 0;
+
+	window->priv->convert_data.converting = FALSE;
+	window->priv->convert_data.temp_dir = NULL;
+	window->priv->convert_data.new_archive = NULL;
+	window->priv->convert_data.password = NULL;
+	window->priv->convert_data.encrypt_header = FALSE;
+	window->priv->convert_data.volume_size = 0;
+
+	window->priv->stoppable = TRUE;
+
+	window->priv->batch_adding_one_file = FALSE;
+
+	window->priv->path_clicked = NULL;
+
+	window->priv->current_view_length = 0;
+
+	window->priv->current_batch_action.type = FR_BATCH_ACTION_NONE;
+	window->priv->current_batch_action.data = NULL;
+	window->priv->current_batch_action.free_func = NULL;
+
+	window->priv->pd_last_archive = NULL;
+
+	/* Create the widgets. */
+
+	/* * File list. */
+
+	window->priv->list_store = fr_list_model_new (NUMBER_OF_COLUMNS,
+						      G_TYPE_POINTER,
+						      GDK_TYPE_PIXBUF,
+						      G_TYPE_STRING,
+						      GDK_TYPE_PIXBUF,
+						      G_TYPE_STRING,
+						      G_TYPE_STRING,
+						      G_TYPE_STRING,
+						      G_TYPE_STRING);
+	g_object_set_data (G_OBJECT (window->priv->list_store), "FrWindow", window);
+	window->priv->list_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (window->priv->list_store));
+
+	gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (window->priv->list_view), TRUE);
+	add_file_list_columns (window, GTK_TREE_VIEW (window->priv->list_view));
+	gtk_tree_view_set_enable_search (GTK_TREE_VIEW (window->priv->list_view),
+					 FALSE);
+	gtk_tree_view_set_search_column (GTK_TREE_VIEW (window->priv->list_view),
+					 COLUMN_NAME);
+
+	gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (window->priv->list_store),
+					 COLUMN_NAME, name_column_sort_func,
+					 NULL, NULL);
+	gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (window->priv->list_store),
+					 COLUMN_SIZE, size_column_sort_func,
+					 NULL, NULL);
+	gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (window->priv->list_store),
+					 COLUMN_TYPE, type_column_sort_func,
+					 NULL, NULL);
+	gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (window->priv->list_store),
+					 COLUMN_TIME, time_column_sort_func,
+					 NULL, NULL);
+	gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (window->priv->list_store),
+					 COLUMN_PATH, path_column_sort_func,
+					 NULL, NULL);
+
+	gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (window->priv->list_store),
+						 no_sort_column_sort_func,
+						 NULL, NULL);
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view));
+	gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
+
+	g_signal_connect (selection,
+			  "changed",
+			  G_CALLBACK (selection_changed_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->list_view),
+			  "row_activated",
+			  G_CALLBACK (row_activated_cb),
+			  window);
+
+	g_signal_connect (G_OBJECT (window->priv->list_view),
+			  "button_press_event",
+			  G_CALLBACK (file_button_press_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->list_view),
+			  "button_release_event",
+			  G_CALLBACK (file_button_release_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->list_view),
+			  "motion_notify_event",
+			  G_CALLBACK (file_motion_notify_callback),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->list_view),
+			  "leave_notify_event",
+			  G_CALLBACK (file_leave_notify_callback),
+			  window);
+
+	g_signal_connect (G_OBJECT (window->priv->list_store),
+			  "sort_column_changed",
+			  G_CALLBACK (sort_column_changed_cb),
+			  window);
+
+	g_signal_connect (G_OBJECT (window->priv->list_view),
+			  "drag_begin",
+			  G_CALLBACK (file_list_drag_begin),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->list_view),
+			  "drag_end",
+			  G_CALLBACK (file_list_drag_end),
+			  window);
+	egg_tree_multi_drag_add_drag_support (GTK_TREE_VIEW (window->priv->list_view));
+
+	list_scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (list_scrolled_window),
+					GTK_POLICY_AUTOMATIC,
+					GTK_POLICY_AUTOMATIC);
+	gtk_container_add (GTK_CONTAINER (list_scrolled_window), window->priv->list_view);
+
+	/* filter bar */
+
+	window->priv->filter_bar = filter_box = gtk_hbox_new (FALSE, 6);
+	gtk_container_set_border_width (GTK_CONTAINER (filter_box), 3);
+	fr_window_attach (FR_WINDOW (window), window->priv->filter_bar, FR_WINDOW_AREA_FILTERBAR);
+
+	gtk_box_pack_start (GTK_BOX (filter_box),
+			    gtk_label_new (_("Find:")), FALSE, FALSE, 0);
+
+	/* * filter entry */
+
+	window->priv->filter_entry = GTK_WIDGET (gtk_entry_new ());
+	gtk_entry_set_icon_from_stock (GTK_ENTRY (window->priv->filter_entry),
+				       GTK_ENTRY_ICON_SECONDARY,
+				       GTK_STOCK_CLEAR);
+
+	gtk_widget_set_size_request (window->priv->filter_entry, 300, -1);
+	gtk_box_pack_start (GTK_BOX (filter_box),
+			    window->priv->filter_entry, FALSE, FALSE, 6);
+
+	g_signal_connect (G_OBJECT (window->priv->filter_entry),
+			  "activate",
+			  G_CALLBACK (filter_entry_activate_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->filter_entry),
+			  "icon-release",
+			  G_CALLBACK (filter_entry_icon_release_cb),
+			  window);
+
+	gtk_widget_show_all (filter_box);
+
+	/* tree view */
+
+	window->priv->tree_store = gtk_tree_store_new (TREE_NUMBER_OF_COLUMNS,
+						       G_TYPE_STRING,
+						       GDK_TYPE_PIXBUF,
+						       G_TYPE_STRING,
+						       PANGO_TYPE_WEIGHT);
+	window->priv->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (window->priv->tree_store));
+	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (window->priv->tree_view), FALSE);
+	add_dir_tree_columns (window, GTK_TREE_VIEW (window->priv->tree_view));
+
+	g_signal_connect (G_OBJECT (window->priv->tree_view),
+			  "button_press_event",
+			  G_CALLBACK (dir_tree_button_press_cb),
+			  window);
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->tree_view));
+	g_signal_connect (selection,
+			  "changed",
+			  G_CALLBACK (dir_tree_selection_changed_cb),
+			  window);
+
+	g_signal_connect (G_OBJECT (window->priv->tree_view),
+			  "drag_begin",
+			  G_CALLBACK (file_list_drag_begin),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->tree_view),
+			  "drag_end",
+			  G_CALLBACK (file_list_drag_end),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->tree_view),
+			  "drag_data_get",
+			  G_CALLBACK (fr_window_folder_tree_drag_data_get),
+			  window);
+	gtk_drag_source_set (window->priv->tree_view,
+			     GDK_BUTTON1_MASK,
+			     folder_tree_targets, G_N_ELEMENTS (folder_tree_targets),
+			     GDK_ACTION_COPY);
+
+	tree_scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tree_scrolled_window),
+					GTK_POLICY_AUTOMATIC,
+					GTK_POLICY_AUTOMATIC);
+	gtk_container_add (GTK_CONTAINER (tree_scrolled_window), window->priv->tree_view);
+
+	/* side pane */
+
+	window->priv->sidepane = gtk_vbox_new (FALSE, 0);
+
+	sidepane_title = gtk_frame_new (NULL);
+	gtk_frame_set_shadow_type (GTK_FRAME (sidepane_title), GTK_SHADOW_ETCHED_IN);
+
+	sidepane_title_box = gtk_hbox_new (FALSE, 0);
+	gtk_container_set_border_width (GTK_CONTAINER (sidepane_title_box), 2);
+	gtk_container_add (GTK_CONTAINER (sidepane_title), sidepane_title_box);
+	sidepane_title_label = gtk_label_new (_("Folders"));
+
+	gtk_misc_set_alignment (GTK_MISC (sidepane_title_label), 0.0, 0.5);
+	gtk_box_pack_start (GTK_BOX (sidepane_title_box), sidepane_title_label, TRUE, TRUE, 0);
+
+	close_sidepane_button = gtk_button_new ();
+	gtk_container_add (GTK_CONTAINER (close_sidepane_button), gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU));
+	gtk_button_set_relief (GTK_BUTTON (close_sidepane_button), GTK_RELIEF_NONE);
+	gtk_widget_set_tooltip_text (close_sidepane_button, _("Close the folders pane"));
+	g_signal_connect (close_sidepane_button,
+			  "clicked",
+			  G_CALLBACK (close_sidepane_button_clicked_cb),
+			  window);
+	gtk_box_pack_end (GTK_BOX (sidepane_title_box), close_sidepane_button, FALSE, FALSE, 0);
+
+	gtk_box_pack_start (GTK_BOX (window->priv->sidepane), sidepane_title, FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (window->priv->sidepane), tree_scrolled_window, TRUE, TRUE, 0);
+
+	/* main content */
+
+	window->priv->paned = gtk_hpaned_new ();
+	gtk_paned_pack1 (GTK_PANED (window->priv->paned), window->priv->sidepane, FALSE, TRUE);
+	gtk_paned_pack2 (GTK_PANED (window->priv->paned), list_scrolled_window, TRUE, TRUE);
+	gtk_paned_set_position (GTK_PANED (window->priv->paned), eel_mateconf_get_integer (PREF_UI_SIDEBAR_WIDTH, DEF_SIDEBAR_WIDTH));
+
+	fr_window_attach (FR_WINDOW (window), window->priv->paned, FR_WINDOW_AREA_CONTENTS);
+	gtk_widget_show_all (window->priv->paned);
+
+	/* Build the menu and the toolbar. */
+
+	ui = gtk_ui_manager_new ();
+
+	window->priv->actions = actions = gtk_action_group_new ("Actions");
+	gtk_action_group_set_translation_domain (actions, NULL);
+	gtk_action_group_add_actions (actions,
+				      action_entries,
+				      n_action_entries,
+				      window);
+	gtk_action_group_add_toggle_actions (actions,
+					     action_toggle_entries,
+					     n_action_toggle_entries,
+					     window);
+	gtk_action_group_add_radio_actions (actions,
+					    view_as_entries,
+					    n_view_as_entries,
+					    window->priv->list_mode,
+					    G_CALLBACK (view_as_radio_action),
+					    window);
+	gtk_action_group_add_radio_actions (actions,
+					    sort_by_entries,
+					    n_sort_by_entries,
+					    window->priv->sort_type,
+					    G_CALLBACK (sort_by_radio_action),
+					    window);
+
+	g_signal_connect (ui, "connect_proxy",
+			  G_CALLBACK (connect_proxy_cb), window);
+	g_signal_connect (ui, "disconnect_proxy",
+			  G_CALLBACK (disconnect_proxy_cb), window);
+
+	gtk_ui_manager_insert_action_group (ui, actions, 0);
+	gtk_window_add_accel_group (GTK_WINDOW (window),
+				    gtk_ui_manager_get_accel_group (ui));
+
+	/* Add a hidden short cut Ctrl-Q for power users */
+	gtk_accel_group_connect (gtk_ui_manager_get_accel_group (ui),
+				 GDK_q, GDK_CONTROL_MASK, 0,
+				 g_cclosure_new_swap (G_CALLBACK (fr_window_close), window, NULL));
+
+
+	if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error)) {
+		g_message ("building menus failed: %s", error->message);
+		g_error_free (error);
+	}
+
+	menubar = gtk_ui_manager_get_widget (ui, "/MenuBar");
+	fr_window_attach (FR_WINDOW (window), menubar, FR_WINDOW_AREA_MENUBAR);
+	gtk_widget_show (menubar);
+
+	window->priv->toolbar = toolbar = gtk_ui_manager_get_widget (ui, "/ToolBar");
+	gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), TRUE);
+	set_action_important (ui, "/ToolBar/Extract_Toolbar");
+
+	/* location bar */
+
+	window->priv->location_bar = gtk_ui_manager_get_widget (ui, "/LocationBar");
+	gtk_toolbar_set_show_arrow (GTK_TOOLBAR (window->priv->location_bar), FALSE);
+	gtk_toolbar_set_style (GTK_TOOLBAR (window->priv->location_bar), GTK_TOOLBAR_BOTH_HORIZ);
+	set_action_important (ui, "/LocationBar/GoBack");
+
+	/* current location */
+
+	location_box = gtk_hbox_new (FALSE, 6);
+	/* Translators: after the colon there is a folder name. */
+	window->priv->location_label = gtk_label_new_with_mnemonic (_("_Location:"));
+	gtk_box_pack_start (GTK_BOX (location_box),
+			    window->priv->location_label, FALSE, FALSE, 5);
+
+	window->priv->location_entry = gtk_entry_new ();
+	gtk_entry_set_icon_from_stock (GTK_ENTRY (window->priv->location_entry),
+				       GTK_ENTRY_ICON_PRIMARY,
+				       GTK_STOCK_DIRECTORY);
+
+	gtk_box_pack_start (GTK_BOX (location_box),
+			    window->priv->location_entry, TRUE, TRUE, 5);
+
+	g_signal_connect (G_OBJECT (window->priv->location_entry),
+			  "key_press_event",
+			  G_CALLBACK (location_entry_key_press_event_cb),
+			  window);
+
+	{
+		GtkToolItem *tool_item;
+
+		tool_item = gtk_separator_tool_item_new ();
+		gtk_widget_show_all (GTK_WIDGET (tool_item));
+		gtk_toolbar_insert (GTK_TOOLBAR (window->priv->location_bar), tool_item, -1);
+
+		tool_item = gtk_tool_item_new ();
+		gtk_tool_item_set_expand (tool_item, TRUE);
+		gtk_container_add (GTK_CONTAINER (tool_item), location_box);
+		gtk_widget_show_all (GTK_WIDGET (tool_item));
+		gtk_toolbar_insert (GTK_TOOLBAR (window->priv->location_bar), tool_item, -1);
+	}
+
+	fr_window_attach (FR_WINDOW (window), window->priv->location_bar, FR_WINDOW_AREA_LOCATIONBAR);
+	if (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT)
+		gtk_widget_hide (window->priv->location_bar);
+	else
+		gtk_widget_show (window->priv->location_bar);
+
+	/* Recent manager */
+
+	window->priv->recent_manager = gtk_recent_manager_get_default ();
+
+	window->priv->recent_chooser_menu = gtk_recent_chooser_menu_new_for_manager (window->priv->recent_manager);
+	gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (window->priv->recent_chooser_menu), GTK_RECENT_SORT_MRU);
+	fr_window_init_recent_chooser (window, GTK_RECENT_CHOOSER (window->priv->recent_chooser_menu));
+	menu_item = gtk_ui_manager_get_widget (ui, "/MenuBar/Archive/OpenRecentMenu");
+	gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), window->priv->recent_chooser_menu);
+
+	window->priv->recent_chooser_toolbar = gtk_recent_chooser_menu_new_for_manager (window->priv->recent_manager);
+	fr_window_init_recent_chooser (window, GTK_RECENT_CHOOSER (window->priv->recent_chooser_toolbar));
+
+	/* Add the recent menu tool item */
+
+	open_recent_tool_item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_OPEN);
+	gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (open_recent_tool_item), window->priv->recent_chooser_toolbar);
+	gtk_tool_item_set_homogeneous (open_recent_tool_item, FALSE);
+	gtk_widget_set_tooltip_text (GTK_WIDGET (open_recent_tool_item), _("Open archive"));
+	gtk_menu_tool_button_set_arrow_tooltip_text (GTK_MENU_TOOL_BUTTON (open_recent_tool_item), _("Open a recently used archive"));
+
+	window->priv->open_action = gtk_action_new ("Toolbar_Open", _("Open"), _("Open archive"), GTK_STOCK_OPEN);
+	g_object_set (window->priv->open_action, "is_important", TRUE, NULL);
+	g_signal_connect (window->priv->open_action,
+			  "activate",
+			  G_CALLBACK (activate_action_open),
+			  window);
+	gtk_activatable_set_related_action (GTK_ACTIVATABLE (open_recent_tool_item), window->priv->open_action);
+
+	gtk_widget_show (GTK_WIDGET (open_recent_tool_item));
+	gtk_toolbar_insert (GTK_TOOLBAR (toolbar), open_recent_tool_item, 1);
+
+	/**/
+
+	fr_window_attach (FR_WINDOW (window), window->priv->toolbar, FR_WINDOW_AREA_TOOLBAR);
+	if (eel_mateconf_get_boolean (PREF_UI_TOOLBAR, TRUE))
+		gtk_widget_show (toolbar);
+	else
+		gtk_widget_hide (toolbar);
+
+	window->priv->file_popup_menu = gtk_ui_manager_get_widget (ui, "/FilePopupMenu");
+	window->priv->folder_popup_menu = gtk_ui_manager_get_widget (ui, "/FolderPopupMenu");
+	window->priv->sidebar_folder_popup_menu = gtk_ui_manager_get_widget (ui, "/SidebarFolderPopupMenu");
+
+	/* Create the statusbar. */
+
+	window->priv->statusbar = gtk_statusbar_new ();
+	window->priv->help_message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (window->priv->statusbar), "help_message");
+	window->priv->list_info_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (window->priv->statusbar), "list_info");
+	window->priv->progress_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (window->priv->statusbar), "progress");
+
+	statusbar = GTK_STATUSBAR (window->priv->statusbar);
+#if GTK_CHECK_VERSION (2, 19, 1)
+	statusbar_box = gtk_statusbar_get_message_area (statusbar);
+	gtk_box_set_homogeneous (GTK_BOX (statusbar_box), FALSE);
+	gtk_box_set_spacing (GTK_BOX (statusbar_box), 4);
+	gtk_box_set_child_packing (GTK_BOX (statusbar_box), gtk_statusbar_get_message_area (statusbar), TRUE, TRUE, 0, GTK_PACK_START );
+#else
+	statusbar_box = gtk_hbox_new (FALSE, 4);
+	g_object_ref (statusbar->label);
+	gtk_container_remove (GTK_CONTAINER (statusbar->frame), statusbar->label);
+	gtk_box_pack_start (GTK_BOX (statusbar_box), statusbar->label, TRUE, TRUE, 0);
+	g_object_unref (statusbar->label);
+	gtk_container_add (GTK_CONTAINER (statusbar->frame), statusbar_box);
+#endif
+
+	window->priv->progress_bar = gtk_progress_bar_new ();
+	gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (window->priv->progress_bar), ACTIVITY_PULSE_STEP);
+	gtk_widget_set_size_request (window->priv->progress_bar, -1, PROGRESS_BAR_HEIGHT);
+	{
+		GtkWidget *vbox;
+
+		vbox = gtk_vbox_new (FALSE, 0);
+		gtk_box_pack_start (GTK_BOX (statusbar_box), vbox, FALSE, FALSE, 0);
+		gtk_box_pack_start (GTK_BOX (vbox), window->priv->progress_bar, TRUE, TRUE, 1);
+		gtk_widget_show (vbox);
+	}
+	gtk_widget_show (statusbar_box);
+	gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (window->priv->statusbar), TRUE);
+
+	fr_window_attach (FR_WINDOW (window), window->priv->statusbar, FR_WINDOW_AREA_STATUSBAR);
+	if (eel_mateconf_get_boolean (PREF_UI_STATUSBAR, TRUE))
+		gtk_widget_show (window->priv->statusbar);
+	else
+		gtk_widget_hide (window->priv->statusbar);
+
+	/**/
+
+	fr_window_update_title (window);
+	fr_window_update_sensitivity (window);
+	fr_window_update_file_list (window, FALSE);
+	fr_window_update_dir_tree (window);
+	fr_window_update_current_location (window);
+	fr_window_update_columns_visibility (window);
+
+	/* Add notification callbacks. */
+
+	i = 0;
+
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_UI_HISTORY_LEN,
+					   pref_history_len_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_UI_TOOLBAR,
+					   pref_view_toolbar_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_UI_STATUSBAR,
+					   pref_view_statusbar_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_UI_FOLDERS,
+					   pref_view_folders_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_LIST_SHOW_TYPE,
+					   pref_show_field_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_LIST_SHOW_SIZE,
+					   pref_show_field_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_LIST_SHOW_TIME,
+					   pref_show_field_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_LIST_SHOW_PATH,
+					   pref_show_field_changed,
+					   window);
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_LIST_USE_MIME_ICONS,
+					   pref_use_mime_icons_changed,
+					   window);
+
+	window->priv->cnxn_id[i++] = eel_mateconf_notification_add (
+					   PREF_CAJA_CLICK_POLICY,
+					   pref_click_policy_changed,
+					   window);
+
+	/* Give focus to the list. */
+
+	gtk_widget_grab_focus (window->priv->list_view);
+}
+
+
+GtkWidget *
+fr_window_new (void)
+{
+	GtkWidget *window;
+
+	window = g_object_new (FR_TYPE_WINDOW, NULL);
+	fr_window_construct ((FrWindow*) window);
+
+	return window;
+}
+
+
+static void
+fr_window_set_archive_uri (FrWindow   *window,
+			   const char *uri)
+{
+	if (window->priv->archive_uri != NULL)
+			g_free (window->priv->archive_uri);
+		window->priv->archive_uri = g_strdup (uri);
+}
+
+
+gboolean
+fr_window_archive_new (FrWindow   *window,
+		       const char *uri)
+{
+	g_return_val_if_fail (window != NULL, FALSE);
+
+	if (! fr_archive_create (window->archive, uri)) {
+		GtkWindow *file_sel = g_object_get_data (G_OBJECT (window), "fr_file_sel");
+
+		window->priv->load_error_parent_window = file_sel;
+		fr_archive_action_completed (window->archive,
+					     FR_ACTION_CREATING_NEW_ARCHIVE,
+					     FR_PROC_ERROR_GENERIC,
+					     _("Archive type not supported."));
+
+		return FALSE;
+	}
+
+	fr_window_set_archive_uri (window, uri);
+	window->priv->archive_present = TRUE;
+	window->priv->archive_new = TRUE;
+
+	fr_archive_action_completed (window->archive,
+				     FR_ACTION_CREATING_NEW_ARCHIVE,
+				     FR_PROC_ERROR_NONE,
+				     NULL);
+
+	return TRUE;
+}
+
+
+FrWindow *
+fr_window_archive_open (FrWindow   *current_window,
+			const char *uri,
+			GtkWindow  *parent)
+{
+	FrWindow *window = current_window;
+
+	if (current_window->priv->archive_present)
+		window = (FrWindow *) fr_window_new ();
+
+	g_return_val_if_fail (window != NULL, FALSE);
+
+	fr_window_archive_close (window);
+
+	fr_window_set_archive_uri (window, uri);
+	window->priv->archive_present = FALSE;
+	window->priv->give_focus_to_the_list = TRUE;
+	window->priv->load_error_parent_window = parent;
+
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_LOAD,
+					    g_strdup (window->priv->archive_uri),
+					    (GFreeFunc) g_free);
+
+	fr_archive_load (window->archive, window->priv->archive_uri, window->priv->password);
+
+	return window;
+}
+
+
+void
+fr_window_archive_close (FrWindow *window)
+{
+	g_return_if_fail (window != NULL);
+
+	if (! window->priv->archive_new && ! window->priv->archive_present)
+		return;
+
+	fr_window_free_open_files (window);
+	fr_clipboard_data_unref (window->priv->copy_data);
+	window->priv->copy_data = NULL;
+
+	fr_window_set_password (window, NULL);
+	fr_window_set_volume_size(window, 0);
+	fr_window_history_clear (window);
+
+	window->priv->archive_new = FALSE;
+	window->priv->archive_present = FALSE;
+
+	fr_window_update_title (window);
+	fr_window_update_sensitivity (window);
+	fr_window_update_file_list (window, FALSE);
+	fr_window_update_dir_tree (window);
+	fr_window_update_current_location (window);
+	fr_window_update_statusbar_list_info (window);
+}
+
+
+const char *
+fr_window_get_archive_uri (FrWindow *window)
+{
+	g_return_val_if_fail (window != NULL, NULL);
+
+	return window->priv->archive_uri;
+}
+
+
+const char *
+fr_window_get_paste_archive_uri (FrWindow *window)
+{
+	g_return_val_if_fail (window != NULL, NULL);
+
+	if (window->priv->clipboard_data != NULL)
+		return window->priv->clipboard_data->archive_filename;
+	else
+		return NULL;
+}
+
+
+gboolean
+fr_window_archive_is_present (FrWindow *window)
+{
+	g_return_val_if_fail (window != NULL, FALSE);
+
+	return window->priv->archive_present;
+}
+
+
+typedef struct {
+	char     *uri;
+	char     *password;
+	gboolean  encrypt_header;
+	guint     volume_size;
+} SaveAsData;
+
+
+static SaveAsData *
+save_as_data_new (const char *uri,
+		  const char *password,
+		  gboolean    encrypt_header,
+	  	  guint       volume_size)
+{
+	SaveAsData *sdata;
+
+	sdata = g_new0 (SaveAsData, 1);
+	if (uri != NULL)
+		sdata->uri = g_strdup (uri);
+	if (password != NULL)
+		sdata->password = g_strdup (password);
+	sdata->encrypt_header = encrypt_header;
+	sdata->volume_size = volume_size;
+
+	return sdata;
+}
+
+
+static void
+save_as_data_free (SaveAsData *sdata)
+{
+	if (sdata == NULL)
+		return;
+	g_free (sdata->uri);
+	g_free (sdata->password);
+	g_free (sdata);
+}
+
+
+void
+fr_window_archive_save_as (FrWindow   *window,
+			   const char *uri,
+			   const char *password,
+			   gboolean    encrypt_header,
+			   guint       volume_size)
+{
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (uri != NULL);
+	g_return_if_fail (window->archive != NULL);
+
+	fr_window_convert_data_free (window, TRUE);
+	window->priv->convert_data.new_file = g_strdup (uri);
+
+	/* create the new archive */
+
+	window->priv->convert_data.new_archive = fr_archive_new ();
+	if (! fr_archive_create (window->priv->convert_data.new_archive, uri)) {
+		GtkWidget *d;
+		char      *utf8_name;
+		char      *message;
+
+		utf8_name = g_uri_display_basename (uri);
+		message = g_strdup_printf (_("Could not save the archive \"%s\""), utf8_name);
+		g_free (utf8_name);
+
+		d = _gtk_error_dialog_new (GTK_WINDOW (window),
+					   GTK_DIALOG_DESTROY_WITH_PARENT,
+					   NULL,
+					   message,
+					   "%s",
+					   _("Archive type not supported."));
+		gtk_dialog_run (GTK_DIALOG (d));
+		gtk_widget_destroy (d);
+
+		g_free (message);
+
+		g_object_unref (window->priv->convert_data.new_archive);
+		window->priv->convert_data.new_archive = NULL;
+
+		return;
+	}
+
+	g_return_if_fail (window->priv->convert_data.new_archive->command != NULL);
+
+	if (password != NULL) {
+		window->priv->convert_data.password = g_strdup (password);
+		window->priv->convert_data.encrypt_header = encrypt_header;
+	}
+	else
+		window->priv->convert_data.encrypt_header = FALSE;
+	window->priv->convert_data.volume_size = volume_size;
+
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_SAVE_AS,
+					    save_as_data_new (uri, password, encrypt_header, volume_size),
+					    (GFreeFunc) save_as_data_free);
+
+	g_signal_connect (G_OBJECT (window->priv->convert_data.new_archive),
+			  "start",
+			  G_CALLBACK (action_started),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->convert_data.new_archive),
+			  "done",
+			  G_CALLBACK (convert__action_performed),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->convert_data.new_archive),
+			  "progress",
+			  G_CALLBACK (fr_window_progress_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->convert_data.new_archive),
+			  "message",
+			  G_CALLBACK (fr_window_message_cb),
+			  window);
+	g_signal_connect (G_OBJECT (window->priv->convert_data.new_archive),
+			  "stoppable",
+			  G_CALLBACK (fr_window_stoppable_cb),
+			  window);
+
+	window->priv->convert_data.converting = TRUE;
+	window->priv->convert_data.temp_dir = get_temp_work_dir (NULL);
+
+	fr_process_clear (window->archive->process);
+	fr_archive_extract_to_local (window->archive,
+				     NULL,
+				     window->priv->convert_data.temp_dir,
+				     NULL,
+				     TRUE,
+				     FALSE,
+				     FALSE,
+				     window->priv->password);
+	fr_process_start (window->archive->process);
+}
+
+
+void
+fr_window_archive_reload (FrWindow *window)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->activity_ref > 0)
+		return;
+	if (window->priv->archive_new)
+		return;
+
+	fr_archive_reload (window->archive, window->priv->password);
+}
+
+
+void
+fr_window_archive_rename (FrWindow   *window,
+			  const char *uri)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->archive_new) {
+		fr_window_archive_new (window, uri);
+		return;
+	}
+
+	fr_archive_rename (window->archive, uri);
+	fr_window_set_archive_uri (window, uri);
+
+	fr_window_update_title (window);
+	fr_window_add_to_recent_list (window, window->priv->archive_uri);
+}
+
+
+/**/
+
+
+void
+fr_window_archive_add_files (FrWindow *window,
+			     GList    *file_list, /* GFile list */
+			     gboolean  update)
+{
+	GFile *base;
+	char  *base_dir;
+	int    base_len;
+	GList *files = NULL;
+	GList *scan;
+	char  *base_uri;
+
+	base = g_file_get_parent ((GFile *) file_list->data);
+	base_dir = g_file_get_path (base);
+	base_len = 0;
+	if (strcmp (base_dir, "/") != 0)
+		base_len = strlen (base_dir);
+
+	for (scan = file_list; scan; scan = scan->next) {
+		GFile *file = scan->data;
+		char  *path;
+		char  *rel_path;
+
+		path = g_file_get_path (file);
+		rel_path = g_strdup (path + base_len + 1);
+		files = g_list_prepend (files, rel_path);
+
+		g_free (path);
+	}
+
+	base_uri = g_file_get_uri (base);
+
+	fr_archive_add_files (window->archive,
+			      files,
+			      base_uri,
+			      fr_window_get_current_location (window),
+			      update,
+			      window->priv->password,
+			      window->priv->encrypt_header,
+			      window->priv->compression,
+			      window->priv->volume_size);
+
+	g_free (base_uri);
+	path_list_free (files);
+	g_free (base_dir);
+	g_object_unref (base);
+}
+
+
+void
+fr_window_archive_add_with_wildcard (FrWindow      *window,
+				     const char    *include_files,
+				     const char    *exclude_files,
+				     const char    *exclude_folders,
+				     const char    *base_dir,
+				     const char    *dest_dir,
+				     gboolean       update,
+				     gboolean       follow_links)
+{
+	fr_archive_add_with_wildcard (window->archive,
+				      include_files,
+				      exclude_files,
+				      exclude_folders,
+				      base_dir,
+				      (dest_dir == NULL)? fr_window_get_current_location (window): dest_dir,
+				      update,
+				      follow_links,
+				      window->priv->password,
+				      window->priv->encrypt_header,
+				      window->priv->compression,
+				      window->priv->volume_size);
+}
+
+
+void
+fr_window_archive_add_directory (FrWindow      *window,
+				 const char    *directory,
+				 const char    *base_dir,
+				 const char    *dest_dir,
+				 gboolean       update)
+{
+	fr_archive_add_directory (window->archive,
+				  directory,
+				  base_dir,
+				  (dest_dir == NULL)? fr_window_get_current_location (window): dest_dir,
+				  update,
+				  window->priv->password,
+				  window->priv->encrypt_header,
+				  window->priv->compression,
+				  window->priv->volume_size);
+}
+
+
+void
+fr_window_archive_add_items (FrWindow      *window,
+			     GList         *item_list,
+			     const char    *base_dir,
+			     const char    *dest_dir,
+			     gboolean       update)
+{
+	fr_archive_add_items (window->archive,
+			      item_list,
+			      base_dir,
+			      (dest_dir == NULL)? fr_window_get_current_location (window): dest_dir,
+			      update,
+			      window->priv->password,
+			      window->priv->encrypt_header,
+			      window->priv->compression,
+			      window->priv->volume_size);
+}
+
+
+void
+fr_window_archive_add_dropped_items (FrWindow *window,
+				     GList    *item_list,
+				     gboolean  update)
+{
+	fr_archive_add_dropped_items (window->archive,
+				      item_list,
+				      fr_window_get_current_location (window),
+				      fr_window_get_current_location (window),
+				      update,
+				      window->priv->password,
+				      window->priv->encrypt_header,
+				      window->priv->compression,
+				      window->priv->volume_size);
+}
+
+
+void
+fr_window_archive_remove (FrWindow      *window,
+			  GList         *file_list)
+{
+	fr_window_clipboard_remove_file_list (window, file_list);
+
+	fr_process_clear (window->archive->process);
+	fr_archive_remove (window->archive, file_list, window->priv->compression);
+	fr_process_start (window->archive->process);
+}
+
+
+/* -- window_archive_extract -- */
+
+
+static ExtractData*
+extract_data_new (GList      *file_list,
+		  const char *extract_to_dir,
+		  const char *base_dir,
+		  gboolean    skip_older,
+		  gboolean    overwrite,
+		  gboolean    junk_paths,
+		  gboolean    extract_here)
+{
+	ExtractData *edata;
+
+	edata = g_new0 (ExtractData, 1);
+	edata->file_list = path_list_dup (file_list);
+	if (extract_to_dir != NULL)
+		edata->extract_to_dir = g_strdup (extract_to_dir);
+	edata->skip_older = skip_older;
+	edata->overwrite = overwrite;
+	edata->junk_paths = junk_paths;
+	if (base_dir != NULL)
+		edata->base_dir = g_strdup (base_dir);
+	edata->extract_here = extract_here;
+
+	return edata;
+}
+
+
+static ExtractData*
+extract_to_data_new (const char *extract_to_dir)
+{
+	return extract_data_new (NULL,
+				 extract_to_dir,
+				 NULL,
+				 FALSE,
+				 TRUE,
+				 FALSE,
+				 FALSE);
+}
+
+
+static void
+extract_data_free (ExtractData *edata)
+{
+	g_return_if_fail (edata != NULL);
+
+	path_list_free (edata->file_list);
+	g_free (edata->extract_to_dir);
+	g_free (edata->base_dir);
+
+	g_free (edata);
+}
+
+
+static gboolean
+archive_is_encrypted (FrWindow *window,
+		      GList    *file_list)
+{
+	gboolean encrypted = FALSE;
+
+	if (file_list == NULL) {
+		int i;
+
+		for (i = 0; ! encrypted && i < window->archive->command->files->len; i++) {
+			FileData *fdata = g_ptr_array_index (window->archive->command->files, i);
+
+			if (fdata->encrypted)
+				encrypted = TRUE;
+		}
+	}
+	else {
+
+		GHashTable *file_hash;
+		int         i;
+		GList      *scan;
+
+		file_hash = g_hash_table_new (g_str_hash, g_str_equal);
+		for (i = 0; i < window->archive->command->files->len; i++) {
+			FileData *fdata = g_ptr_array_index (window->archive->command->files, i);
+			g_hash_table_insert (file_hash, fdata->original_path, fdata);
+		}
+
+		for (scan = file_list; ! encrypted && scan; scan = scan->next) {
+			char     *filename = scan->data;
+			FileData *fdata;
+
+			fdata = g_hash_table_lookup (file_hash, filename);
+			g_return_val_if_fail (fdata != NULL, FALSE);
+
+			if (fdata->encrypted)
+				encrypted = TRUE;
+		}
+
+		g_hash_table_destroy (file_hash);
+	}
+
+	return encrypted;
+}
+
+
+void
+fr_window_archive_extract_here (FrWindow   *window,
+				gboolean    skip_older,
+				gboolean    overwrite,
+				gboolean    junk_paths)
+{
+	ExtractData *edata;
+
+	edata = extract_data_new (NULL,
+				  NULL,
+				  NULL,
+				  skip_older,
+				  overwrite,
+				  junk_paths,
+				  TRUE);
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_EXTRACT,
+					    edata,
+					    (GFreeFunc) extract_data_free);
+
+	if (archive_is_encrypted (window, NULL) && (window->priv->password == NULL)) {
+		dlg_ask_password (window);
+		return;
+	}
+
+	window->priv->ask_to_open_destination_after_extraction = FALSE;
+
+	fr_process_clear (window->archive->process);
+	if (fr_archive_extract_here (window->archive,
+				     edata->skip_older,
+				     edata->overwrite,
+				     edata->junk_paths,
+				     window->priv->password))
+	{
+		fr_process_start (window->archive->process);
+	}
+}
+
+
+void
+fr_window_archive_extract (FrWindow   *window,
+			   GList      *file_list,
+			   const char *extract_to_dir,
+			   const char *base_dir,
+			   gboolean    skip_older,
+			   gboolean    overwrite,
+			   gboolean    junk_paths,
+			   gboolean    ask_to_open_destination)
+{
+	ExtractData *edata;
+	gboolean     do_not_extract = FALSE;
+	GError      *error = NULL;
+
+	edata = extract_data_new (file_list,
+				  extract_to_dir,
+				  base_dir,
+				  skip_older,
+				  overwrite,
+				  junk_paths,
+				  FALSE);
+
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_EXTRACT,
+					    edata,
+					    (GFreeFunc) extract_data_free);
+
+	if (archive_is_encrypted (window, edata->file_list) && (window->priv->password == NULL)) {
+		dlg_ask_password (window);
+		return;
+	}
+
+	if (! uri_is_dir (edata->extract_to_dir)) {
+		if (! ForceDirectoryCreation) {
+			GtkWidget *d;
+			int        r;
+			char      *folder_name;
+			char      *msg;
+
+			folder_name = g_filename_display_name (edata->extract_to_dir);
+			msg = g_strdup_printf (_("Destination folder \"%s\" does not exist.\n\nDo you want to create it?"), folder_name);
+			g_free (folder_name);
+
+			d = _gtk_message_dialog_new (GTK_WINDOW (window),
+						     GTK_DIALOG_MODAL,
+						     GTK_STOCK_DIALOG_QUESTION,
+						     msg,
+						     NULL,
+						     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+						     _("Create _Folder"), GTK_RESPONSE_YES,
+						     NULL);
+
+			gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES);
+			r = gtk_dialog_run (GTK_DIALOG (d));
+			gtk_widget_destroy (GTK_WIDGET (d));
+
+			g_free (msg);
+
+			if (r != GTK_RESPONSE_YES)
+				do_not_extract = TRUE;
+		}
+
+		if (! do_not_extract && ! ensure_dir_exists (edata->extract_to_dir, 0755, &error)) {
+			GtkWidget  *d;
+
+			d = _gtk_error_dialog_new (GTK_WINDOW (window),
+						   0,
+						   NULL,
+						   _("Extraction not performed"),
+						   _("Could not create the destination folder: %s."),
+						   error->message);
+			g_clear_error (&error);
+			fr_window_show_error_dialog (window, d, GTK_WINDOW (window));
+			fr_window_stop_batch (window);
+
+			return;
+		}
+	}
+
+	if (do_not_extract) {
+		GtkWidget *d;
+
+		d = _gtk_message_dialog_new (GTK_WINDOW (window),
+					     0,
+					     GTK_STOCK_DIALOG_WARNING,
+					     _("Extraction not performed"),
+					     NULL,
+					     GTK_STOCK_OK, GTK_RESPONSE_OK,
+					     NULL);
+		gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_OK);
+		fr_window_show_error_dialog (window, d, GTK_WINDOW (window));
+		fr_window_stop_batch (window);
+
+		return;
+	}
+
+	window->priv->ask_to_open_destination_after_extraction = ask_to_open_destination;
+
+	fr_process_clear (window->archive->process);
+	fr_archive_extract (window->archive,
+			    edata->file_list,
+			    edata->extract_to_dir,
+			    edata->base_dir,
+			    edata->skip_older,
+			    edata->overwrite,
+			    edata->junk_paths,
+			    window->priv->password);
+	fr_process_start (window->archive->process);
+}
+
+
+void
+fr_window_archive_test (FrWindow *window)
+{
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_TEST,
+					    NULL,
+					    NULL);
+	fr_archive_test (window->archive, window->priv->password);
+}
+
+
+void
+fr_window_set_password (FrWindow   *window,
+			const char *password)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->password != NULL) {
+		g_free (window->priv->password);
+		window->priv->password = NULL;
+	}
+
+	if ((password != NULL) && (password[0] != '\0'))
+		window->priv->password = g_strdup (password);
+}
+
+void
+fr_window_set_password_for_paste (FrWindow   *window,
+				  const char *password)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->password_for_paste != NULL) {
+		g_free (window->priv->password_for_paste);
+		window->priv->password_for_paste = NULL;
+	}
+
+	if ((password != NULL) && (password[0] != '\0'))
+		window->priv->password_for_paste = g_strdup (password);
+}
+
+const char *
+fr_window_get_password (FrWindow *window)
+{
+	g_return_val_if_fail (window != NULL, NULL);
+
+	return window->priv->password;
+}
+
+
+void
+fr_window_set_encrypt_header (FrWindow *window,
+			      gboolean  encrypt_header)
+{
+	g_return_if_fail (window != NULL);
+
+	window->priv->encrypt_header = encrypt_header;
+}
+
+
+gboolean
+fr_window_get_encrypt_header (FrWindow *window)
+{
+	return window->priv->encrypt_header;
+}
+
+
+void
+fr_window_set_compression (FrWindow      *window,
+			   FrCompression  compression)
+{
+	g_return_if_fail (window != NULL);
+
+	window->priv->compression = compression;
+}
+
+
+FrCompression
+fr_window_get_compression (FrWindow *window)
+{
+	return window->priv->compression;
+}
+
+
+void
+fr_window_set_volume_size (FrWindow *window,
+			   guint     volume_size)
+{
+	g_return_if_fail (window != NULL);
+
+	window->priv->volume_size = volume_size;
+}
+
+
+guint
+fr_window_get_volume_size (FrWindow *window)
+{
+	return window->priv->volume_size;
+}
+
+
+void
+fr_window_go_to_location (FrWindow   *window,
+			  const char *path,
+			  gboolean    force_update)
+{
+	char *dir;
+
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (path != NULL);
+
+	if (force_update) {
+		g_free (window->priv->last_location);
+		window->priv->last_location = NULL;
+	}
+
+	if (path[strlen (path) - 1] != '/')
+		dir = g_strconcat (path, "/", NULL);
+	else
+		dir = g_strdup (path);
+
+	if ((window->priv->last_location == NULL) || (strcmp (window->priv->last_location, dir) != 0)) {
+		g_free (window->priv->last_location);
+		window->priv->last_location = dir;
+
+		fr_window_history_add (window, dir);
+		fr_window_update_file_list (window, TRUE);
+		fr_window_update_current_location (window);
+	}
+	else
+		g_free (dir);
+}
+
+
+const char *
+fr_window_get_current_location (FrWindow *window)
+{
+	if (window->priv->history_current == NULL) {
+		fr_window_history_add (window, "/");
+		return window->priv->history_current->data;
+	}
+	else
+		return (const char*) window->priv->history_current->data;
+}
+
+
+void
+fr_window_go_up_one_level (FrWindow *window)
+{
+	char *parent_dir;
+
+	g_return_if_fail (window != NULL);
+
+	parent_dir = get_parent_dir (fr_window_get_current_location (window));
+	fr_window_go_to_location (window, parent_dir, FALSE);
+	g_free (parent_dir);
+}
+
+
+void
+fr_window_go_back (FrWindow *window)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->history == NULL)
+		return;
+	if (window->priv->history_current == NULL)
+		return;
+	if (window->priv->history_current->next == NULL)
+		return;
+	window->priv->history_current = window->priv->history_current->next;
+
+	fr_window_go_to_location (window, window->priv->history_current->data, FALSE);
+}
+
+
+void
+fr_window_go_forward (FrWindow *window)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->history == NULL)
+		return;
+	if (window->priv->history_current == NULL)
+		return;
+	if (window->priv->history_current->prev == NULL)
+		return;
+	window->priv->history_current = window->priv->history_current->prev;
+
+	fr_window_go_to_location (window, window->priv->history_current->data, FALSE);
+}
+
+
+void
+fr_window_set_list_mode (FrWindow         *window,
+			 FrWindowListMode  list_mode)
+{
+	g_return_if_fail (window != NULL);
+
+	window->priv->list_mode = window->priv->last_list_mode = list_mode;
+	if (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT) {
+		fr_window_history_clear (window);
+		fr_window_history_add (window, "/");
+	}
+
+	preferences_set_list_mode (window->priv->last_list_mode);
+	eel_mateconf_set_boolean (PREF_LIST_SHOW_PATH, (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT));
+
+	fr_window_update_file_list (window, TRUE);
+	fr_window_update_dir_tree (window);
+	fr_window_update_current_location (window);
+}
+
+
+GtkTreeModel *
+fr_window_get_list_store (FrWindow *window)
+{
+	return GTK_TREE_MODEL (window->priv->list_store);
+}
+
+
+void
+fr_window_find (FrWindow *window)
+{
+	window->priv->filter_mode = TRUE;
+	gtk_widget_show (window->priv->filter_bar);
+	gtk_widget_grab_focus (window->priv->filter_entry);
+}
+
+
+void
+fr_window_select_all (FrWindow *window)
+{
+	gtk_tree_selection_select_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view)));
+}
+
+
+void
+fr_window_unselect_all (FrWindow *window)
+{
+	gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (window->priv->list_view)));
+}
+
+
+void
+fr_window_set_sort_type (FrWindow     *window,
+			 GtkSortType   sort_type)
+{
+	window->priv->sort_type = sort_type;
+	fr_window_update_list_order (window);
+}
+
+
+void
+fr_window_stop (FrWindow *window)
+{
+	if (! window->priv->stoppable)
+		return;
+
+	if (window->priv->activity_ref > 0)
+		fr_archive_stop (window->archive);
+
+	if (window->priv->convert_data.converting)
+		fr_window_convert_data_free (window, TRUE);
+}
+
+
+/* -- start/stop activity mode -- */
+
+
+static int
+activity_cb (gpointer data)
+{
+	FrWindow *window = data;
+
+	if ((window->priv->pd_progress_bar != NULL) && window->priv->progress_pulse)
+		gtk_progress_bar_pulse (GTK_PROGRESS_BAR (window->priv->pd_progress_bar));
+	if (window->priv->progress_pulse)
+		gtk_progress_bar_pulse (GTK_PROGRESS_BAR (window->priv->progress_bar));
+
+	return TRUE;
+}
+
+
+void
+fr_window_start_activity_mode (FrWindow *window)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->activity_ref++ > 0)
+		return;
+
+	window->priv->activity_timeout_handle = g_timeout_add (ACTIVITY_DELAY,
+							       activity_cb,
+							       window);
+	fr_window_update_sensitivity (window);
+}
+
+
+void
+fr_window_stop_activity_mode (FrWindow *window)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->activity_ref == 0)
+		return;
+
+	window->priv->activity_ref--;
+
+	if (window->priv->activity_ref > 0)
+		return;
+
+	if (window->priv->activity_timeout_handle == 0)
+		return;
+
+	g_source_remove (window->priv->activity_timeout_handle);
+	window->priv->activity_timeout_handle = 0;
+
+	if (! gtk_widget_get_realized (GTK_WIDGET (window)))
+		return;
+
+	if (window->priv->progress_dialog != NULL)
+		gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (window->priv->pd_progress_bar), 0.0);
+
+	if (! window->priv->batch_mode) {
+		if (window->priv->progress_bar != NULL)
+			gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (window->priv->progress_bar), 0.0);
+		fr_window_update_sensitivity (window);
+	}
+}
+
+
+static gboolean
+last_output_window__unrealize_cb (GtkWidget  *widget,
+				  gpointer    data)
+{
+	pref_util_save_window_geometry (GTK_WINDOW (widget), LAST_OUTPUT_DIALOG_NAME);
+	return FALSE;
+}
+
+
+void
+fr_window_view_last_output (FrWindow   *window,
+			    const char *title)
+{
+	GtkWidget     *dialog;
+	GtkWidget     *vbox;
+	GtkWidget     *text_view;
+	GtkWidget     *scrolled;
+	GtkTextBuffer *text_buffer;
+	GtkTextIter    iter;
+	GList         *scan;
+
+	if (title == NULL)
+		title = _("Last Output");
+
+	dialog = gtk_dialog_new_with_buttons (title,
+					      GTK_WINDOW (window),
+					      GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+					      GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+					      NULL);
+	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
+
+	gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
+	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
+	gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
+	gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 6);
+	gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 8);
+
+	gtk_widget_set_size_request (dialog, 500, 300);
+
+	/* Add text */
+
+	scrolled = gtk_scrolled_window_new (NULL, NULL);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+					GTK_POLICY_AUTOMATIC,
+					GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+					     GTK_SHADOW_ETCHED_IN);
+
+	text_buffer = gtk_text_buffer_new (NULL);
+	gtk_text_buffer_create_tag (text_buffer, "monospace",
+				    "family", "monospace", NULL);
+
+	text_view = gtk_text_view_new_with_buffer (text_buffer);
+	g_object_unref (text_buffer);
+	gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
+	gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE);
+
+	/**/
+
+	vbox = gtk_vbox_new (FALSE, 6);
+	gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+	gtk_container_add (GTK_CONTAINER (scrolled), text_view);
+	gtk_box_pack_start (GTK_BOX (vbox), scrolled,
+			    TRUE, TRUE, 0);
+
+	gtk_widget_show_all (vbox);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+			    vbox,
+			    TRUE, TRUE, 0);
+
+	/* signals */
+
+	g_signal_connect (G_OBJECT (dialog),
+			  "response",
+			  G_CALLBACK (gtk_widget_destroy),
+			  NULL);
+
+	g_signal_connect (G_OBJECT (dialog),
+			  "unrealize",
+			  G_CALLBACK (last_output_window__unrealize_cb),
+			  NULL);
+
+	/**/
+
+	gtk_text_buffer_get_iter_at_offset (text_buffer, &iter, 0);
+	scan = window->archive->process->out.raw;
+	for (; scan; scan = scan->next) {
+		char        *line = scan->data;
+		char        *utf8_line;
+		gsize        bytes_written;
+
+		utf8_line = g_locale_to_utf8 (line, -1, NULL, &bytes_written, NULL);
+		gtk_text_buffer_insert_with_tags_by_name (text_buffer,
+							  &iter,
+							  utf8_line,
+							  bytes_written,
+							  "monospace", NULL);
+		g_free (utf8_line);
+		gtk_text_buffer_insert (text_buffer, &iter, "\n", 1);
+	}
+
+	/**/
+
+	pref_util_restore_window_geometry (GTK_WINDOW (dialog), LAST_OUTPUT_DIALOG_NAME);
+}
+
+
+/* -- fr_window_rename_selection -- */
+
+
+typedef struct {
+	char     *path_to_rename;
+	char     *old_name;
+	char     *new_name;
+	char     *current_dir;
+	gboolean  is_dir;
+	gboolean  dir_in_archive;
+	char     *original_path;
+} RenameData;
+
+
+static RenameData*
+rename_data_new (const char *path_to_rename,
+		 const char *old_name,
+		 const char *new_name,
+		 const char *current_dir,
+		 gboolean    is_dir,
+		 gboolean    dir_in_archive,
+		 const char *original_path)
+{
+	RenameData *rdata;
+
+	rdata = g_new0 (RenameData, 1);
+	rdata->path_to_rename = g_strdup (path_to_rename);
+	if (old_name != NULL)
+		rdata->old_name = g_strdup (old_name);
+	if (new_name != NULL)
+		rdata->new_name = g_strdup (new_name);
+	if (current_dir != NULL)
+		rdata->current_dir = g_strdup (current_dir);
+	rdata->is_dir = is_dir;
+	rdata->dir_in_archive = dir_in_archive;
+	if (original_path != NULL)
+		rdata->original_path = g_strdup (original_path);
+
+	return rdata;
+}
+
+
+static void
+rename_data_free (RenameData *rdata)
+{
+	g_return_if_fail (rdata != NULL);
+
+	g_free (rdata->path_to_rename);
+	g_free (rdata->old_name);
+	g_free (rdata->new_name);
+	g_free (rdata->current_dir);
+	g_free (rdata->original_path);
+	g_free (rdata);
+}
+
+
+static void
+rename_selection (FrWindow   *window,
+		  const char *path_to_rename,
+		  const char *old_name,
+		  const char *new_name,
+		  const char *current_dir,
+		  gboolean    is_dir,
+		  gboolean    dir_in_archive,
+		  const char *original_path)
+{
+	FrArchive  *archive = window->archive;
+	RenameData *rdata;
+	char       *tmp_dir;
+	GList      *file_list;
+	gboolean    added_dir;
+	char       *new_dirname;
+	GList      *new_file_list;
+	GList      *scan;
+
+	rdata = rename_data_new (path_to_rename,
+				 old_name,
+				 new_name,
+				 current_dir,
+				 is_dir,
+				 dir_in_archive,
+				 original_path);
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_RENAME,
+					    rdata,
+					    (GFreeFunc) rename_data_free);
+
+	fr_process_clear (archive->process);
+
+	tmp_dir = get_temp_work_dir (NULL);
+
+	if (is_dir)
+		file_list = get_dir_list_from_path (window, rdata->path_to_rename);
+	else
+		file_list = g_list_append (NULL, g_strdup (rdata->path_to_rename));
+
+	fr_archive_extract_to_local (archive,
+				     file_list,
+				     tmp_dir,
+				     NULL,
+				     FALSE,
+				     TRUE,
+				     FALSE,
+				     window->priv->password);
+
+	/* temporarily add the dir to rename to the list if it's stored in the
+	 * archive, this way it will be removed from the archive... */
+	added_dir = FALSE;
+	if (is_dir && dir_in_archive && ! g_list_find_custom (file_list, original_path, (GCompareFunc) strcmp)) {
+		file_list = g_list_prepend (file_list, g_strdup (original_path));
+		added_dir = TRUE;
+	}
+
+	fr_archive_remove (archive, file_list, window->priv->compression);
+	fr_window_clipboard_remove_file_list (window, file_list);
+
+	/* ...and remove it from the list again */
+	if (added_dir) {
+		GList *tmp;
+
+		tmp = file_list;
+		file_list = g_list_remove_link (file_list, tmp);
+
+		g_free (tmp->data);
+		g_list_free (tmp);
+	}
+
+	/* rename the files. */
+
+	new_dirname = g_build_filename (rdata->current_dir + 1, rdata->new_name, "/", NULL);
+	new_file_list = NULL;
+	if (rdata->is_dir) {
+		char *old_path;
+		char *new_path;
+
+		old_path = g_build_filename (tmp_dir, rdata->current_dir, rdata->old_name, NULL);
+		new_path = g_build_filename (tmp_dir, rdata->current_dir, rdata->new_name, NULL);
+
+		fr_process_begin_command (archive->process, "mv");
+		fr_process_add_arg (archive->process, "-f");
+		fr_process_add_arg (archive->process, old_path);
+		fr_process_add_arg (archive->process, new_path);
+		fr_process_end_command (archive->process);
+
+		g_free (old_path);
+		g_free (new_path);
+	}
+
+	for (scan = file_list; scan; scan = scan->next) {
+		const char *current_dir_relative = rdata->current_dir + 1;
+		const char *filename = (char*) scan->data;
+		char       *old_path = NULL, *common = NULL, *new_path = NULL;
+		char       *new_filename;
+
+		old_path = g_build_filename (tmp_dir, filename, NULL);
+
+		if (strlen (filename) > (strlen (rdata->current_dir) + strlen (rdata->old_name)))
+			common = g_strdup (filename + strlen (rdata->current_dir) + strlen (rdata->old_name));
+		new_path = g_build_filename (tmp_dir, rdata->current_dir, rdata->new_name, common, NULL);
+
+		if (! rdata->is_dir) {
+			fr_process_begin_command (archive->process, "mv");
+			fr_process_add_arg (archive->process, "-f");
+			fr_process_add_arg (archive->process, old_path);
+			fr_process_add_arg (archive->process, new_path);
+			fr_process_end_command (archive->process);
+		}
+
+		new_filename = g_build_filename (current_dir_relative, rdata->new_name, common, NULL);
+		new_file_list = g_list_prepend (new_file_list, new_filename);
+
+		g_free (old_path);
+		g_free (common);
+		g_free (new_path);
+	}
+	new_file_list = g_list_reverse (new_file_list);
+
+	/* FIXME: this is broken for tar archives.
+	if (is_dir && dir_in_archive && ! g_list_find_custom (new_file_list, new_dirname, (GCompareFunc) strcmp))
+		new_file_list = g_list_prepend (new_file_list, g_build_filename (rdata->current_dir + 1, rdata->new_name, NULL));
+	*/
+
+	fr_archive_add (archive,
+			new_file_list,
+			tmp_dir,
+			NULL,
+			FALSE,
+			FALSE,
+			window->priv->password,
+			window->priv->encrypt_header,
+			window->priv->compression,
+			window->priv->volume_size);
+
+	g_free (new_dirname);
+	path_list_free (new_file_list);
+	path_list_free (file_list);
+
+	/* remove the tmp dir */
+
+	fr_process_begin_command (archive->process, "rm");
+	fr_process_set_working_dir (archive->process, g_get_tmp_dir ());
+	fr_process_set_sticky (archive->process, TRUE);
+	fr_process_add_arg (archive->process, "-rf");
+	fr_process_add_arg (archive->process, tmp_dir);
+	fr_process_end_command (archive->process);
+
+	fr_process_start (archive->process);
+
+	g_free (tmp_dir);
+}
+
+
+static gboolean
+valid_name (const char  *new_name,
+	    const char  *old_name,
+	    char       **reason)
+{
+	char     *utf8_new_name;
+	gboolean  retval = TRUE;
+
+	new_name = eat_spaces (new_name);
+	utf8_new_name = g_filename_display_name (new_name);
+
+	if (*new_name == '\0') {
+		/* Translators: the name references to a filename.  This message can appear when renaming a file. */
+		*reason = g_strdup_printf ("%s\n\n%s", _("The new name is void."), _("Please use a different name."));
+		retval = FALSE;
+	}
+	else if (strcmp (new_name, old_name) == 0) {
+		/* Translators: the name references to a filename.  This message can appear when renaming a file. */
+		*reason = g_strdup_printf ("%s\n\n%s", _("The new name is equal to the old one."), _("Please use a different name."));
+		retval = FALSE;
+	}
+	else if (strchrs (new_name, BAD_CHARS)) {
+		/* Translators: the name references to a filename.  This message can appear when renaming a file. */
+		*reason = g_strdup_printf (_("The name \"%s\" is not valid because it cannot contain the characters: %s\n\n%s"), utf8_new_name, BAD_CHARS, _("Please use a different name."));
+		retval = FALSE;
+	}
+
+	g_free (utf8_new_name);
+
+	return retval;
+}
+
+
+static gboolean
+name_is_present (FrWindow    *window,
+		 const char  *current_dir,
+		 const char  *new_name,
+		 char       **reason)
+{
+	gboolean  retval = FALSE;
+	int       i;
+	char     *new_filename;
+	int       new_filename_l;
+
+	*reason = NULL;
+
+	new_filename = g_build_filename (current_dir, new_name, NULL);
+	new_filename_l = strlen (new_filename);
+
+	for (i = 0; i < window->archive->command->files->len; i++) {
+		FileData   *fdata = g_ptr_array_index (window->archive->command->files, i);
+		const char *filename = fdata->full_path;
+
+		if ((strncmp (filename, new_filename, new_filename_l) == 0)
+		    && ((filename[new_filename_l] == '\0')
+			|| (filename[new_filename_l] == G_DIR_SEPARATOR))) {
+			char *utf8_name = g_filename_display_name (new_name);
+
+			if (filename[new_filename_l] == G_DIR_SEPARATOR)
+				*reason = g_strdup_printf (_("A folder named \"%s\" already exists.\n\n%s"), utf8_name, _("Please use a different name."));
+			else
+				*reason = g_strdup_printf (_("A file named \"%s\" already exists.\n\n%s"), utf8_name, _("Please use a different name."));
+
+			retval = TRUE;
+			break;
+		}
+	}
+
+	g_free (new_filename);
+
+	return retval;
+}
+
+
+void
+fr_window_rename_selection (FrWindow *window,
+			    gboolean  from_sidebar)
+{
+	char     *path_to_rename;
+	char     *parent_dir;
+	char     *old_name;
+	gboolean  renaming_dir = FALSE;
+	gboolean  dir_in_archive = FALSE;
+	char     *original_path = NULL;
+	char     *utf8_old_name;
+	char     *utf8_new_name;
+
+	if (from_sidebar) {
+		path_to_rename = fr_window_get_selected_folder_in_tree_view (window);
+		if (path_to_rename == NULL)
+			return;
+		parent_dir = remove_level_from_path (path_to_rename);
+		old_name = g_strdup (file_name_from_path (path_to_rename));
+		renaming_dir = TRUE;
+	}
+	else {
+		FileData *selected_item;
+
+		selected_item = fr_window_get_selected_item_from_file_list (window);
+		if (selected_item == NULL)
+			return;
+
+		renaming_dir = file_data_is_dir (selected_item);
+		dir_in_archive = selected_item->dir;
+		original_path = g_strdup (selected_item->original_path);
+
+		if (renaming_dir && ! dir_in_archive) {
+			parent_dir = g_strdup (fr_window_get_current_location (window));
+			old_name = g_strdup (selected_item->list_name);
+			path_to_rename = g_build_filename (parent_dir, old_name, NULL);
+		}
+		else {
+			if (renaming_dir) {
+				path_to_rename = remove_ending_separator (selected_item->full_path);
+				parent_dir = remove_level_from_path (path_to_rename);
+			}
+			else {
+				path_to_rename = g_strdup (selected_item->original_path);
+				parent_dir = remove_level_from_path (selected_item->full_path);
+			}
+			old_name = g_strdup (selected_item->name);
+		}
+
+		file_data_free (selected_item);
+	}
+
+ retry__rename_selection:
+	utf8_old_name = g_locale_to_utf8 (old_name, -1 ,0 ,0 ,0);
+	utf8_new_name = _gtk_request_dialog_run (GTK_WINDOW (window),
+						 (GTK_DIALOG_DESTROY_WITH_PARENT
+						  | GTK_DIALOG_MODAL),
+						 _("Rename"),
+						 (renaming_dir ? _("New folder name") : _("New file name")),
+						 utf8_old_name,
+						 1024,
+						 GTK_STOCK_CANCEL,
+						 _("_Rename"));
+	g_free (utf8_old_name);
+
+	if (utf8_new_name != NULL) {
+		char *new_name;
+		char *reason = NULL;
+
+		new_name = g_filename_from_utf8 (utf8_new_name, -1, 0, 0, 0);
+		g_free (utf8_new_name);
+
+		if (! valid_name (new_name, old_name, &reason)) {
+			char      *utf8_name = g_filename_display_name (new_name);
+			GtkWidget *dlg;
+
+			dlg = _gtk_error_dialog_new (GTK_WINDOW (window),
+						     GTK_DIALOG_DESTROY_WITH_PARENT,
+						     NULL,
+						     (renaming_dir ? _("Could not rename the folder") : _("Could not rename the file")),
+						     "%s",
+						     reason);
+			gtk_dialog_run (GTK_DIALOG (dlg));
+			gtk_widget_destroy (dlg);
+
+			g_free (reason);
+			g_free (utf8_name);
+			g_free (new_name);
+
+			goto retry__rename_selection;
+		}
+
+		if (name_is_present (window, parent_dir, new_name, &reason)) {
+			GtkWidget *dlg;
+			int        r;
+
+			dlg = _gtk_message_dialog_new (GTK_WINDOW (window),
+						       GTK_DIALOG_MODAL,
+						       GTK_STOCK_DIALOG_QUESTION,
+						       (renaming_dir ? _("Could not rename the folder") : _("Could not rename the file")),
+						       reason,
+						       GTK_STOCK_CLOSE, GTK_RESPONSE_OK,
+						       NULL);
+			r = gtk_dialog_run (GTK_DIALOG (dlg));
+			gtk_widget_destroy (dlg);
+			g_free (reason);
+			g_free (new_name);
+			goto retry__rename_selection;
+		}
+
+		rename_selection (window,
+				  path_to_rename,
+				  old_name,
+				  new_name,
+				  parent_dir,
+				  renaming_dir,
+				  dir_in_archive,
+				  original_path);
+
+		g_free (new_name);
+	}
+
+	g_free (old_name);
+	g_free (parent_dir);
+	g_free (path_to_rename);
+	g_free (original_path);
+}
+
+
+static void
+fr_clipboard_get (GtkClipboard     *clipboard,
+		  GtkSelectionData *selection_data,
+		  guint             info,
+		  gpointer          user_data_or_owner)
+{
+	FrWindow *window = user_data_or_owner;
+	char     *data;
+
+	if (gtk_selection_data_get_target (selection_data) != FR_SPECIAL_URI_LIST)
+		return;
+
+	data = get_selection_data_from_clipboard_data (window, window->priv->copy_data);
+	gtk_selection_data_set (selection_data,
+				gtk_selection_data_get_target (selection_data),
+				8,
+				(guchar *) data,
+				strlen (data));
+	g_free (data);
+}
+
+
+static void
+fr_clipboard_clear (GtkClipboard *clipboard,
+		    gpointer      user_data_or_owner)
+{
+	FrWindow *window = user_data_or_owner;
+
+	if (window->priv->copy_data != NULL) {
+		fr_clipboard_data_unref (window->priv->copy_data);
+		window->priv->copy_data = NULL;
+	}
+}
+
+
+GList *
+fr_window_get_selection (FrWindow   *window,
+		  	 gboolean    from_sidebar,
+		  	 char      **return_base_dir)
+{
+	GList *files;
+	char  *base_dir;
+
+	if (from_sidebar) {
+		char *selected_folder;
+		char *parent_folder;
+
+		files = fr_window_get_folder_tree_selection (window, TRUE, NULL);
+		selected_folder = fr_window_get_selected_folder_in_tree_view (window);
+		parent_folder = remove_level_from_path (selected_folder);
+		if (parent_folder == NULL)
+			base_dir = g_strdup ("/");
+		else if (parent_folder[strlen (parent_folder) - 1] == '/')
+			base_dir = g_strdup (parent_folder);
+		else
+			base_dir = g_strconcat (parent_folder, "/", NULL);
+		g_free (selected_folder);
+		g_free (parent_folder);
+	}
+	else {
+		files = fr_window_get_file_list_selection (window, TRUE, NULL);
+		base_dir = g_strdup (fr_window_get_current_location (window));
+	}
+
+	if (return_base_dir)
+		*return_base_dir = base_dir;
+	else
+		g_free (base_dir);
+
+	return files;
+}
+
+
+static void
+fr_window_copy_or_cut_selection (FrWindow      *window,
+				 FRClipboardOp  op,
+			  	 gboolean       from_sidebar)
+{
+	GList        *files;
+	char         *base_dir;
+	GtkClipboard *clipboard;
+
+	files = fr_window_get_selection (window, from_sidebar, &base_dir);
+
+	if (window->priv->copy_data != NULL)
+		fr_clipboard_data_unref (window->priv->copy_data);
+	window->priv->copy_data = fr_clipboard_data_new ();
+	window->priv->copy_data->files = files;
+	window->priv->copy_data->op = op;
+	window->priv->copy_data->base_dir = base_dir;
+
+	clipboard = gtk_clipboard_get (FR_CLIPBOARD);
+	gtk_clipboard_set_with_owner (clipboard,
+				      clipboard_targets,
+				      G_N_ELEMENTS (clipboard_targets),
+				      fr_clipboard_get,
+				      fr_clipboard_clear,
+				      G_OBJECT (window));
+
+	fr_window_update_sensitivity (window);
+}
+
+
+void
+fr_window_copy_selection (FrWindow *window,
+			  gboolean  from_sidebar)
+{
+	fr_window_copy_or_cut_selection (window, FR_CLIPBOARD_OP_COPY, from_sidebar);
+}
+
+
+void
+fr_window_cut_selection (FrWindow *window,
+			 gboolean  from_sidebar)
+{
+	fr_window_copy_or_cut_selection (window, FR_CLIPBOARD_OP_CUT, from_sidebar);
+}
+
+
+static gboolean
+always_fake_load (FrArchive *archive,
+		  gpointer   data)
+{
+	return TRUE;
+}
+
+
+static void
+add_pasted_files (FrWindow        *window,
+		  FrClipboardData *data)
+{
+	const char *current_dir_relative = data->current_dir + 1;
+	GList      *scan;
+	GList      *new_file_list = NULL;
+
+	if (window->priv->password_for_paste != NULL) {
+		g_free (window->priv->password_for_paste);
+		window->priv->password_for_paste = NULL;
+	}
+
+	fr_process_clear (window->archive->process);
+	for (scan = data->files; scan; scan = scan->next) {
+		const char *old_name = (char*) scan->data;
+		char       *new_name = g_build_filename (current_dir_relative, old_name + strlen (data->base_dir) - 1, NULL);
+
+		/* skip folders */
+
+		if ((strcmp (old_name, new_name) != 0)
+		    && (old_name[strlen (old_name) - 1] != '/'))
+		{
+			fr_process_begin_command (window->archive->process, "mv");
+			fr_process_set_working_dir (window->archive->process, data->tmp_dir);
+			fr_process_add_arg (window->archive->process, "-f");
+			fr_process_add_arg (window->archive->process, old_name);
+			fr_process_add_arg (window->archive->process, new_name);
+			fr_process_end_command (window->archive->process);
+		}
+
+		new_file_list = g_list_prepend (new_file_list, new_name);
+	}
+
+	fr_archive_add (window->archive,
+			new_file_list,
+			data->tmp_dir,
+			NULL,
+			FALSE,
+			FALSE,
+			window->priv->password,
+			window->priv->encrypt_header,
+			window->priv->compression,
+			window->priv->volume_size);
+
+	path_list_free (new_file_list);
+
+	/* remove the tmp dir */
+
+	fr_process_begin_command (window->archive->process, "rm");
+	fr_process_set_working_dir (window->archive->process, g_get_tmp_dir ());
+	fr_process_set_sticky (window->archive->process, TRUE);
+	fr_process_add_arg (window->archive->process, "-rf");
+	fr_process_add_arg (window->archive->process, data->tmp_dir);
+	fr_process_end_command (window->archive->process);
+
+	fr_process_start (window->archive->process);
+}
+
+
+static void
+copy_from_archive_action_performed_cb (FrArchive   *archive,
+				       FrAction     action,
+				       FrProcError *error,
+				       gpointer     data)
+{
+	FrWindow *window = data;
+	gboolean  continue_batch = FALSE;
+
+#ifdef DEBUG
+	debug (DEBUG_INFO, "%s [DONE] (FR::Window)\n", action_names[action]);
+#endif
+
+	fr_window_stop_activity_mode (window);
+	fr_window_pop_message (window);
+	close_progress_dialog (window, FALSE);
+
+	if (error->type == FR_PROC_ERROR_ASK_PASSWORD) {
+		dlg_ask_password_for_paste_operation (window);
+		return;
+	}
+
+	continue_batch = handle_errors (window, archive, action, error);
+
+	if (error->type != FR_PROC_ERROR_NONE) {
+		fr_clipboard_data_unref (window->priv->clipboard_data);
+		window->priv->clipboard_data = NULL;
+		return;
+	}
+
+	switch (action) {
+	case FR_ACTION_LISTING_CONTENT:
+		fr_process_clear (window->priv->copy_from_archive->process);
+		fr_archive_extract_to_local (window->priv->copy_from_archive,
+					     window->priv->clipboard_data->files,
+					     window->priv->clipboard_data->tmp_dir,
+					     NULL,
+					     FALSE,
+					     TRUE,
+					     FALSE,
+					     window->priv->clipboard_data->archive_password);
+		fr_process_start (window->priv->copy_from_archive->process);
+		break;
+
+	case FR_ACTION_EXTRACTING_FILES:
+		if (window->priv->clipboard_data->op == FR_CLIPBOARD_OP_CUT) {
+			fr_process_clear (window->priv->copy_from_archive->process);
+			fr_archive_remove (window->priv->copy_from_archive,
+					   window->priv->clipboard_data->files,
+					   window->priv->compression);
+			fr_process_start (window->priv->copy_from_archive->process);
+		}
+		else
+			add_pasted_files (window, window->priv->clipboard_data);
+		break;
+
+	case FR_ACTION_DELETING_FILES:
+		add_pasted_files (window, window->priv->clipboard_data);
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+static void
+fr_window_paste_from_clipboard_data (FrWindow        *window,
+				     FrClipboardData *data)
+{
+	const char *current_dir_relative;
+	GHashTable *created_dirs;
+	GList      *scan;
+
+	if (window->priv->password_for_paste != NULL)
+		fr_clipboard_data_set_password (data, window->priv->password_for_paste);
+
+	if (window->priv->clipboard_data != data) {
+		fr_clipboard_data_unref (window->priv->clipboard_data);
+		window->priv->clipboard_data = data;
+	}
+
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_PASTE,
+					    fr_clipboard_data_ref (data),
+					    (GFreeFunc) fr_clipboard_data_unref);
+
+	current_dir_relative = data->current_dir + 1;
+
+	data->tmp_dir = get_temp_work_dir (NULL);
+	created_dirs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+	for (scan = data->files; scan; scan = scan->next) {
+		const char *old_name = (char*) scan->data;
+		char       *new_name = g_build_filename (current_dir_relative, old_name + strlen (data->base_dir) - 1, NULL);
+		char       *dir = remove_level_from_path (new_name);
+
+		if ((dir != NULL) && (g_hash_table_lookup (created_dirs, dir) == NULL)) {
+			char *dir_path;
+
+			dir_path = g_build_filename (data->tmp_dir, dir, NULL);
+			debug (DEBUG_INFO, "mktree %s\n", dir_path);
+			make_directory_tree_from_path (dir_path, 0700, NULL);
+
+			g_free (dir_path);
+			g_hash_table_replace (created_dirs, g_strdup (dir), "1");
+		}
+
+		g_free (dir);
+		g_free (new_name);
+	}
+	g_hash_table_destroy (created_dirs);
+
+	/**/
+
+	if (window->priv->copy_from_archive == NULL) {
+		window->priv->copy_from_archive = fr_archive_new ();
+		g_signal_connect (G_OBJECT (window->priv->copy_from_archive),
+				  "start",
+				  G_CALLBACK (action_started),
+				  window);
+		g_signal_connect (G_OBJECT (window->priv->copy_from_archive),
+				  "done",
+				  G_CALLBACK (copy_from_archive_action_performed_cb),
+				  window);
+		g_signal_connect (G_OBJECT (window->priv->copy_from_archive),
+				  "progress",
+				  G_CALLBACK (fr_window_progress_cb),
+				  window);
+		g_signal_connect (G_OBJECT (window->priv->copy_from_archive),
+				  "message",
+				  G_CALLBACK (fr_window_message_cb),
+				  window);
+		g_signal_connect (G_OBJECT (window->priv->copy_from_archive),
+				  "stoppable",
+				  G_CALLBACK (fr_window_stoppable_cb),
+				  window);
+		fr_archive_set_fake_load_func (window->priv->copy_from_archive, always_fake_load, NULL);
+	}
+	fr_archive_load_local (window->priv->copy_from_archive,
+			       data->archive_filename,
+			       data->archive_password);
+}
+
+
+static void
+fr_window_paste_selection_to (FrWindow   *window,
+			      const char *current_dir)
+{
+	GtkClipboard     *clipboard;
+	GtkSelectionData *selection_data;
+	FrClipboardData  *paste_data;
+
+	clipboard = gtk_clipboard_get (FR_CLIPBOARD);
+	selection_data = gtk_clipboard_wait_for_contents (clipboard, FR_SPECIAL_URI_LIST);
+	if (selection_data == NULL)
+		return;
+
+	paste_data = get_clipboard_data_from_selection_data (window, (char*) gtk_selection_data_get_data (selection_data));
+	paste_data->current_dir = g_strdup (current_dir);
+	fr_window_paste_from_clipboard_data (window, paste_data);
+
+	gtk_selection_data_free (selection_data);
+}
+
+
+void
+fr_window_paste_selection (FrWindow *window,
+			   gboolean  from_sidebar)
+{
+	char *utf8_path, *utf8_old_path, *destination;
+	char *current_dir;
+
+	if (window->priv->list_mode == FR_WINDOW_LIST_MODE_FLAT)
+		return;
+
+	/**/
+
+	utf8_old_path = g_filename_to_utf8 (fr_window_get_current_location (window), -1, NULL, NULL, NULL);
+	utf8_path = _gtk_request_dialog_run (GTK_WINDOW (window),
+					       (GTK_DIALOG_DESTROY_WITH_PARENT
+						| GTK_DIALOG_MODAL),
+					       _("Paste Selection"),
+					       _("Destination folder"),
+					       utf8_old_path,
+					       1024,
+					       GTK_STOCK_CANCEL,
+					       GTK_STOCK_PASTE);
+	g_free (utf8_old_path);
+	if (utf8_path == NULL)
+		return;
+
+	destination = g_filename_from_utf8 (utf8_path, -1, NULL, NULL, NULL);
+	g_free (utf8_path);
+
+	if (destination[0] != '/')
+		current_dir = build_uri (fr_window_get_current_location (window), destination, NULL);
+	else
+		current_dir = g_strdup (destination);
+	g_free (destination);
+
+	fr_window_paste_selection_to (window, current_dir);
+
+	g_free (current_dir);
+}
+
+
+/* -- fr_window_open_files -- */
+
+
+void
+fr_window_open_files_with_command (FrWindow *window,
+				   GList    *file_list,
+				   char     *command)
+{
+	GAppInfo *app;
+	GError   *error = NULL;
+
+	app = g_app_info_create_from_commandline (command, NULL, G_APP_INFO_CREATE_NONE, &error);
+	if (error != NULL) {
+		_gtk_error_dialog_run (GTK_WINDOW (window),
+				       _("Could not perform the operation"),
+				       "%s",
+				       error->message);
+		g_clear_error (&error);
+		return;
+	}
+
+	fr_window_open_files_with_application (window, file_list, app);
+}
+
+
+void
+fr_window_open_files_with_application (FrWindow *window,
+				       GList    *file_list,
+				       GAppInfo *app)
+{
+	GList  *uris = NULL, *scan;
+	GError *error = NULL;
+
+	if (window->priv->activity_ref > 0)
+		return;
+
+	for (scan = file_list; scan; scan = scan->next)
+		uris = g_list_prepend (uris, g_filename_to_uri (scan->data, NULL, NULL));
+
+	if (! g_app_info_launch_uris (app, uris, NULL, &error)) {
+		_gtk_error_dialog_run (GTK_WINDOW (window),
+				       _("Could not perform the operation"),
+				       "%s",
+				       error->message);
+		g_clear_error (&error);
+	}
+	else {
+		char       *uri;
+		const char *mime_type;
+
+		uri = g_filename_to_uri (file_list->data, NULL, NULL);
+		mime_type = get_file_mime_type (uri, FALSE);
+		if (mime_type != NULL)
+			g_app_info_set_as_default_for_type (app, mime_type, NULL);
+		g_free (uri);
+	}
+
+	path_list_free (uris);
+}
+
+
+typedef struct {
+	FrWindow    *window;
+	GList       *file_list;
+	gboolean     ask_application;
+	CommandData *cdata;
+} OpenFilesData;
+
+
+static OpenFilesData*
+open_files_data_new (FrWindow *window,
+		     GList    *file_list,
+		     gboolean  ask_application)
+
+{
+	OpenFilesData *odata;
+	GList         *scan;
+
+	odata = g_new0 (OpenFilesData, 1);
+	odata->window = window;
+	odata->file_list = path_list_dup (file_list);
+	odata->ask_application = ask_application;
+	odata->cdata = g_new0 (CommandData, 1);
+	odata->cdata->temp_dir = get_temp_work_dir (NULL);
+	odata->cdata->file_list = NULL;
+	for (scan = file_list; scan; scan = scan->next) {
+		char *file = scan->data;
+		char *filename;
+
+		filename = g_strconcat (odata->cdata->temp_dir,
+					"/",
+					file,
+					NULL);
+		odata->cdata->file_list = g_list_prepend (odata->cdata->file_list, filename);
+	}
+
+	/* Add to CommandList so the cdata is released on exit. */
+	CommandList = g_list_prepend (CommandList, odata->cdata);
+
+	return odata;
+}
+
+
+static void
+open_files_data_free (OpenFilesData *odata)
+{
+	g_return_if_fail (odata != NULL);
+
+	path_list_free (odata->file_list);
+	g_free (odata);
+}
+
+
+void
+fr_window_update_dialog_closed (FrWindow *window)
+{
+	window->priv->update_dialog = NULL;
+}
+
+
+gboolean
+fr_window_update_files (FrWindow *window,
+			GList    *file_list)
+{
+	GList *scan;
+
+	if (window->priv->activity_ref > 0)
+		return FALSE;
+
+	if (window->archive->read_only)
+		return FALSE;
+
+	fr_process_clear (window->archive->process);
+
+	for (scan = file_list; scan; scan = scan->next) {
+		OpenFile *file = scan->data;
+		GList    *local_file_list;
+
+		local_file_list = g_list_append (NULL, file->path);
+		fr_archive_add (window->archive,
+				local_file_list,
+				file->temp_dir,
+				"/",
+				FALSE,
+				FALSE,
+				window->priv->password,
+				window->priv->encrypt_header,
+				window->priv->compression,
+				window->priv->volume_size);
+		g_list_free (local_file_list);
+	}
+
+	fr_process_start (window->archive->process);
+
+	return TRUE;
+}
+
+
+static void
+open_file_modified_cb (GFileMonitor     *monitor,
+		       GFile            *monitor_file,
+		       GFile            *other_file,
+		       GFileMonitorEvent event_type,
+		       gpointer          user_data)
+{
+	FrWindow *window = user_data;
+	char     *monitor_uri;
+	OpenFile *file;
+	GList    *scan;
+
+	if ((event_type != G_FILE_MONITOR_EVENT_CHANGED)
+	    && (event_type != G_FILE_MONITOR_EVENT_CREATED))
+	{
+		return;
+	}
+
+	monitor_uri = g_file_get_uri (monitor_file);
+	file = NULL;
+	for (scan = window->priv->open_files; scan; scan = scan->next) {
+		OpenFile *test = scan->data;
+		if (uricmp (test->extracted_uri, monitor_uri) == 0) {
+			file = test;
+			break;
+		}
+	}
+	g_free (monitor_uri);
+
+	g_return_if_fail (file != NULL);
+
+	if (window->priv->update_dialog == NULL)
+		window->priv->update_dialog = dlg_update (window);
+	dlg_update_add_file (window->priv->update_dialog, file);
+}
+
+
+static void
+fr_window_monitor_open_file (FrWindow *window,
+			     OpenFile *file)
+{
+	GFile *f;
+
+	window->priv->open_files = g_list_prepend (window->priv->open_files, file);
+	f = g_file_new_for_uri (file->extracted_uri);
+	file->monitor = g_file_monitor_file (f, 0, NULL, NULL);
+	g_signal_connect (file->monitor,
+			  "changed",
+			  G_CALLBACK (open_file_modified_cb),
+			  window);
+	g_object_unref (f);
+}
+
+
+static void
+monitor_extracted_files (OpenFilesData *odata)
+{
+	FrWindow *window = odata->window;
+	GList    *scan1, *scan2;
+
+	for (scan1 = odata->file_list, scan2 = odata->cdata->file_list;
+	     scan1 && scan2;
+	     scan1 = scan1->next, scan2 = scan2->next)
+	{
+		OpenFile   *ofile;
+		const char *file = scan1->data;
+		const char *extracted_path = scan2->data;
+
+		ofile = open_file_new (file, extracted_path, odata->cdata->temp_dir);
+		if (ofile != NULL)
+			fr_window_monitor_open_file (window, ofile);
+	}
+}
+
+
+static gboolean
+fr_window_open_extracted_files (OpenFilesData *odata)
+{
+	GList      *file_list = odata->cdata->file_list;
+	gboolean    result = FALSE;
+	const char *first_file;
+	const char *first_mime_type;
+	GAppInfo   *app;
+	GList      *files_to_open = NULL;
+	GError     *error = NULL;
+
+	g_return_val_if_fail (file_list != NULL, FALSE);
+
+	first_file = (char*) file_list->data;
+	if (first_file == NULL)
+		return FALSE;
+
+	if (! odata->window->archive->read_only)
+		monitor_extracted_files (odata);
+
+	if (odata->ask_application) {
+		dlg_open_with (odata->window, file_list);
+		return FALSE;
+	}
+
+	first_mime_type = get_file_mime_type_for_path (first_file, FALSE);
+	app = g_app_info_get_default_for_type (first_mime_type, FALSE);
+
+	if (app == NULL) {
+		dlg_open_with (odata->window, file_list);
+		return FALSE;
+	}
+
+	files_to_open = g_list_append (files_to_open, g_filename_to_uri (first_file, NULL, NULL));
+
+	if (g_app_info_supports_files (app)) {
+		GList *scan;
+
+		for (scan = file_list->next; scan; scan = scan->next) {
+			const char *path = scan->data;
+			const char *mime_type;
+
+			mime_type = get_file_mime_type_for_path (path, FALSE);
+			if (mime_type == NULL)
+				continue;
+
+			if (strcmp (mime_type, first_mime_type) == 0) {
+				files_to_open = g_list_append (files_to_open, g_filename_to_uri (path, NULL, NULL));
+			}
+			else {
+				GAppInfo *app2;
+
+				app2 = g_app_info_get_default_for_type (mime_type, FALSE);
+				if (g_app_info_equal (app, app2))
+					files_to_open = g_list_append (files_to_open, g_filename_to_uri (path, NULL, NULL));
+				g_object_unref (app2);
+			}
+		}
+	}
+
+	result = g_app_info_launch_uris (app, files_to_open, NULL, &error);
+	if (! result) {
+		_gtk_error_dialog_run (GTK_WINDOW (odata->window),
+				       _("Could not perform the operation"),
+				       "%s",
+				       error->message);
+		g_clear_error (&error);
+	}
+
+	g_object_unref (app);
+	path_list_free (files_to_open);
+
+	return result;
+}
+
+
+static void
+fr_window_open_files__extract_done_cb (FrArchive   *archive,
+				       FrAction     action,
+				       FrProcError *error,
+				       gpointer     callback_data)
+{
+	OpenFilesData *odata = callback_data;
+
+	g_signal_handlers_disconnect_matched (G_OBJECT (archive),
+					      G_SIGNAL_MATCH_DATA,
+					      0,
+					      0, NULL,
+					      0,
+					      odata);
+
+	if (error->type == FR_PROC_ERROR_NONE)
+		fr_window_open_extracted_files (odata);
+}
+
+
+void
+fr_window_open_files (FrWindow *window,
+		      GList    *file_list,
+		      gboolean  ask_application)
+{
+	OpenFilesData *odata;
+
+	if (window->priv->activity_ref > 0)
+		return;
+
+	odata = open_files_data_new (window, file_list, ask_application);
+	fr_window_set_current_batch_action (window,
+					    FR_BATCH_ACTION_OPEN_FILES,
+					    odata,
+					    (GFreeFunc) open_files_data_free);
+
+	g_signal_connect (G_OBJECT (window->archive),
+			  "done",
+			  G_CALLBACK (fr_window_open_files__extract_done_cb),
+			  odata);
+
+	fr_process_clear (window->archive->process);
+	fr_archive_extract_to_local (window->archive,
+				     odata->file_list,
+				     odata->cdata->temp_dir,
+				     NULL,
+				     FALSE,
+				     TRUE,
+				     FALSE,
+				     window->priv->password);
+	fr_process_start (window->archive->process);
+}
+
+
+/**/
+
+
+static char*
+get_default_dir (const char *dir)
+{
+	if (! is_temp_dir (dir))
+		return g_strdup (dir);
+	else
+		return NULL;
+}
+
+
+void
+fr_window_set_open_default_dir (FrWindow   *window,
+				const char *default_dir)
+{
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (default_dir != NULL);
+
+	if (window->priv->open_default_dir != NULL)
+		g_free (window->priv->open_default_dir);
+	window->priv->open_default_dir = get_default_dir (default_dir);
+}
+
+
+const char *
+fr_window_get_open_default_dir (FrWindow *window)
+{
+	if (window->priv->open_default_dir == NULL)
+		return get_home_uri ();
+	else
+		return  window->priv->open_default_dir;
+}
+
+
+void
+fr_window_set_add_default_dir (FrWindow   *window,
+			       const char *default_dir)
+{
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (default_dir != NULL);
+
+	if (window->priv->add_default_dir != NULL)
+		g_free (window->priv->add_default_dir);
+	window->priv->add_default_dir = get_default_dir (default_dir);
+}
+
+
+const char *
+fr_window_get_add_default_dir (FrWindow *window)
+{
+	if (window->priv->add_default_dir == NULL)
+		return get_home_uri ();
+	else
+		return  window->priv->add_default_dir;
+}
+
+
+void
+fr_window_set_extract_default_dir (FrWindow   *window,
+				   const char *default_dir,
+				   gboolean    freeze)
+{
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (default_dir != NULL);
+
+	/* do not change this dir while it's used by the non-interactive
+	 * extraction operation. */
+	if (window->priv->extract_interact_use_default_dir)
+		return;
+
+	window->priv->extract_interact_use_default_dir = freeze;
+
+	if (window->priv->extract_default_dir != NULL)
+		g_free (window->priv->extract_default_dir);
+	window->priv->extract_default_dir = get_default_dir (default_dir);
+}
+
+
+const char *
+fr_window_get_extract_default_dir (FrWindow *window)
+{
+	if (window->priv->extract_default_dir == NULL)
+		return get_home_uri ();
+	else
+		return  window->priv->extract_default_dir;
+}
+
+
+void
+fr_window_set_default_dir (FrWindow   *window,
+			   const char *default_dir,
+			   gboolean    freeze)
+{
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (default_dir != NULL);
+
+	window->priv->freeze_default_dir = freeze;
+
+	fr_window_set_open_default_dir (window, default_dir);
+	fr_window_set_add_default_dir (window, default_dir);
+	fr_window_set_extract_default_dir (window, default_dir, FALSE);
+}
+
+
+void
+fr_window_update_columns_visibility (FrWindow *window)
+{
+	GtkTreeView       *tree_view = GTK_TREE_VIEW (window->priv->list_view);
+	GtkTreeViewColumn *column;
+
+	column = gtk_tree_view_get_column (tree_view, 1);
+	gtk_tree_view_column_set_visible (column, eel_mateconf_get_boolean (PREF_LIST_SHOW_SIZE, TRUE));
+
+	column = gtk_tree_view_get_column (tree_view, 2);
+	gtk_tree_view_column_set_visible (column, eel_mateconf_get_boolean (PREF_LIST_SHOW_TYPE, TRUE));
+
+	column = gtk_tree_view_get_column (tree_view, 3);
+	gtk_tree_view_column_set_visible (column, eel_mateconf_get_boolean (PREF_LIST_SHOW_TIME, TRUE));
+
+	column = gtk_tree_view_get_column (tree_view, 4);
+	gtk_tree_view_column_set_visible (column, eel_mateconf_get_boolean (PREF_LIST_SHOW_PATH, TRUE));
+}
+
+
+void
+fr_window_set_toolbar_visibility (FrWindow *window,
+				  gboolean  visible)
+{
+	g_return_if_fail (window != NULL);
+
+	if (visible)
+		gtk_widget_show (window->priv->toolbar);
+	else
+		gtk_widget_hide (window->priv->toolbar);
+
+	set_active (window, "ViewToolbar", visible);
+}
+
+
+void
+fr_window_set_statusbar_visibility  (FrWindow *window,
+				     gboolean  visible)
+{
+	g_return_if_fail (window != NULL);
+
+	if (visible)
+		gtk_widget_show (window->priv->statusbar);
+	else
+		gtk_widget_hide (window->priv->statusbar);
+
+	set_active (window, "ViewStatusbar", visible);
+}
+
+
+void
+fr_window_set_folders_visibility (FrWindow   *window,
+				  gboolean    value)
+{
+	g_return_if_fail (window != NULL);
+
+	window->priv->view_folders = value;
+	fr_window_update_dir_tree (window);
+
+	set_active (window, "ViewFolders", window->priv->view_folders);
+}
+
+
+/* -- batch mode procedures -- */
+
+
+static void fr_window_exec_current_batch_action (FrWindow *window);
+
+
+static void
+fr_window_exec_batch_action (FrWindow      *window,
+			     FRBatchAction *action)
+{
+	ExtractData   *edata;
+	RenameData    *rdata;
+	OpenFilesData *odata;
+	SaveAsData    *sdata;
+
+	switch (action->type) {
+	case FR_BATCH_ACTION_LOAD:
+		debug (DEBUG_INFO, "[BATCH] LOAD\n");
+
+		if (! uri_exists ((char*) action->data))
+			fr_window_archive_new (window, (char*) action->data);
+		else
+			fr_window_archive_open (window, (char*) action->data, GTK_WINDOW (window));
+		break;
+
+	case FR_BATCH_ACTION_ADD:
+		debug (DEBUG_INFO, "[BATCH] ADD\n");
+
+		fr_window_archive_add_dropped_items (window, (GList*) action->data, FALSE);
+		break;
+
+	case FR_BATCH_ACTION_OPEN:
+		debug (DEBUG_INFO, "[BATCH] OPEN\n");
+
+		fr_window_push_message (window, _("Add files to an archive"));
+		dlg_batch_add_files (window, (GList*) action->data);
+		break;
+
+	case FR_BATCH_ACTION_EXTRACT:
+		debug (DEBUG_INFO, "[BATCH] EXTRACT\n");
+
+		edata = action->data;
+		fr_window_archive_extract (window,
+					   edata->file_list,
+					   edata->extract_to_dir,
+					   edata->base_dir,
+					   edata->skip_older,
+					   edata->overwrite,
+					   edata->junk_paths,
+					   TRUE);
+		break;
+
+	case FR_BATCH_ACTION_EXTRACT_HERE:
+		debug (DEBUG_INFO, "[BATCH] EXTRACT HERE\n");
+
+		edata = action->data;
+		fr_window_archive_extract_here (window,
+						FALSE,
+						TRUE,
+						FALSE);
+		break;
+
+	case FR_BATCH_ACTION_EXTRACT_INTERACT:
+		debug (DEBUG_INFO, "[BATCH] EXTRACT_INTERACT\n");
+
+		if (window->priv->extract_interact_use_default_dir
+		    && (window->priv->extract_default_dir != NULL))
+		{
+			fr_window_archive_extract (window,
+						   NULL,
+						   window->priv->extract_default_dir,
+						   NULL,
+						   FALSE,
+						   TRUE,
+						   FALSE,
+						   TRUE);
+		}
+		else {
+			fr_window_push_message (window, _("Extract archive"));
+			dlg_extract (NULL, window);
+		}
+		break;
+
+	case FR_BATCH_ACTION_RENAME:
+		debug (DEBUG_INFO, "[BATCH] RENAME\n");
+
+		rdata = action->data;
+		rename_selection (window,
+				  rdata->path_to_rename,
+				  rdata->old_name,
+				  rdata->new_name,
+				  rdata->current_dir,
+				  rdata->is_dir,
+				  rdata->dir_in_archive,
+				  rdata->original_path);
+		break;
+
+	case FR_BATCH_ACTION_PASTE:
+		debug (DEBUG_INFO, "[BATCH] PASTE\n");
+
+		fr_window_paste_from_clipboard_data (window, (FrClipboardData*) action->data);
+		break;
+
+	case FR_BATCH_ACTION_OPEN_FILES:
+		debug (DEBUG_INFO, "[BATCH] OPEN FILES\n");
+
+		odata = action->data;
+		fr_window_open_files (window, odata->file_list, odata->ask_application);
+		break;
+
+	case FR_BATCH_ACTION_SAVE_AS:
+		debug (DEBUG_INFO, "[BATCH] SAVE_AS\n");
+
+		sdata = action->data;
+		fr_window_archive_save_as (window,
+					   sdata->uri,
+					   sdata->password,
+					   sdata->encrypt_header,
+					   sdata->volume_size);
+		break;
+
+	case FR_BATCH_ACTION_TEST:
+		debug (DEBUG_INFO, "[BATCH] TEST\n");
+
+		fr_window_archive_test (window);
+		break;
+
+	case FR_BATCH_ACTION_CLOSE:
+		debug (DEBUG_INFO, "[BATCH] CLOSE\n");
+
+		fr_window_archive_close (window);
+		fr_window_exec_next_batch_action (window);
+		break;
+
+	case FR_BATCH_ACTION_QUIT:
+		debug (DEBUG_INFO, "[BATCH] QUIT\n");
+
+		gtk_widget_destroy (GTK_WIDGET (window));
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+void
+fr_window_reset_current_batch_action (FrWindow *window)
+{
+	FRBatchAction *adata = &window->priv->current_batch_action;
+
+	if ((adata->data != NULL) && (adata->free_func != NULL))
+		(*adata->free_func) (adata->data);
+	adata->type = FR_BATCH_ACTION_NONE;
+	adata->data = NULL;
+	adata->free_func = NULL;
+}
+
+
+void
+fr_window_set_current_batch_action (FrWindow          *window,
+				    FrBatchActionType  action,
+				    void              *data,
+				    GFreeFunc          free_func)
+{
+	FRBatchAction *adata = &window->priv->current_batch_action;
+
+	fr_window_reset_current_batch_action (window);
+
+	adata->type = action;
+	adata->data = data;
+	adata->free_func = free_func;
+}
+
+
+void
+fr_window_restart_current_batch_action (FrWindow *window)
+{
+	fr_window_exec_batch_action (window, &window->priv->current_batch_action);
+}
+
+
+void
+fr_window_append_batch_action (FrWindow          *window,
+			       FrBatchActionType  action,
+			       void              *data,
+			       GFreeFunc          free_func)
+{
+	FRBatchAction *a_desc;
+
+	g_return_if_fail (window != NULL);
+
+	a_desc = g_new0 (FRBatchAction, 1);
+	a_desc->type = action;
+	a_desc->data = data;
+	a_desc->free_func = free_func;
+
+	window->priv->batch_action_list = g_list_append (window->priv->batch_action_list, a_desc);
+}
+
+
+static void
+fr_window_exec_current_batch_action (FrWindow *window)
+{
+	FRBatchAction *action;
+
+	if (window->priv->batch_action == NULL) {
+		window->priv->batch_mode = FALSE;
+		return;
+	}
+	action = (FRBatchAction *) window->priv->batch_action->data;
+	fr_window_exec_batch_action (window, action);
+}
+
+
+static void
+fr_window_exec_next_batch_action (FrWindow *window)
+{
+	if (window->priv->batch_action != NULL)
+		window->priv->batch_action = g_list_next (window->priv->batch_action);
+	else
+		window->priv->batch_action = window->priv->batch_action_list;
+	fr_window_exec_current_batch_action (window);
+}
+
+
+void
+fr_window_start_batch (FrWindow *window)
+{
+	g_return_if_fail (window != NULL);
+
+	if (window->priv->batch_mode)
+		return;
+
+	if (window->priv->batch_action_list == NULL)
+		return;
+
+	window->priv->batch_mode = TRUE;
+	window->priv->batch_action = window->priv->batch_action_list;
+	window->archive->can_create_compressed_file = window->priv->batch_adding_one_file;
+
+	fr_window_exec_current_batch_action (window);
+}
+
+
+void
+fr_window_stop_batch (FrWindow *window)
+{
+	if (! window->priv->non_interactive)
+		return;
+
+	window->priv->extract_interact_use_default_dir = FALSE;
+	window->archive->can_create_compressed_file = FALSE;
+
+	if (window->priv->batch_mode) {
+		if (! window->priv->showing_error_dialog) {
+			gtk_widget_destroy (GTK_WIDGET (window));
+			return;
+		}
+	}
+	else {
+		gtk_window_present (GTK_WINDOW (window));
+		fr_window_archive_close (window);
+	}
+
+	window->priv->batch_mode = FALSE;
+}
+
+
+void
+fr_window_resume_batch (FrWindow *window)
+{
+	fr_window_exec_current_batch_action (window);
+}
+
+
+gboolean
+fr_window_is_batch_mode (FrWindow *window)
+{
+	return window->priv->batch_mode;
+}
+
+
+void
+fr_window_new_batch (FrWindow *window)
+{
+	fr_window_free_batch_data (window);
+	window->priv->non_interactive = TRUE;
+}
+
+
+void
+fr_window_set_batch__extract_here (FrWindow   *window,
+				   const char *filename)
+{
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (filename != NULL);
+
+	fr_window_append_batch_action (window,
+				       FR_BATCH_ACTION_LOAD,
+				       g_strdup (filename),
+				       (GFreeFunc) g_free);
+	fr_window_append_batch_action (window,
+				       FR_BATCH_ACTION_EXTRACT_HERE,
+				       extract_to_data_new (NULL),
+				       (GFreeFunc) extract_data_free);
+	fr_window_append_batch_action (window,
+				       FR_BATCH_ACTION_CLOSE,
+				       NULL,
+				       NULL);
+}
+
+
+void
+fr_window_set_batch__extract (FrWindow   *window,
+			      const char *filename,
+			      const char *dest_dir)
+{
+	g_return_if_fail (window != NULL);
+	g_return_if_fail (filename != NULL);
+
+	fr_window_append_batch_action (window,
+				       FR_BATCH_ACTION_LOAD,
+				       g_strdup (filename),
+				       (GFreeFunc) g_free);
+	if (dest_dir != NULL)
+		fr_window_append_batch_action (window,
+					       FR_BATCH_ACTION_EXTRACT,
+					       extract_to_data_new (dest_dir),
+					       (GFreeFunc) extract_data_free);
+	else
+		fr_window_append_batch_action (window,
+					       FR_BATCH_ACTION_EXTRACT_INTERACT,
+					       NULL,
+					       NULL);
+	fr_window_append_batch_action (window,
+				       FR_BATCH_ACTION_CLOSE,
+				       NULL,
+				       NULL);
+}
+
+
+void
+fr_window_set_batch__add (FrWindow   *window,
+			  const char *archive,
+			  GList      *file_list)
+{
+	window->priv->batch_adding_one_file = (file_list->next == NULL) && (uri_is_file (file_list->data));
+
+	if (archive != NULL)
+		fr_window_append_batch_action (window,
+					       FR_BATCH_ACTION_LOAD,
+					       g_strdup (archive),
+					       (GFreeFunc) g_free);
+	else
+		fr_window_append_batch_action (window,
+					       FR_BATCH_ACTION_OPEN,
+					       file_list,
+					       NULL);
+	fr_window_append_batch_action (window,
+				       FR_BATCH_ACTION_ADD,
+				       file_list,
+				       NULL);
+	fr_window_append_batch_action (window,
+				       FR_BATCH_ACTION_CLOSE,
+				       NULL,
+				       NULL);
+}