X-Git-Url: https://www.fi.muni.cz/~kas/git//home/kas/public_html/git/?a=blobdiff_plain;f=shell%2Fev-window.c;h=f950c9b650c103fb9739410909eee90d3ac7ab56;hb=b1cf0ae66e5e198507789848dda8cc1f7c5716fb;hp=d53d818720eff8b14497c6e7fd1e5bf85b9de43c;hpb=76f0af54740d46b8f35712234c027f77920d7c0f;p=evince.git

diff --git a/shell/ev-window.c b/shell/ev-window.c
index d53d8187..f950c9b6 100644
--- a/shell/ev-window.c
+++ b/shell/ev-window.c
@@ -43,7 +43,9 @@
 #else
 #include <gtk/gtkprintunixdialog.h>
 #endif
+#ifdef WITH_GCONF
 #include <gconf/gconf-client.h>
+#endif
 
 #include "egg-editable-toolbar.h"
 #include "egg-toolbar-editor.h"
@@ -61,6 +63,7 @@
 #include "ev-document-images.h"
 #include "ev-document-links.h"
 #include "ev-document-thumbnails.h"
+#include "ev-document-type-builtins.h"
 #include "ev-file-exporter.h"
 #include "ev-file-helpers.h"
 #include "ev-file-monitor.h"
@@ -86,6 +89,7 @@
 #include "ev-utils.h"
 #include "ev-keyring.h"
 #include "ev-view.h"
+#include "ev-view-type-builtins.h"
 #include "ev-window.h"
 #include "ev-window-title.h"
 #include "ev-print-operation.h"
@@ -115,6 +119,12 @@ typedef enum {
 	EV_CHROME_NORMAL	= EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
 } EvChrome;
 
+typedef enum {
+	EV_SAVE_DOCUMENT,
+	EV_SAVE_ATTACHMENT,
+	EV_SAVE_IMAGE
+} EvSaveType;
+
 struct _EvWindowPrivate {
 	/* UI */
 	EvChrome chrome;
@@ -135,6 +145,10 @@ struct _EvWindowPrivate {
 	GtkWidget *sidebar_attachments;
 	GtkWidget *sidebar_layers;
 
+	/* Progress Messages */
+	guint progress_idle;
+	GCancellable *progress_cancellable;
+
 	/* Dialogs */
 	GtkWidget *properties;
 	GtkWidget *print_dialog;
@@ -171,7 +185,6 @@ struct _EvWindowPrivate {
 	char *uri;
 	glong uri_mtime;
 	char *local_uri;
-	EvLinkDest *dest;
 	gboolean unlink_temp_file;
 	gboolean in_reload;
 	EvFileMonitor *monitor;
@@ -183,6 +196,11 @@ struct _EvWindowPrivate {
 	EvWindowPageMode page_mode;
 	EvWindowTitle *title;
 
+	/* Load params */
+	EvLinkDest       *dest;
+	gchar            *search_string;
+	EvWindowRunMode   window_mode;
+
 	EvJob            *load_job;
 	EvJob            *reload_job;
 	EvJob            *thumbnail_job;
@@ -324,8 +342,9 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 	gboolean can_get_text = FALSE;
 	gboolean has_pages = FALSE;
 	gboolean can_find = FALSE;
-
+#ifdef WITH_GCONF
 	GConfClient *client;
+#endif
 
 	if (document) {
 		has_document = TRUE;
@@ -348,10 +367,12 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 		can_find = TRUE;
 	}
 
+#ifdef WITH_GCONF
 	client = gconf_client_get_default ();
 	override_restrictions = gconf_client_get_bool (client, 
 						       GCONF_OVERRIDE_RESTRICTIONS, 
 						       NULL);
+#endif
 	if (!override_restrictions && info && info->fields_mask & EV_DOCUMENT_INFO_PERMISSIONS) {
 		ok_to_print = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_PRINT);
 		ok_to_copy = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_COPY);
@@ -360,7 +381,7 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 	if (has_document && !EV_IS_FILE_EXPORTER(document))
 		ok_to_print = FALSE;
 
-	
+#ifdef WITH_GCONF
 	if (gconf_client_get_bool (client, GCONF_LOCKDOWN_SAVE, NULL)) {
 		ok_to_copy = FALSE;
 	}
@@ -370,6 +391,7 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window)
 	}
 
 	g_object_unref (client);
+#endif
 
 	/* File menu */
 	ev_window_set_action_sensitive (ev_window, "FileOpenCopy", has_document);
@@ -865,29 +887,6 @@ update_document_mode (EvWindow *window, EvDocumentMode mode)
 	}
 }
 
-static void
-setup_document_from_metadata (EvWindow *window)
-{
-	char *uri = window->priv->uri;
-	GValue page = { 0, };
-	gint n_pages;
-	gint new_page;
-
-	/* View the previously shown page, but make sure to not open a document on
-	 * the last page, since closing it on the last page most likely means the
-	 * user was finished reading the document. In that case, reopening should
-	 * show the first page. */
-	if (uri && ev_metadata_manager_get (uri, "page", &page, TRUE)) {
-		n_pages = ev_page_cache_get_n_pages (window->priv->page_cache);
-		new_page = CLAMP (g_value_get_int (&page), 0, n_pages - 1);
-		if (!window->priv->in_reload && new_page == n_pages - 1)
-			new_page = 0;
-		ev_page_cache_set_current_page (window->priv->page_cache,
-						new_page);
-		g_value_unset (&page);
-	}
-}
-
 static void
 setup_chrome_from_metadata (EvWindow *window)
 {
@@ -903,17 +902,18 @@ setup_chrome_from_metadata (EvWindow *window)
 }
 
 static void
-setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
+setup_sidebar_from_metadata (EvWindow *window)
 {
-	char *uri = window->priv->uri;
-	GtkWidget *sidebar = window->priv->sidebar;
-	GtkWidget *links = window->priv->sidebar_links;
-	GtkWidget *thumbs = window->priv->sidebar_thumbs;
-	GtkWidget *attachments = window->priv->sidebar_attachments;
-	GtkWidget *layers = window->priv->sidebar_layers;
-	GValue sidebar_size = { 0, };
-	GValue sidebar_page = { 0, };
-	GValue sidebar_visibility = { 0, };
+	gchar      *uri = window->priv->uri;
+	EvDocument *document = window->priv->document;
+	GtkWidget  *sidebar = window->priv->sidebar;
+	GtkWidget  *links = window->priv->sidebar_links;
+	GtkWidget  *thumbs = window->priv->sidebar_thumbs;
+	GtkWidget  *attachments = window->priv->sidebar_attachments;
+	GtkWidget  *layers = window->priv->sidebar_layers;
+	GValue      sidebar_size = { 0, };
+	GValue      sidebar_page = { 0, };
+	GValue      sidebar_visibility = { 0, };
 
 	if (ev_metadata_manager_get (uri, "sidebar_size", &sidebar_size, FALSE)) {
 		gtk_paned_set_position (GTK_PANED (window->priv->hpaned),
@@ -954,57 +954,43 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document)
 }
 
 static void
-setup_size_from_metadata (EvWindow *window)
+setup_document_from_metadata (EvWindow *window)
 {
-	char *uri = window->priv->uri;
+	gchar *uri = window->priv->uri;
+	GValue page = { 0, };
 	GValue width = { 0, };
 	GValue height = { 0, };
 	GValue width_ratio = { 0, };
 	GValue height_ratio = { 0, };
-	GValue maximized = { 0, };
-	GValue x = { 0, };
-	GValue y = { 0, };
 
-	if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
-		if (g_value_get_boolean (&maximized)) {
-			gtk_window_maximize (GTK_WINDOW (window));
-			g_value_unset (&maximized);
-			return;
-		} else {
-			gtk_window_unmaximize (GTK_WINDOW (window));
-		}
-		g_value_unset (&maximized);
+	/* View the previously shown page, but make sure to not open a document on
+	 * the last page, since closing it on the last page most likely means the
+	 * user was finished reading the document. In that case, reopening should
+	 * show the first page. */
+	if (uri && ev_metadata_manager_get (uri, "page", &page, TRUE)) {
+		gint n_pages;
+		gint new_page;
+		
+		n_pages = ev_page_cache_get_n_pages (window->priv->page_cache);
+		new_page = CLAMP (g_value_get_int (&page), 0, n_pages - 1);
+		ev_page_cache_set_current_page (window->priv->page_cache,
+						new_page);
+		g_value_unset (&page);
 	}
 
-	if (ev_metadata_manager_get (uri, "window_x", &x, TRUE) &&
-	    ev_metadata_manager_get (uri, "window_y", &y, TRUE)) {
-		gtk_window_move (GTK_WINDOW (window), g_value_get_int (&x),
-				 g_value_get_int (&y));
-	        g_value_unset (&x);
-	        g_value_unset (&y);
-	}
+	setup_sidebar_from_metadata (window);
 
-        if (ev_metadata_manager_get (uri, "window_width", &width, TRUE) &&
-	    ev_metadata_manager_get (uri, "window_height", &height, TRUE)) {
-		gtk_window_resize (GTK_WINDOW (window),
-				   g_value_get_int (&width),
-				   g_value_get_int (&height));
-	    	g_value_unset (&width);
-		g_value_unset (&height);
-		return;
-	}
+	if (ev_metadata_manager_get (uri, "window_width", &width, TRUE) &&
+	    ev_metadata_manager_get (uri, "window_height", &height, TRUE))
+		return; /* size was already set in setup_size_from_metadata */
 
-        if (window->priv->page_cache &&
-    	    ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
+	if (ev_metadata_manager_get (uri, "window_width_ratio", &width_ratio, FALSE) &&
 	    ev_metadata_manager_get (uri, "window_height_ratio", &height_ratio, FALSE)) {
-		
-		gint document_width;
-		gint document_height;
-		
+		gint       document_width;
+		gint       document_height;
 		GdkScreen *screen;
-		
-		gint request_width;
-		gint request_height;
+		gint       request_width;
+		gint       request_height;
 
 		ev_page_cache_get_max_width (window->priv->page_cache, 
 					     0, 1.0,
@@ -1032,34 +1018,62 @@ setup_size_from_metadata (EvWindow *window)
 }
 
 static void
-setup_view_from_metadata (EvWindow *window)
+setup_size_from_metadata (EvWindow *window)
 {
-	EvView *view = EV_VIEW (window->priv->view);
 	char *uri = window->priv->uri;
-	GEnumValue *enum_value;
-	GValue sizing_mode = { 0, };
-	GValue zoom = { 0, };
-	GValue continuous = { 0, };
-	GValue dual_page = { 0, };
-	GValue presentation = { 0, };
-	GValue fullscreen = { 0, };
-	GValue rotation = { 0, };
+	GValue width = { 0, };
+	GValue height = { 0, };
 	GValue maximized = { 0, };
+	GValue x = { 0, };
+	GValue y = { 0, };
 
-	/* Maximized */
 	if (ev_metadata_manager_get (uri, "window_maximized", &maximized, FALSE)) {
 		if (g_value_get_boolean (&maximized)) {
 			gtk_window_maximize (GTK_WINDOW (window));
+			g_value_unset (&maximized);
+			return;
 		} else {
 			gtk_window_unmaximize (GTK_WINDOW (window));
 		}
 		g_value_unset (&maximized);
 	}
 
+	if (ev_metadata_manager_get (uri, "window_x", &x, TRUE) &&
+	    ev_metadata_manager_get (uri, "window_y", &y, TRUE)) {
+		gtk_window_move (GTK_WINDOW (window), g_value_get_int (&x),
+				 g_value_get_int (&y));
+	        g_value_unset (&x);
+	        g_value_unset (&y);
+	}
+
+        if (ev_metadata_manager_get (uri, "window_width", &width, TRUE) &&
+	    ev_metadata_manager_get (uri, "window_height", &height, TRUE)) {
+		gtk_window_resize (GTK_WINDOW (window),
+				   g_value_get_int (&width),
+				   g_value_get_int (&height));
+	    	g_value_unset (&width);
+		g_value_unset (&height);
+	}
+}
+
+static void
+setup_view_from_metadata (EvWindow *window)
+{
+	EvView *view = EV_VIEW (window->priv->view);
+	gchar *uri = window->priv->uri;
+	GEnumValue *enum_value;
+	GValue sizing_mode = { 0, };
+	GValue zoom = { 0, };
+	GValue continuous = { 0, };
+	GValue dual_page = { 0, };
+	GValue presentation = { 0, };
+	GValue fullscreen = { 0, };
+	GValue rotation = { 0, };
+
 	/* Sizing mode */
 	if (ev_metadata_manager_get (uri, "sizing_mode", &sizing_mode, FALSE)) {
 		enum_value = g_enum_get_value_by_nick
-			(EV_SIZING_MODE_CLASS, g_value_get_string (&sizing_mode));
+			(g_type_class_peek (EV_TYPE_SIZING_MODE), g_value_get_string (&sizing_mode));
 		g_value_unset (&sizing_mode);
 		ev_view_set_sizing_mode (view, enum_value->value);
 	}
@@ -1234,10 +1248,6 @@ ev_window_set_document (EvWindow *ev_window, EvDocument *document)
 	g_signal_connect (ev_window->priv->page_cache, "history-changed",
 			  G_CALLBACK (history_changed_cb), ev_window);
 
-	setup_size_from_metadata (ev_window);
-	setup_sidebar_from_metadata (ev_window, document);
-	setup_document_from_metadata (ev_window);
-
 	if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) {
 		ev_view_set_document (view, document);
 	} else {
@@ -1357,8 +1367,10 @@ ev_window_load_job_cb (EvJob *job,
 	/* Success! */
 	if (!ev_job_is_failed (job)) {
 		ev_window_set_document (ev_window, document);
+
+		setup_document_from_metadata (ev_window);
 		
-		if (job_load->mode != EV_WINDOW_MODE_PREVIEW) {
+		if (ev_window->priv->window_mode != EV_WINDOW_MODE_PREVIEW) {
 			setup_view_from_metadata (ev_window);
 		}
 
@@ -1378,17 +1390,23 @@ ev_window_load_job_cb (EvJob *job,
 						  flags);
 		}
 
-		if (job_load->dest) {
+		if (ev_window->priv->dest) {
 			EvLink *link;
 			EvLinkAction *link_action;
 	
-			link_action = ev_link_action_new_dest (g_object_ref (job_load->dest));
+			link_action = ev_link_action_new_dest (ev_window->priv->dest);
 			link = ev_link_new (NULL, link_action);
 			ev_view_handle_link (EV_VIEW (ev_window->priv->view), link);
 		    	g_object_unref (link);
+
+			/* Already unrefed by ev_link_action
+			 * FIXME: link action should inc dest ref counting
+			 * or not unref it at all
+			 */
+			ev_window->priv->dest = NULL;
 		}
 
-		switch (job_load->mode) {
+		switch (ev_window->priv->window_mode) {
 		        case EV_WINDOW_MODE_FULLSCREEN:
 				ev_window_run_fullscreen (ev_window);
 				break;
@@ -1402,15 +1420,18 @@ ev_window_load_job_cb (EvJob *job,
 				break;
 		}
 
-		if (job_load->search_string && EV_IS_DOCUMENT_FIND (document)) {
+		if (ev_window->priv->search_string && EV_IS_DOCUMENT_FIND (document)) {
 			ev_window_cmd_edit_find (NULL, ev_window);
 			egg_find_bar_set_search_string (EGG_FIND_BAR (ev_window->priv->find_bar),
-							job_load->search_string);
+							ev_window->priv->search_string);
 		}
 
+		g_free (ev_window->priv->search_string);
+		ev_window->priv->search_string = NULL;
+
 		/* Create a monitor for the document */
 		ev_window->priv->monitor = ev_file_monitor_new (ev_window->priv->uri);
-		g_signal_connect_swapped (G_OBJECT (ev_window->priv->monitor), "changed",
+		g_signal_connect_swapped (ev_window->priv->monitor, "changed",
 					  G_CALLBACK (ev_window_document_changed),
 					  ev_window);
 		
@@ -1418,8 +1439,7 @@ ev_window_load_job_cb (EvJob *job,
 		return;
 	}
 
-	if (job->error->domain == EV_DOCUMENT_ERROR &&
-	    job->error->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
+	if (g_error_matches (job->error, EV_DOCUMENT_ERROR, EV_DOCUMENT_ERROR_ENCRYPTED)) {
 		gchar *password;
 		
 		setup_view_from_metadata (ev_window);
@@ -1466,15 +1486,27 @@ ev_window_reload_job_cb (EvJob    *job,
 			 EvWindow *ev_window)
 {
 	GtkWidget *widget;
+	gint       page;
 
 	if (ev_job_is_failed (job)) {
 		ev_window_clear_reload_job (ev_window);
 		ev_window->priv->in_reload = FALSE;
+		g_object_unref (ev_window->priv->dest);
+		ev_window->priv->dest = NULL;
+		
 		return;
 	}
 	
 	ev_window_set_document (ev_window, job->document);
 
+	/* Restart the current page */
+	page = CLAMP (ev_link_dest_get_page (ev_window->priv->dest),
+		      0,
+		      ev_page_cache_get_n_pages (ev_window->priv->page_cache) - 1);
+	ev_page_cache_set_current_page (ev_window->priv->page_cache, page);
+	g_object_unref (ev_window->priv->dest);
+	ev_window->priv->dest = NULL;
+	
 	/* Restart the search after reloading */
 	widget = gtk_window_get_focus (GTK_WINDOW (ev_window));
 	if (widget && gtk_widget_get_ancestor (widget, EGG_TYPE_FIND_BAR)) {
@@ -1519,6 +1551,81 @@ ev_window_close_dialogs (EvWindow *ev_window)
 	ev_window->priv->properties = NULL;
 }
 
+static void
+ev_window_clear_progress_idle (EvWindow *ev_window)
+{
+	if (ev_window->priv->progress_idle > 0)
+		g_source_remove (ev_window->priv->progress_idle);
+	ev_window->priv->progress_idle = 0;
+}
+
+static void
+reset_progress_idle (EvWindow *ev_window)
+{
+	ev_window->priv->progress_idle = 0;
+}
+
+static void
+ev_window_show_progress_message (EvWindow   *ev_window,
+				 guint       interval,
+				 GSourceFunc function)
+{
+	if (ev_window->priv->progress_idle > 0)
+		g_source_remove (ev_window->priv->progress_idle);
+	ev_window->priv->progress_idle =
+		g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
+					    interval, function,
+					    ev_window,
+					    (GDestroyNotify)reset_progress_idle);
+}
+
+static void
+ev_window_reset_progress_cancellable (EvWindow *ev_window)
+{
+	if (ev_window->priv->progress_cancellable)
+		g_cancellable_reset (ev_window->priv->progress_cancellable);
+	else
+		ev_window->priv->progress_cancellable = g_cancellable_new ();
+}
+
+static void
+ev_window_progress_response_cb (EvProgressMessageArea *area,
+				gint                   response,
+				EvWindow              *ev_window)
+{
+	if (response == GTK_RESPONSE_CANCEL)
+		g_cancellable_cancel (ev_window->priv->progress_cancellable);
+	ev_window_set_message_area (ev_window, NULL);
+}
+
+static gboolean 
+show_loading_progress (EvWindow *ev_window)
+{
+	GtkWidget *area;
+	gchar     *text;
+	
+	if (ev_window->priv->message_area)
+		return FALSE;
+	
+	text = g_strdup_printf (_("Loading document from %s"),
+				ev_window->priv->uri);
+	area = ev_progress_message_area_new (GTK_STOCK_OPEN,
+					     text,
+					     GTK_STOCK_CLOSE,
+					     GTK_RESPONSE_CLOSE,
+					     GTK_STOCK_CANCEL,
+					     GTK_RESPONSE_CANCEL,
+					     NULL);
+	g_signal_connect (area, "response",
+			  G_CALLBACK (ev_window_progress_response_cb),
+			  ev_window);
+	gtk_widget_show (area);
+	ev_window_set_message_area (ev_window, area);
+	g_free (text);
+
+	return FALSE;
+}
+
 static void
 ev_window_load_remote_failed (EvWindow *ev_window,
 			      GError   *error)
@@ -1582,6 +1689,8 @@ window_open_file_copy_ready_cb (GFile        *source,
 				EvWindow     *ev_window)
 {
 	GError *error = NULL;
+
+	ev_window_clear_progress_idle (ev_window);
 	
 	g_file_copy_finish (source, async_result, &error);
 	if (!error) {
@@ -1606,6 +1715,16 @@ window_open_file_copy_ready_cb (GFile        *source,
 					       (GAsyncReadyCallback)mount_volume_ready_cb,
 					       ev_window);
 		g_object_unref (operation);
+	} else if (error->domain == G_IO_ERROR &&
+		   error->code == G_IO_ERROR_CANCELLED) {
+		ev_window_clear_load_job (ev_window);
+		ev_window_clear_local_uri (ev_window);
+		ev_window_clear_print_settings_file (ev_window);
+		g_free (ev_window->priv->uri);
+		ev_window->priv->uri = NULL;
+		g_object_unref (source);
+		
+		ev_view_set_loading (EV_VIEW (ev_window->priv->view), FALSE);
 	} else {
 		ev_window_load_remote_failed (ev_window, error);
 		g_object_unref (source);
@@ -1615,8 +1734,31 @@ window_open_file_copy_ready_cb (GFile        *source,
 }
 
 static void
-ev_window_load_file_remote (EvWindow  *ev_window,
-			    GFile     *source_file)
+window_open_file_copy_progress_cb (goffset   n_bytes,
+				   goffset   total_bytes,
+				   EvWindow *ev_window)
+{
+	gchar *status;
+	gdouble fraction;
+	
+	if (!ev_window->priv->message_area)
+		return;
+
+	fraction = n_bytes / (gdouble)total_bytes;
+	status = g_strdup_printf (_("Downloading document (%d%%)"),
+				  (gint)(fraction * 100));
+	
+	ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+					     status);
+	ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+					       fraction);
+
+	g_free (status);
+}
+
+static void
+ev_window_load_file_remote (EvWindow *ev_window,
+			    GFile    *source_file)
 {
 	GFile *target_file;
 	
@@ -1635,14 +1777,21 @@ ev_window_load_file_remote (EvWindow  *ev_window,
 		g_free (base_name);
 		g_free (tmp_name);
 	}
+
+	ev_window_reset_progress_cancellable (ev_window);
 	
 	target_file = g_file_new_for_uri (ev_window->priv->local_uri);
 	g_file_copy_async (source_file, target_file,
-			   0, G_PRIORITY_DEFAULT, NULL,
-			   NULL, NULL, /* no progress callback */
-			   (GAsyncReadyCallback) window_open_file_copy_ready_cb,
+			   0, G_PRIORITY_DEFAULT,
+			   ev_window->priv->progress_cancellable,
+			   (GFileProgressCallback)window_open_file_copy_progress_cb,
+			   ev_window, 
+			   (GAsyncReadyCallback)window_open_file_copy_ready_cb,
 			   ev_window);
 	g_object_unref (target_file);
+
+	ev_window_show_progress_message (ev_window, 1,
+					 (GSourceFunc)show_loading_progress);
 }
 
 void
@@ -1676,6 +1825,7 @@ ev_window_open_uri (EvWindow       *ev_window,
 	ev_view_set_loading (EV_VIEW (ev_window->priv->view), TRUE);
 
 	ev_window->priv->unlink_temp_file = unlink_temp_file;
+	ev_window->priv->window_mode = mode;
 
 	if (mode == EV_WINDOW_MODE_PREVIEW) {
 		ev_window->priv->print_settings_file = print_settings ? 
@@ -1686,9 +1836,18 @@ ev_window_open_uri (EvWindow       *ev_window,
 		g_free (ev_window->priv->uri);
 	ev_window->priv->uri = g_strdup (uri);
 
+	if (ev_window->priv->search_string)
+		g_free (ev_window->priv->search_string);
+	ev_window->priv->search_string = search_string ?
+		g_strdup (search_string) : NULL;
+
+	if (ev_window->priv->dest)
+		g_object_unref (ev_window->priv->dest);
+	ev_window->priv->dest = dest ? g_object_ref (dest) : NULL;
+
 	setup_size_from_metadata (ev_window);
-	
-	ev_window->priv->load_job = ev_job_load_new (uri, dest, mode, search_string);
+
+	ev_window->priv->load_job = ev_job_load_new (uri);
 	g_signal_connect (ev_window->priv->load_job,
 			  "finished",
 			  G_CALLBACK (ev_window_load_job_cb),
@@ -1709,23 +1868,87 @@ ev_window_reload_local (EvWindow *ev_window)
 	const gchar *uri;
 	
 	uri = ev_window->priv->local_uri ? ev_window->priv->local_uri : ev_window->priv->uri;
-	ev_window->priv->reload_job = ev_job_load_new (uri, NULL, 0, NULL);
+	ev_window->priv->reload_job = ev_job_load_new (uri);
 	g_signal_connect (ev_window->priv->reload_job, "finished",
 			  G_CALLBACK (ev_window_reload_job_cb),
 			  ev_window);
 	ev_job_scheduler_push_job (ev_window->priv->reload_job, EV_JOB_PRIORITY_NONE);
 }
 
+static gboolean 
+show_reloading_progress (EvWindow *ev_window)
+{
+	GtkWidget *area;
+	gchar     *text;
+	
+	if (ev_window->priv->message_area)
+		return FALSE;
+	
+	text = g_strdup_printf (_("Reloading document from %s"),
+				ev_window->priv->uri);
+	area = ev_progress_message_area_new (GTK_STOCK_REFRESH,
+					     text,
+					     GTK_STOCK_CLOSE,
+					     GTK_RESPONSE_CLOSE,
+					     GTK_STOCK_CANCEL,
+					     GTK_RESPONSE_CANCEL,
+					     NULL);
+	g_signal_connect (area, "response",
+			  G_CALLBACK (ev_window_progress_response_cb),
+			  ev_window);
+	gtk_widget_show (area);
+	ev_window_set_message_area (ev_window, area);
+	g_free (text);
+
+	return FALSE;
+}
+
 static void
 reload_remote_copy_ready_cb (GFile        *remote,
 			     GAsyncResult *async_result,
 			     EvWindow     *ev_window)
 {
-	g_file_copy_finish (remote, async_result, NULL);
-	ev_window_reload_local (ev_window);
+	GError *error = NULL;
+	
+	ev_window_clear_progress_idle (ev_window);
+	
+	g_file_copy_finish (remote, async_result, &error);
+	if (error) {
+		if (error->domain != G_IO_ERROR ||
+		    error->code != G_IO_ERROR_CANCELLED)
+			ev_window_error_message (ev_window, error,
+						 "%s", _("Failed to reload document."));
+		g_error_free (error);
+	} else {
+		ev_window_reload_local (ev_window);
+	}
+		
 	g_object_unref (remote);
 }
 
+static void
+reload_remote_copy_progress_cb (goffset   n_bytes,
+				goffset   total_bytes,
+				EvWindow *ev_window)
+{
+	gchar *status;
+	gdouble fraction;
+	
+	if (!ev_window->priv->message_area)
+		return;
+	
+	fraction = n_bytes / (gdouble)total_bytes;
+	status = g_strdup_printf (_("Downloading document (%d%%)"),
+				  (gint)(fraction * 100));
+	
+	ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+					     status);
+	ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+					       fraction);
+
+	g_free (status);
+}
+
 static void
 query_remote_uri_mtime_cb (GFile        *remote,
 			   GAsyncResult *async_result,
@@ -1750,14 +1973,21 @@ query_remote_uri_mtime_cb (GFile        *remote,
 			
 		/* Remote file has changed */
 		ev_window->priv->uri_mtime = mtime.tv_sec;
+
+		ev_window_reset_progress_cancellable (ev_window);
+		
 		target_file = g_file_new_for_uri (ev_window->priv->local_uri);
 		g_file_copy_async (remote, target_file,
 				   G_FILE_COPY_OVERWRITE,
-				   G_PRIORITY_DEFAULT, NULL,
-				   NULL, NULL, /* no progress callback */
-				   (GAsyncReadyCallback) reload_remote_copy_ready_cb,
+				   G_PRIORITY_DEFAULT,
+				   ev_window->priv->progress_cancellable,
+				   (GFileProgressCallback)reload_remote_copy_progress_cb,
+				   ev_window, 
+				   (GAsyncReadyCallback)reload_remote_copy_ready_cb,
 				   ev_window);
 		g_object_unref (target_file);
+		ev_window_show_progress_message (ev_window, 1,
+						 (GSourceFunc)show_reloading_progress);
 	} else {
 		g_object_unref (remote);
 		ev_window_reload_local (ev_window);
@@ -1784,9 +2014,19 @@ ev_window_reload_remote (EvWindow *ev_window)
 static void
 ev_window_reload_document (EvWindow *ev_window)
 {
+	gint page;
+
+	
 	ev_window_clear_reload_job (ev_window);
 	ev_window->priv->in_reload = TRUE;
 
+	page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
+	
+	if (ev_window->priv->dest)
+		g_object_unref (ev_window->priv->dest);
+	/* FIXME: save the scroll position too (xyz dest) */
+	ev_window->priv->dest = ev_link_dest_new_page (page);
+
 	if (ev_window->priv->local_uri) {
 		ev_window_reload_remote (ev_window);
 	} else {
@@ -2111,7 +2351,7 @@ ev_window_setup_recent (EvWindow *ev_window)
 					gtk_recent_info_ref (info),
 					(GDestroyNotify) gtk_recent_info_unref);
 		
-		g_signal_connect (G_OBJECT (action), "activate",
+		g_signal_connect (action, "activate",
 				  G_CALLBACK (ev_window_cmd_recent_file_activate),
 				  (gpointer) ev_window);
 
@@ -2137,42 +2377,150 @@ ev_window_setup_recent (EvWindow *ev_window)
 	g_list_free (items);
 }
 
+static gboolean 
+show_saving_progress (GFile *dst)
+{
+	EvWindow  *ev_window;
+	GtkWidget *area;
+	gchar     *text;
+	gchar     *uri;
+	EvSaveType save_type;
+
+	ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
+	ev_window->priv->progress_idle = 0;
+	
+	if (ev_window->priv->message_area)
+		return FALSE;
+
+	save_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dst), "save-type"));
+	uri = g_file_get_uri (dst);
+	switch (save_type) {
+	case EV_SAVE_DOCUMENT:
+		text = g_strdup_printf (_("Saving document to %s"), uri);
+		break;
+	case EV_SAVE_ATTACHMENT:
+		text = g_strdup_printf (_("Saving attachment to %s"), uri);
+		break;
+	case EV_SAVE_IMAGE:
+		text = g_strdup_printf (_("Saving image to %s"), uri);
+		break;
+	default:
+		g_assert_not_reached ();
+	}
+	g_free (uri);
+	area = ev_progress_message_area_new (GTK_STOCK_SAVE,
+					     text,
+					     GTK_STOCK_CLOSE,
+					     GTK_RESPONSE_CLOSE,
+					     GTK_STOCK_CANCEL,
+					     GTK_RESPONSE_CANCEL,
+					     NULL);
+	g_signal_connect (area, "response",
+			  G_CALLBACK (ev_window_progress_response_cb),
+			  ev_window);
+	gtk_widget_show (area);
+	ev_window_set_message_area (ev_window, area);
+	g_free (text);
+
+	return FALSE;
+}
+
 static void
 window_save_file_copy_ready_cb (GFile        *src,
 				GAsyncResult *async_result,
 				GFile        *dst)
 {
-	EvWindow  *window;
-	gchar     *name;
-	GError    *error = NULL;
+	EvWindow *ev_window;
+	GError   *error = NULL;
 
+	ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
+	ev_window_clear_progress_idle (ev_window);
+	
 	if (g_file_copy_finish (src, async_result, &error)) {
 		ev_tmp_file_unlink (src);
 		return;
 	}
 
-	window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
-	name = g_file_get_basename (dst);
-	ev_window_error_message (window, error,
-				 _("The file could not be saved as “%s”."),
-				 name);
+	if (error->domain != G_IO_ERROR ||
+	    error->code != G_IO_ERROR_CANCELLED) {
+		gchar *name;
+		
+		name = g_file_get_basename (dst);
+		ev_window_error_message (ev_window, error,
+					 _("The file could not be saved as “%s”."),
+					 name);
+		g_free (name);
+	}
 	ev_tmp_file_unlink (src);
-	g_free (name);
 	g_error_free (error);
 }
 
 static void
-ev_window_save_remote (EvWindow *ev_window,
-		       GFile    *src,
-		       GFile    *dst)
+window_save_file_copy_progress_cb (goffset n_bytes,
+				   goffset total_bytes,
+				   GFile  *dst)
+{
+	EvWindow  *ev_window;
+	EvSaveType save_type;
+	gchar     *status;
+	gdouble    fraction;
+
+	ev_window = EV_WINDOW (g_object_get_data (G_OBJECT (dst), "ev-window"));
+	
+	if (!ev_window->priv->message_area)
+		return;
+	
+	fraction = n_bytes / (gdouble)total_bytes;
+	save_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dst), "save-type"));
+
+	switch (save_type) {
+	case EV_SAVE_DOCUMENT:
+		status = g_strdup_printf (_("Uploading document (%d%%)"),
+					  (gint)(fraction * 100));
+		break;
+	case EV_SAVE_ATTACHMENT:
+		status = g_strdup_printf (_("Uploading attachment (%d%%)"),
+					  (gint)(fraction * 100));
+		break;
+	case EV_SAVE_IMAGE:
+		status = g_strdup_printf (_("Uploading image (%d%%)"),
+					  (gint)(fraction * 100));
+		break;
+	default:
+		g_assert_not_reached ();
+	}
+	
+	ev_progress_message_area_set_status (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+					     status);
+	ev_progress_message_area_set_fraction (EV_PROGRESS_MESSAGE_AREA (ev_window->priv->message_area),
+					       fraction);
+
+	g_free (status);
+}
+
+static void
+ev_window_save_remote (EvWindow  *ev_window,
+		       EvSaveType save_type,
+		       GFile     *src,
+		       GFile     *dst)
 {
+	ev_window_reset_progress_cancellable (ev_window);
 	g_object_set_data (G_OBJECT (dst), "ev-window", ev_window);
+	g_object_set_data (G_OBJECT (dst), "save-type", GINT_TO_POINTER (save_type));
 	g_file_copy_async (src, dst,
 			   G_FILE_COPY_OVERWRITE,
-			   G_PRIORITY_DEFAULT, NULL,
-			   NULL, NULL, /* no progress callback */
-			   (GAsyncReadyCallback) window_save_file_copy_ready_cb,
-			   dst);		
+			   G_PRIORITY_DEFAULT,
+			   ev_window->priv->progress_cancellable,
+			   (GFileProgressCallback)window_save_file_copy_progress_cb,
+			   dst,
+			   (GAsyncReadyCallback)window_save_file_copy_ready_cb,
+			   dst);
+	ev_window->priv->progress_idle =
+		g_timeout_add_seconds_full (G_PRIORITY_DEFAULT,
+					    1,
+					    (GSourceFunc)show_saving_progress,
+					    dst,
+					    NULL);
 }
 
 static void
@@ -2216,6 +2564,9 @@ file_save_dialog_response_cb (GtkWidget *fc,
 	}
 	
 	uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
+	/* FIXME: remote copy should be done here rather than in the save job, 
+	 * so that we can track progress and cancel the operation
+	 */
 	
 	ev_window_clear_save_job (ev_window);
 	ev_window->priv->save_job = ev_job_save_new (ev_window->priv->document,
@@ -2615,13 +2966,13 @@ ev_window_print_range (EvWindow *ev_window,
 		ev_window->priv->print_queue = g_queue_new ();
 
 	op = ev_print_operation_new (ev_window->priv->document);
-	g_signal_connect (G_OBJECT (op), "begin_print",
+	g_signal_connect (op, "begin_print",
 			  G_CALLBACK (ev_window_print_operation_begin_print),
 			  (gpointer)ev_window);
-	g_signal_connect (G_OBJECT (op), "status_changed",
+	g_signal_connect (op, "status_changed",
 			  G_CALLBACK (ev_window_print_operation_status_changed),
 			  (gpointer)ev_window);
-	g_signal_connect (G_OBJECT (op), "done",
+	g_signal_connect (op, "done",
 			  G_CALLBACK (ev_window_print_operation_done),
 			  (gpointer)ev_window);
 
@@ -2775,7 +3126,7 @@ ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
 				GTK_RESPONSE_NO,
 				GTK_STOCK_CANCEL,
 				GTK_RESPONSE_CANCEL,
-				_("Close after _Printing"),
+				_("Close _after Printing"),
 				GTK_RESPONSE_YES,
 				NULL);
 	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
@@ -3750,7 +4101,7 @@ save_sizing_mode (EvWindow *window)
 	GEnumValue *enum_value;
 
 	mode = ev_view_get_sizing_mode (EV_VIEW (window->priv->view));
-	enum_value = g_enum_get_value (EV_SIZING_MODE_CLASS, mode);
+	enum_value = g_enum_get_value (g_type_class_peek (EV_TYPE_SIZING_MODE), mode);
 
 	if (!ev_window_is_empty (window))
 		ev_metadata_manager_set_string (window->priv->uri, "sizing_mode",
@@ -4374,6 +4725,40 @@ zoom_control_changed_cb (EphyZoomAction *action,
 	}
 }
 
+static void
+ev_window_drag_data_received (GtkWidget        *widget,
+			      GdkDragContext   *context,
+			      gint              x,
+			      gint              y,
+			      GtkSelectionData *selection_data,
+			      guint             info,
+			      guint             time)
+
+{
+	EvWindow *window = EV_WINDOW (widget);
+	gchar   **uris;
+	gint      i = 0;
+	GSList   *uri_list = NULL;
+
+	uris = gtk_selection_data_get_uris (selection_data);
+	if (!uris) {
+		gtk_drag_finish (context, FALSE, FALSE, time);
+		return;
+	}
+
+	for (i = 0; uris[i]; i++) {
+		uri_list = g_slist_prepend (uri_list, (gpointer) uris[i]);
+	}
+
+	ev_application_open_uri_list (EV_APP, uri_list,
+				      gtk_window_get_screen (GTK_WINDOW (window)),
+				      0);
+	gtk_drag_finish (context, TRUE, FALSE, time);
+
+	g_strfreev (uris);
+	g_slist_free (uri_list);
+}
+
 static void
 ev_window_finalize (GObject *object)
 {
@@ -4495,6 +4880,12 @@ ev_window_dispose (GObject *object)
 		priv->local_uri = NULL;
 	}
 
+	ev_window_clear_progress_idle (window);
+	if (priv->progress_cancellable) {
+		g_object_unref (priv->progress_cancellable);
+		priv->progress_cancellable = NULL;
+	}
+	
 	ev_window_close_dialogs (window);
 
 	if (window->priv->printer) {
@@ -4545,6 +4936,11 @@ ev_window_dispose (GObject *object)
 		priv->uri = NULL;
 	}
 
+	if (priv->search_string) {
+		g_free (priv->search_string);
+		priv->search_string = NULL;
+	}
+	
 	if (priv->dest) {
 		g_object_unref (priv->dest);
 		priv->dest = NULL;
@@ -4584,6 +4980,7 @@ ev_window_class_init (EvWindowClass *ev_window_class)
 
 	widget_class->screen_changed = ev_window_screen_changed;
 	widget_class->window_state_event = ev_window_state_event;
+	widget_class->drag_data_received = ev_window_drag_data_received;
 
 	g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate));
 }
@@ -5332,9 +5729,10 @@ image_save_dialog_response_cb (GtkWidget *fc,
 	if (!is_native) {
 		GFile *source_file;
 		
-		source_file = g_file_new_for_uri (filename);
+		source_file = g_file_new_for_path (filename);
 		
-		ev_window_save_remote (ev_window, source_file, target_file);
+		ev_window_save_remote (ev_window, EV_SAVE_IMAGE,
+				       source_file, target_file);
 		g_object_unref (source_file);
 	}
 	
@@ -5481,7 +5879,8 @@ attachment_save_dialog_response_cb (GtkWidget *fc,
 				dest_file = g_object_ref (target_file);
 			}
 
-			ev_window_save_remote (ev_window, save_to, dest_file);
+			ev_window_save_remote (ev_window, EV_SAVE_ATTACHMENT,
+					       save_to, dest_file);
 
 			g_object_unref (dest_file);
 		}
@@ -5873,10 +6272,17 @@ ev_window_init (EvWindow *ev_window)
 	gtk_window_set_default_size (GTK_WINDOW (ev_window), 600, 600);
 
 	setup_view_from_metadata (ev_window);
-	setup_sidebar_from_metadata (ev_window, NULL);
+	setup_sidebar_from_metadata (ev_window);
 
         ev_window_sizing_mode_changed_cb (EV_VIEW (ev_window->priv->view), NULL, ev_window);
 	ev_window_setup_action_sensitivity (ev_window);
+
+	/* Drag and Drop */
+	gtk_drag_dest_set (GTK_WIDGET (ev_window),
+			   GTK_DEST_DEFAULT_ALL,
+			   NULL, 0,
+			   GDK_ACTION_COPY);
+	gtk_drag_dest_add_uri_targets (GTK_WIDGET (ev_window));
 }
 
 /**