summaryrefslogtreecommitdiff
path: root/src/fr-window.c
diff options
context:
space:
mode:
authorPerberos <[email protected]>2011-11-09 22:53:33 -0300
committerPerberos <[email protected]>2011-11-09 22:53:33 -0300
commit70438138096a47b2505ac55634cd94947ce378b6 (patch)
treee45e49dda10a71616466500a4ab65d1c54b5f6c1 /src/fr-window.c
downloadengrampa-70438138096a47b2505ac55634cd94947ce378b6.tar.bz2
engrampa-70438138096a47b2505ac55634cd94947ce378b6.tar.xz
initial
Diffstat (limited to 'src/fr-window.c')
-rw-r--r--src/fr-window.c8855
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);
+}