X-Git-Url: https://www.fi.muni.cz/~kas/git//home/kas/public_html/git/?a=blobdiff_plain;f=shell%2Fev-window.c;h=7f3a520311d4324724476999cf0ddf93e8a26338;hb=217797d63b2d3b1c9a7a0511af1bbf3d99f0d482;hp=ab14e27183fd4f3328886853bbe039434c54712a;hpb=1d6150237848b4c1fede94ce23baa4fd8870fd93;p=evince.git diff --git a/shell/ev-window.c b/shell/ev-window.c index ab14e271..7f3a5203 100644 --- a/shell/ev-window.c +++ b/shell/ev-window.c @@ -87,12 +87,17 @@ #include #include #include -#include #include #include +#include #include +#include +#include #include +#include + +char *xdg_user_dir_lookup (char *type); typedef enum { PAGE_MODE_DOCUMENT, @@ -116,7 +121,6 @@ struct _EvWindowPrivate { GtkWidget *main_box; GtkWidget *menubar; - GtkWidget *toolbar_dock; GtkWidget *toolbar; GtkWidget *hpaned; GtkWidget *sidebar; @@ -127,7 +131,6 @@ struct _EvWindowPrivate { GtkWidget *sidebar_thumbs; GtkWidget *sidebar_links; GtkWidget *sidebar_attachments; - GtkWidget *preview_toolbar; /* Dialogs */ GtkWidget *properties; @@ -149,8 +152,13 @@ struct _EvWindowPrivate { /* Fullscreen mode */ GtkWidget *fullscreen_toolbar; - GtkWidget *fullscreen_popup; - guint fullscreen_timeout_id; + + /* Presentation mode */ + guint presentation_timeout_id; + + /* Preview mode */ + GtkWidget *preview_toolbar; + gchar *print_settings_file; /* Popup view */ GtkWidget *view_popup; @@ -202,7 +210,7 @@ struct _EvWindowPrivate { #define GCONF_LOCKDOWN_SAVE "/desktop/gnome/lockdown/disable_save_to_disk" #define GCONF_LOCKDOWN_PRINT "/desktop/gnome/lockdown/disable_printing" -#define FULLSCREEN_TIMEOUT 5 * 1000 +#define PRESENTATION_TIMEOUT 5 * 1000 #define SIDEBAR_DEFAULT_SIZE 132 #define LINKS_SIDEBAR_ID "links" @@ -210,7 +218,6 @@ struct _EvWindowPrivate { #define ATTACHMENTS_SIDEBAR_ID "attachments" static void ev_window_update_actions (EvWindow *ev_window); -static void ev_window_update_fullscreen_popup (EvWindow *window); static void ev_window_sidebar_visibility_changed_cb (EvSidebar *ev_sidebar, GParamSpec *pspec, EvWindow *ev_window); @@ -259,13 +266,6 @@ static void ev_window_cmd_view_best_fit (GtkAction *action, EvWindow *ev_window); static void ev_window_cmd_view_page_width (GtkAction *action, EvWindow *ev_window); -static void fullscreen_set_timeout (EvWindow *window); -static gboolean fullscreen_motion_notify_cb (GtkWidget *widget, - GdkEventMotion *event, - gpointer user_data); -static gboolean fullscreen_leave_notify_cb (GtkWidget *widget, - GdkEventCrossing *event, - gpointer user_data); static void view_handle_link_cb (EvView *view, EvLink *link, EvWindow *window); @@ -393,7 +393,8 @@ ev_window_setup_action_sensitivity (EvWindow *ev_window) /* Toolbar-specific actions: */ ev_window_set_action_sensitive (ev_window, PAGE_SELECTOR_ACTION, has_pages); ev_window_set_action_sensitive (ev_window, ZOOM_CONTROL_ACTION, has_pages); - ev_window_set_action_sensitive (ev_window, NAVIGATION_ACTION, has_pages); + ev_window_set_action_sensitive (ev_window, NAVIGATION_ACTION, FALSE); + ev_window_set_action_sensitive (ev_window, "PreviewPrint", has_pages && ok_to_print); ev_window_update_actions (ev_window); } @@ -431,13 +432,6 @@ ev_window_update_actions (EvWindow *ev_window) ev_view_can_zoom_out (view) && !presentation_mode); - ev_window_set_action_sensitive (ev_window, "Plus", !presentation_mode); - ev_window_set_action_sensitive (ev_window, "Minus", !presentation_mode); - ev_window_set_action_sensitive (ev_window, "KpPlus", !presentation_mode); - ev_window_set_action_sensitive (ev_window, "KpMinus", !presentation_mode); - ev_window_set_action_sensitive (ev_window, "CtrlKpPlus", !presentation_mode); - ev_window_set_action_sensitive (ev_window, "CtrlKpMinus", !presentation_mode); - /* Go menu */ if (has_pages) { ev_window_set_action_sensitive (ev_window, "GoPreviousPage", page > 0); @@ -529,17 +523,18 @@ update_chrome_visibility (EvWindow *window) preview_toolbar = (priv->chrome& EV_CHROME_PREVIEW_TOOLBAR); set_widget_visibility (priv->menubar, menubar); - set_widget_visibility (priv->toolbar_dock, toolbar); + set_widget_visibility (priv->toolbar, toolbar); set_widget_visibility (priv->find_bar, findbar); set_widget_visibility (priv->sidebar, sidebar); - set_widget_visibility (priv->preview_toolbar, preview_toolbar); + + if (priv->preview_toolbar) + set_widget_visibility (priv->preview_toolbar, preview_toolbar); ev_window_set_action_sensitive (window, "EditToolbar", toolbar); gtk_widget_set_sensitive (priv->menubar, menubar); - if (priv->fullscreen_popup != NULL) { + if (priv->fullscreen_toolbar != NULL) { set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar); - set_widget_visibility (priv->fullscreen_popup, fullscreen_toolbar); } } @@ -611,6 +606,16 @@ update_sizing_buttons (EvWindow *window) } } +/** + * ev_window_is_empty: + * @ev_window: The instance of the #EvWindow. + * + * It does look if there is any document loaded or if there is any job to load + * a document. + * + * Returns: %TRUE if there isn't any document loaded or any any documente to be + * loaded, %FALSE in other case. + */ gboolean ev_window_is_empty (const EvWindow *ev_window) { @@ -706,6 +711,9 @@ ev_window_add_history (EvWindow *window, gint page, EvLink *link) EvLinkAction *action; EvLinkDest *dest; + if (window->priv->history == NULL) + return; + if (link) { action = g_object_ref (ev_link_get_action (link)); dest = ev_link_action_get_dest (action); @@ -849,7 +857,7 @@ setup_sidebar_from_metadata (EvWindow *window, EvDocument *document) } else if (strcmp (page_id, THUMBNAILS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (thumbs), document)) { ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs); } else if (strcmp (page_id, ATTACHMENTS_SIDEBAR_ID) && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (attachments), document)) { - ev_sidebar_set_page (EV_SIDEBAR (sidebar), thumbs); + ev_sidebar_set_page (EV_SIDEBAR (sidebar), attachments); } g_value_unset (&sidebar_page); } else if (document && ev_sidebar_page_support_document (EV_SIDEBAR_PAGE (links), document)) { @@ -905,8 +913,14 @@ setup_size_from_metadata (EvWindow *window) if (window->priv->page_cache && 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; + + GdkScreen *screen; + + gint request_width; + gint request_height; ev_page_cache_get_max_width (window->priv->page_cache, 0, 1.0, @@ -915,9 +929,19 @@ setup_size_from_metadata (EvWindow *window) 0, 1.0, &document_height); + request_width = g_value_get_double (&width_ratio) * document_width; + request_height = g_value_get_double (&height_ratio) * document_height; + + screen = gtk_window_get_screen (GTK_WINDOW (window)); + + if (screen) { + request_width = MIN (request_width, gdk_screen_get_width (screen)); + request_height = MIN (request_width, gdk_screen_get_height (screen)); + } + gtk_window_resize (GTK_WINDOW (window), - g_value_get_double (&width_ratio) * document_width, - g_value_get_double (&height_ratio) * document_height); + request_width, + request_height); g_value_unset (&width_ratio); g_value_unset (&height_ratio); } @@ -1042,22 +1066,14 @@ ev_window_set_icon_from_thumbnail (EvJobThumbnail *job, ev_window_clear_thumbnail_job (ev_window); } -static void +static gboolean ev_window_setup_document (EvWindow *ev_window) { const EvDocumentInfo *info; - EvDocument *document; - EvView *view = EV_VIEW (ev_window->priv->view); + EvDocument *document = ev_window->priv->document; EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar); GtkAction *action; - - document = ev_window->priv->document; - ev_window->priv->page_cache = ev_page_cache_get (ev_window->priv->document); - g_signal_connect (ev_window->priv->page_cache, "page-changed", - G_CALLBACK (page_changed_cb), ev_window); - g_signal_connect (ev_window->priv->page_cache, "history-changed", - G_CALLBACK (history_changed_cb), ev_window); - + if (EV_IS_DOCUMENT_FIND (document)) { g_signal_connect_object (G_OBJECT (document), "find_changed", @@ -1073,7 +1089,7 @@ ev_window_setup_document (EvWindow *ev_window) ev_window_clear_thumbnail_job (ev_window); ev_page_cache_get_size (ev_window->priv->page_cache, - 1, 0, 1.0, + 0, 0, 1.0, &page_width, &page_height); scale = (gdouble)128 / (gdouble)page_width; @@ -1086,16 +1102,12 @@ ev_window_setup_document (EvWindow *ev_window) g_object_unref (rc); } - ev_sidebar_set_document (sidebar, document); - - if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) { - ev_view_set_document (view, document); - } ev_window_set_page_mode (ev_window, PAGE_MODE_DOCUMENT); - ev_window_title_set_document (ev_window->priv->title, document); ev_window_title_set_uri (ev_window->priv->title, ev_window->priv->uri); + ev_sidebar_set_document (sidebar, document); + action = gtk_action_group_get_action (ev_window->priv->action_group, PAGE_SELECTOR_ACTION); ev_page_action_set_document (EV_PAGE_ACTION (action), document); ev_window_setup_action_sensitivity (ev_window); @@ -1111,12 +1123,36 @@ ev_window_setup_document (EvWindow *ev_window) ev_window->priv->document); } + info = ev_page_cache_get_info (ev_window->priv->page_cache); + update_document_mode (ev_window, info->mode); + + return FALSE; +} + +static void +ev_window_set_document (EvWindow *ev_window, EvDocument *document) +{ + EvView *view = EV_VIEW (ev_window->priv->view); + + if (ev_window->priv->document) + g_object_unref (ev_window->priv->document); + ev_window->priv->document = g_object_ref (document); + + ev_window->priv->page_cache = ev_page_cache_get (ev_window->priv->document); + g_signal_connect (ev_window->priv->page_cache, "page-changed", + G_CALLBACK (page_changed_cb), ev_window); + g_signal_connect (ev_window->priv->page_cache, "history-changed", + G_CALLBACK (history_changed_cb), ev_window); + setup_size_from_metadata (ev_window); - setup_document_from_metadata (ev_window); setup_sidebar_from_metadata (ev_window, document); + setup_document_from_metadata (ev_window); - info = ev_page_cache_get_info (ev_window->priv->page_cache); - update_document_mode (ev_window, info->mode); + if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) { + ev_view_set_document (view, document); + } + + g_idle_add ((GSourceFunc)ev_window_setup_document, ev_window); } static void @@ -1199,19 +1235,23 @@ ev_window_clear_load_job (EvWindow *ev_window) static void ev_window_clear_local_uri (EvWindow *ev_window) { - char *filename; - if (ev_window->priv->local_uri) { - filename = g_filename_from_uri (ev_window->priv->local_uri, NULL, NULL); - if (filename != NULL) { - g_unlink (filename); - g_free (filename); - } + ev_tmp_uri_unlink (ev_window->priv->local_uri); g_free (ev_window->priv->local_uri); ev_window->priv->local_uri = NULL; } } +static void +ev_window_clear_print_settings_file (EvWindow *ev_window) +{ + if (ev_window->priv->print_settings_file) { + g_unlink (ev_window->priv->print_settings_file); + g_free (ev_window->priv->print_settings_file); + ev_window->priv->print_settings_file = NULL; + } +} + static void ev_window_clear_temp_file (EvWindow *ev_window) { @@ -1262,17 +1302,16 @@ ev_window_load_job_cb (EvJobLoad *job, /* Success! */ if (job->error == NULL) { - if (ev_window->priv->document) - g_object_unref (ev_window->priv->document); - ev_window->priv->document = g_object_ref (document); + ev_window_set_document (ev_window, document); + + if (job->mode != EV_WINDOW_MODE_PREVIEW) { + setup_view_from_metadata (ev_window); + } if (!ev_window->priv->unlink_temp_file) { - setup_view_from_metadata (ev_window); ev_window_add_recent (ev_window, ev_window->priv->uri); } - ev_window_setup_document (ev_window); - if (job->dest) { EvLink *link; EvLinkAction *link_action; @@ -1326,12 +1365,27 @@ ev_window_load_job_cb (EvJobLoad *job, return; } +/** + * ev_window_get_uri: + * @ev_window: The instance of the #EvWindow. + * + * It returns the uri of the document showed in the #EvWindow. + * + * Returns: the uri of the document showed in the #EvWindow. + */ const char * ev_window_get_uri (EvWindow *ev_window) { return ev_window->priv->uri; } +/** + * ev_window_close_dialogs: + * @ev_window: The window where dialogs will be closed. + * + * It looks for password, print and properties dialogs and closes them and + * frees them from memory. If there is any print job it does free it too. + */ static void ev_window_close_dialogs (EvWindow *ev_window) { @@ -1357,9 +1411,9 @@ ev_window_close_dialogs (EvWindow *ev_window) } static gint -xfer_update_progress_callback (GnomeVFSAsyncHandle *handle, - GnomeVFSXferProgressInfo *info, - EvWindow *ev_window) +open_xfer_update_progress_callback (GnomeVFSAsyncHandle *handle, + GnomeVFSXferProgressInfo *info, + EvWindow *ev_window) { switch (info->status) { case GNOME_VFS_XFER_PROGRESS_STATUS_OK: @@ -1384,7 +1438,8 @@ ev_window_open_uri (EvWindow *ev_window, const char *uri, EvLinkDest *dest, EvWindowRunMode mode, - gboolean unlink_temp_file) + gboolean unlink_temp_file, + const gchar *print_settings) { GnomeVFSURI *source_uri; GnomeVFSURI *target_uri; @@ -1392,10 +1447,16 @@ ev_window_open_uri (EvWindow *ev_window, ev_window_close_dialogs (ev_window); ev_window_clear_load_job (ev_window); ev_window_clear_local_uri (ev_window); + ev_window_clear_print_settings_file (ev_window); ev_view_set_loading (EV_VIEW (ev_window->priv->view), TRUE); ev_window->priv->unlink_temp_file = unlink_temp_file; + if (mode == EV_WINDOW_MODE_PREVIEW) { + ev_window->priv->print_settings_file = print_settings ? + g_strdup (print_settings) : NULL; + } + if (ev_window->priv->uri) g_free (ev_window->priv->uri); ev_window->priv->uri = g_strdup (uri); @@ -1436,7 +1497,8 @@ ev_window_open_uri (EvWindow *ev_window, GNOME_VFS_XFER_ERROR_MODE_ABORT, GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE, GNOME_VFS_PRIORITY_DEFAULT, - (GnomeVFSAsyncXferProgressCallback)xfer_update_progress_callback, + (GnomeVFSAsyncXferProgressCallback) + open_xfer_update_progress_callback, ev_window, NULL, NULL); @@ -1497,6 +1559,13 @@ ev_window_cmd_file_open (GtkAction *action, EvWindow *window) } else if (window->priv->uri != NULL) { gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser), window->priv->uri); + } else { + char *folder; + + folder = xdg_user_dir_lookup ("DOCUMENTS"); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser), + folder); + free (folder); } g_signal_connect (chooser, "response", @@ -1550,11 +1619,11 @@ ev_window_create_tmp_symlink (const gchar *filename, GError **error) static void ev_window_cmd_file_open_copy_at_dest (EvWindow *window, EvLinkDest *dest) { - GError *error = NULL; - gchar *symlink_uri; - gchar *old_filename; - gchar *new_filename; - gchar *uri_unc; + GError *error = NULL; + gchar *symlink_uri; + gchar *old_filename; + gchar *new_filename; + const gchar *uri_unc; uri_unc = g_object_get_data (G_OBJECT (window->priv->document), "uri-uncompressed"); @@ -1585,6 +1654,7 @@ ev_window_cmd_file_open_copy_at_dest (EvWindow *window, EvLinkDest *dest) dest, 0, TRUE, + NULL, GDK_CURRENT_TIME); g_free (symlink_uri); } @@ -1619,7 +1689,7 @@ ev_window_cmd_recent_file_activate (GtkAction *action, ev_application_open_uri_at_dest (EV_APP, uri, gtk_window_get_screen (GTK_WINDOW (window)), - NULL, 0, FALSE, + NULL, 0, FALSE, NULL, GDK_CURRENT_TIME); } #else @@ -1635,8 +1705,10 @@ ev_window_cmd_recent_file_activate (GtkAction *action, uri = egg_recent_item_get_uri (item); - ev_application_open_uri (EV_APP, uri, NULL, - GDK_CURRENT_TIME, NULL); + ev_application_open_uri_at_dest (EV_APP, uri, + gtk_window_get_screen (GTK_WINDOW (ev_window)), + NULL, 0, FALSE, NULL, + GDK_CURRENT_TIME); g_free (uri); } @@ -1703,13 +1775,11 @@ ev_window_get_recent_file_label (gint index, const gchar *filename) p = filename; end = filename + length; - while (p != end) - { + while (p != end) { const gchar *next; next = g_utf8_next_char (p); - switch (*p) - { + switch (*p) { case '_': g_string_append (str, "__"); break; @@ -1820,69 +1890,206 @@ ev_window_setup_recent (EvWindow *ev_window) #endif /* HAVE_GTK_RECENT */ } +static gint +save_xfer_update_progress_callback (GnomeVFSAsyncHandle *handle, + GnomeVFSXferProgressInfo *info, + GnomeVFSURI *tmp_uri) +{ + switch (info->status) { + case GNOME_VFS_XFER_PROGRESS_STATUS_OK: + if (info->phase == GNOME_VFS_XFER_PHASE_COMPLETED) { + gchar *uri; + + uri = gnome_vfs_uri_to_string (tmp_uri, 0); + ev_tmp_uri_unlink (uri); + g_free (uri); + gnome_vfs_uri_unref (tmp_uri); + } + return 1; + case GNOME_VFS_XFER_PROGRESS_STATUS_VFSERROR: + if (info->vfs_status != GNOME_VFS_OK) { + GtkWidget *dialog; + gchar *uri; + + dialog = gtk_message_dialog_new (NULL, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("The file could not be saved as “%s”."), + info->target_name); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + gnome_vfs_result_to_string (info->vfs_status)); + + g_signal_connect (dialog, "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + gtk_widget_show (dialog); + + uri = gnome_vfs_uri_to_string (tmp_uri, 0); + ev_tmp_uri_unlink (uri); + g_free (uri); + gnome_vfs_uri_unref (tmp_uri); + } + return 1; + case GNOME_VFS_XFER_PROGRESS_STATUS_OVERWRITE: + case GNOME_VFS_XFER_PROGRESS_STATUS_DUPLICATE: + return 1; + default: + g_assert_not_reached (); + } + + return 0; +} + +static void +ev_window_save_remote (EvWindow *ev_window, + GnomeVFSURI *src, + GnomeVFSURI *dst) +{ + GnomeVFSAsyncHandle *handle; + GList *slist = NULL; + GList *tlist = NULL; + + slist = g_list_prepend (slist, src); + tlist = g_list_prepend (tlist, dst); + gnome_vfs_async_xfer (&handle, slist, tlist, + GNOME_VFS_XFER_DEFAULT | GNOME_VFS_XFER_FOLLOW_LINKS, + GNOME_VFS_XFER_ERROR_MODE_ABORT, + GNOME_VFS_XFER_OVERWRITE_MODE_REPLACE, + GNOME_VFS_PRIORITY_DEFAULT, + (GnomeVFSAsyncXferProgressCallback) + save_xfer_update_progress_callback, + gnome_vfs_uri_ref (src), + NULL, NULL); + g_list_free (slist); + g_list_free (tlist); +} + static void file_save_dialog_response_cb (GtkWidget *fc, gint response_id, EvWindow *ev_window) { - gboolean success; + gchar *uri; + gchar *local_uri; + gint fd; + gchar *filename; + gchar *tmp_filename; + GError *error = NULL; - if (response_id == GTK_RESPONSE_OK) { - gint fd; - gchar *filename; - gchar *tmp_filename; - GError *error = NULL; + if (response_id != GTK_RESPONSE_OK) { + gtk_widget_destroy (fc); + return; + } + + uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc)); - filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fc)); - tmp_filename = g_strdup_printf ("%s.XXXXXX", filename); + filename = ev_tmp_filename ("saveacopy"); + tmp_filename = g_strdup_printf ("%s.XXXXXX", filename); + g_free (filename); + + fd = g_mkstemp (tmp_filename); + if (fd == -1) { + gchar *msg; + gchar *display_name; + gint save_errno = errno; - fd = g_mkstemp (tmp_filename); - if (fd == -1) { - gchar *display_name; - gint save_errno = errno; - - display_name = g_filename_display_name (tmp_filename); - g_set_error (&error, - G_FILE_ERROR, - g_file_error_from_errno (save_errno), - _("Failed to create file “%s”: %s"), - display_name, g_strerror (save_errno)); - g_free (display_name); - } else { - gchar *uri; + display_name = g_filename_display_name (tmp_filename); + g_set_error (&error, + G_FILE_ERROR, + g_file_error_from_errno (save_errno), + _("Failed to create file “%s”: %s"), + display_name, g_strerror (save_errno)); + g_free (display_name); - uri = g_filename_to_uri (tmp_filename, NULL, NULL); - - ev_document_doc_mutex_lock (); - success = ev_document_save (ev_window->priv->document, - uri, - &error); - ev_document_doc_mutex_unlock (); + msg = g_strdup_printf (_("The file could not be saved as “%s”."), uri); + ev_window_error_dialog (GTK_WINDOW (ev_window), msg, error); - g_free (uri); - close (fd); - } + g_free (tmp_filename); + g_free (uri); + g_free (msg); + g_error_free (error); + gtk_widget_destroy (fc); + + return; + } - if (!error) { - if (g_rename (tmp_filename, filename) == -1) { - g_unlink (tmp_filename); + /* Save document to temp filename */ + local_uri = g_filename_to_uri (tmp_filename, NULL, NULL); + + ev_document_doc_mutex_lock (); + ev_document_save (ev_window->priv->document, local_uri, &error); + ev_document_doc_mutex_unlock (); + + close (fd); + + if (!error) { + /* If original document was compressed, + * compress it again before saving + */ + if (g_object_get_data (G_OBJECT (ev_window->priv->document), + "uri-uncompressed")) { + EvCompressionType ctype = EV_COMPRESSION_NONE; + const gchar *ext; + gchar *uri_comp; + + ext = g_strrstr (ev_window->priv->uri, ".gz"); + if (ext && g_ascii_strcasecmp (ext, ".gz") == 0) + ctype = EV_COMPRESSION_GZIP; + + ext = g_strrstr (ev_window->priv->uri, ".bz2"); + if (ext && g_ascii_strcasecmp (ext, ".bz2") == 0) + ctype = EV_COMPRESSION_BZIP2; + + uri_comp = ev_file_compress (local_uri, ctype, &error); + g_free (local_uri); + ev_tmp_filename_unlink (tmp_filename); + + if (!uri_comp || error) { + local_uri = NULL; + } else { + local_uri = uri_comp; } + } + } + + g_free (tmp_filename); + + if (error) { + gchar *msg; + + msg = g_strdup_printf (_("The file could not be saved as “%s”."), uri); + ev_window_error_dialog (GTK_WINDOW (ev_window), msg, error); + g_free (uri); + g_free (msg); + g_error_free (error); + g_free (local_uri); + gtk_widget_destroy (fc); + + return; + } + + if (local_uri) { + GnomeVFSURI *target_uri; + + target_uri = gnome_vfs_uri_new (uri); + if (gnome_vfs_uri_is_local (target_uri)) { + /* If target uri is local, just rename local_uri */ + if (gnome_vfs_move (local_uri, uri, TRUE) != GNOME_VFS_OK) + ev_tmp_uri_unlink (local_uri); } else { - gchar *msg; - gchar *uri; - - uri = g_filename_to_uri (filename, NULL, NULL); - msg = g_strdup_printf (_("The file could not be saved as “%s”."), uri); - ev_window_error_dialog (GTK_WINDOW (ev_window), msg, error); - g_free (msg); - g_free (uri); - g_error_free (error); + GnomeVFSURI *source_uri; + + source_uri = gnome_vfs_uri_new (local_uri); + ev_window_save_remote (ev_window, source_uri, target_uri); + gnome_vfs_uri_unref (source_uri); } - - g_free (tmp_filename); - g_free (filename); + + gnome_vfs_uri_unref (target_uri); + g_free (local_uri); } + g_free (uri); gtk_widget_destroy (fc); } @@ -1892,6 +2099,7 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window) GtkWidget *fc; gchar *base_name; gchar *file_name; + gchar *folder; fc = gtk_file_chooser_dialog_new ( _("Save a Copy"), @@ -1903,13 +2111,17 @@ ev_window_cmd_save_as (GtkAction *action, EvWindow *ev_window) ev_document_factory_add_filters (fc, ev_window->priv->document); gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK); - gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER (fc), TRUE); + gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE); + gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE); file_name = gnome_vfs_format_uri_for_display (ev_window->priv->uri); base_name = g_path_get_basename (file_name); + folder = xdg_user_dir_lookup ("DOCUMENTS"); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc), folder); g_free (file_name); g_free (base_name); - + free (folder); + g_signal_connect (fc, "response", G_CALLBACK (file_save_dialog_response_cb), ev_window); @@ -1981,6 +2193,10 @@ ev_window_print_finished (GtkPrintJob *print_job, gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); + } else { + /* If printed successfully, save print settings */ + ev_application_set_print_settings (EV_APP, + window->priv->print_settings); } } @@ -2188,8 +2404,10 @@ ev_window_print_range (EvWindow *ev_window, int first_page, int last_page) current_page = ev_page_cache_get_current_page (page_cache); document_last_page = ev_page_cache_get_n_pages (page_cache); - if (!ev_window->priv->print_settings) - ev_window->priv->print_settings = gtk_print_settings_new (); + if (!ev_window->priv->print_settings) { + ev_window->priv->print_settings = g_object_ref ( + ev_application_get_print_settings (EV_APP)); + } if (first_page != 1 || last_page != document_last_page) { GtkPageRange range; @@ -2529,320 +2747,183 @@ ev_window_cmd_edit_copy (GtkAction *action, EvWindow *ev_window) } static void -ev_window_update_fullscreen_popup (EvWindow *window) +ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec, + EvWindow *ev_window) { - GtkWidget *popup = window->priv->fullscreen_popup; - int popup_width, popup_height; - GdkScreen *screen; - GdkRectangle screen_rect; - gboolean toolbar; - - g_return_if_fail (popup != NULL); - - if (GTK_WIDGET (window)->window == NULL) - return; - - toolbar = (window->priv->chrome & EV_CHROME_FULLSCREEN_TOOLBAR) != 0 || - (window->priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0; - popup_width = popup->requisition.width; - popup_height = popup->requisition.height; - - screen = gtk_widget_get_screen (GTK_WIDGET (window)); - gdk_screen_get_monitor_geometry (screen, - gdk_screen_get_monitor_at_window - (screen, - GTK_WIDGET (window)->window), - &screen_rect); - if (toolbar) { - gtk_widget_set_size_request (popup, - screen_rect.width, - -1); - gtk_window_move (GTK_WINDOW (popup), - screen_rect.x, - screen_rect.y); - - } else { - if (gtk_widget_get_direction (popup) == GTK_TEXT_DIR_RTL) - { - gtk_window_move (GTK_WINDOW (popup), - screen_rect.x, - screen_rect.y); - } else { - gtk_window_move (GTK_WINDOW (popup), - screen_rect.x + screen_rect.width - popup_width, - screen_rect.y); - } - } + if (!ev_window_is_empty (ev_window)) + ev_metadata_manager_set_int (ev_window->priv->uri, "sidebar_size", + gtk_paned_get_position (GTK_PANED (object))); } static void -screen_size_changed_cb (GdkScreen *screen, - EvWindow *window) +ev_window_update_fullscreen_action (EvWindow *window) { - ev_window_update_fullscreen_popup (window); + GtkAction *action; + + action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen"); + g_signal_handlers_block_by_func + (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window); + gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), + ev_view_get_fullscreen (EV_VIEW (window->priv->view))); + g_signal_handlers_unblock_by_func + (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window); } static void -ev_window_sidebar_position_change_cb (GObject *object, GParamSpec *pspec, - EvWindow *ev_window) +fullscreen_toolbar_setup_item_properties (GtkUIManager *ui_manager) { - if (!ev_window_is_empty (ev_window)) - ev_metadata_manager_set_int (ev_window->priv->uri, "sidebar_size", - gtk_paned_get_position (GTK_PANED (object))); + GtkWidget *item; + + item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoPreviousPage"); + g_object_set (item, "is-important", FALSE, NULL); + + item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/GoNextPage"); + g_object_set (item, "is-important", FALSE, NULL); + + item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/StartPresentation"); + g_object_set (item, "is-important", TRUE, NULL); + + item = gtk_ui_manager_get_widget (ui_manager, "/FullscreenToolbar/LeaveFullscreen"); + g_object_set (item, "is-important", TRUE, NULL); } static void -destroy_fullscreen_popup (EvWindow *window) +ev_window_run_fullscreen (EvWindow *window) { - if (window->priv->fullscreen_popup != NULL) - { - gtk_widget_destroy (window->priv->fullscreen_popup); - window->priv->fullscreen_popup = NULL; + if (!window->priv->fullscreen_toolbar) { + window->priv->fullscreen_toolbar = + gtk_ui_manager_get_widget (window->priv->ui_manager, + "/FullscreenToolbar"); + + gtk_toolbar_set_style (GTK_TOOLBAR (window->priv->fullscreen_toolbar), + GTK_TOOLBAR_BOTH_HORIZ); + fullscreen_toolbar_setup_item_properties (window->priv->ui_manager); + + gtk_box_pack_start (GTK_BOX (window->priv->main_box), + window->priv->fullscreen_toolbar, + FALSE, FALSE, 0); + gtk_box_reorder_child (GTK_BOX (window->priv->main_box), + window->priv->fullscreen_toolbar, 1); } + + g_object_set (G_OBJECT (window->priv->scrolled_window), + "shadow-type", GTK_SHADOW_NONE, + NULL); + + ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE); + ev_window_update_fullscreen_action (window); + + update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, TRUE); + update_chrome_visibility (window); + + gtk_window_fullscreen (GTK_WINDOW (window)); + gtk_widget_grab_focus (window->priv->view); + + if (!ev_window_is_empty (window)) + ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", TRUE); } static void -exit_fullscreen_button_clicked_cb (GtkWidget *button, EvWindow *window) +ev_window_stop_fullscreen (EvWindow *window) { - GtkAction *action; + EvView *view = EV_VIEW (window->priv->view); - action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen"); - g_return_if_fail (action != NULL); + if (!ev_view_get_fullscreen (EV_VIEW (view))) + return; + + g_object_set (G_OBJECT (window->priv->scrolled_window), + "shadow-type", GTK_SHADOW_IN, + NULL); + + ev_view_set_fullscreen (view, FALSE); + ev_window_update_fullscreen_action (window); + update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE); + update_chrome_visibility (window); + gtk_window_unfullscreen (GTK_WINDOW (window)); - gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), FALSE); + if (!ev_window_is_empty (window)) + ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", FALSE); } static void -fullscreen_popup_size_request_cb (GtkWidget *popup, GtkRequisition *req, EvWindow *window) +ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *window) { - ev_window_update_fullscreen_popup (window); + gboolean fullscreen; + + g_return_if_fail (EV_IS_WINDOW (window)); + ev_window_stop_presentation (window); + + fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); + if (fullscreen) { + ev_window_run_fullscreen (window); + } else { + ev_window_stop_fullscreen (window); + } } static gboolean -fullscreen_timeout_cb (EvWindow *window) +presentation_timeout_cb (EvWindow *window) { EvView *view = EV_VIEW (window->priv->view); - if (!view || - (!ev_view_get_fullscreen (EV_VIEW (view)) && - !ev_view_get_presentation (EV_VIEW (view)))) + if (!view || !ev_view_get_presentation (EV_VIEW (view))) return FALSE; - update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, FALSE); ev_view_hide_cursor (EV_VIEW (window->priv->view)); - window->priv->fullscreen_timeout_id = 0; + window->priv->presentation_timeout_id = 0; return FALSE; } static void -fullscreen_set_timeout (EvWindow *window) +presentation_set_timeout (EvWindow *window) { - if (window->priv->fullscreen_timeout_id != 0) { - g_source_remove (window->priv->fullscreen_timeout_id); + if (window->priv->presentation_timeout_id > 0) { + g_source_remove (window->priv->presentation_timeout_id); } - window->priv->fullscreen_timeout_id = - g_timeout_add (FULLSCREEN_TIMEOUT, (GSourceFunc)fullscreen_timeout_cb, window); + window->priv->presentation_timeout_id = + g_timeout_add (PRESENTATION_TIMEOUT, (GSourceFunc)presentation_timeout_cb, window); - update_chrome_flag (window, EV_CHROME_FULLSCREEN_TOOLBAR, TRUE); - update_chrome_visibility (window); ev_view_show_cursor (EV_VIEW (window->priv->view)); } static void -fullscreen_clear_timeout (EvWindow *window) +presentation_clear_timeout (EvWindow *window) { - if (window->priv->fullscreen_timeout_id != 0) { - g_source_remove (window->priv->fullscreen_timeout_id); + if (window->priv->presentation_timeout_id > 0) { + g_source_remove (window->priv->presentation_timeout_id); } - window->priv->fullscreen_timeout_id = 0; - update_chrome_visibility (window); + window->priv->presentation_timeout_id = 0; + ev_view_show_cursor (EV_VIEW (window->priv->view)); } - static gboolean -fullscreen_motion_notify_cb (GtkWidget *widget, - GdkEventMotion *event, - gpointer user_data) +presentation_motion_notify_cb (GtkWidget *widget, + GdkEventMotion *event, + gpointer user_data) { EvWindow *window = EV_WINDOW (user_data); - fullscreen_set_timeout (window); + presentation_set_timeout (window); return FALSE; } static gboolean -fullscreen_leave_notify_cb (GtkWidget *widget, - GdkEventCrossing *event, - gpointer user_data) +presentation_leave_notify_cb (GtkWidget *widget, + GdkEventCrossing *event, + gpointer user_data) { EvWindow *window = EV_WINDOW (user_data); - fullscreen_clear_timeout (window); + presentation_clear_timeout (window); return FALSE; } -static GtkWidget * -ev_window_get_exit_fullscreen_button (EvWindow *window) -{ - GtkWidget *button, *icon, *label, *hbox; - - button = gtk_button_new (); - g_signal_connect (button, "clicked", - G_CALLBACK (exit_fullscreen_button_clicked_cb), - window); - gtk_widget_show (button); - - hbox = gtk_hbox_new (FALSE, 2); - gtk_widget_show (hbox); - gtk_container_add (GTK_CONTAINER (button), hbox); - - icon = gtk_image_new_from_stock (EV_STOCK_LEAVE_FULLSCREEN, GTK_ICON_SIZE_BUTTON); - gtk_widget_show (icon); - gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0); - - label = gtk_label_new (_("Leave Fullscreen")); - gtk_widget_show (label); - gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); - - return button; -} - -static GtkWidget * -ev_window_create_fullscreen_popup (EvWindow *window) -{ - GtkWidget *popup; - GtkWidget *hbox; - GtkWidget *button; - GdkScreen *screen; - - window->priv->fullscreen_toolbar = egg_editable_toolbar_new_with_model - (window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP, FALSE), NULL); - - popup = gtk_window_new (GTK_WINDOW_POPUP); - hbox = gtk_hbox_new (FALSE, 0); - button = ev_window_get_exit_fullscreen_button (window); - - gtk_container_add (GTK_CONTAINER (popup), hbox); - gtk_box_pack_start (GTK_BOX (hbox), window->priv->fullscreen_toolbar, - TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); - - gtk_widget_show (button); - gtk_widget_show (hbox); - - gtk_window_set_resizable (GTK_WINDOW (popup), FALSE); - - screen = gtk_widget_get_screen (GTK_WIDGET (window)); - g_signal_connect_object (screen, "size-changed", - G_CALLBACK (screen_size_changed_cb), - window, 0); - g_signal_connect_object (popup, "size_request", - G_CALLBACK (fullscreen_popup_size_request_cb), - window, 0); - - gtk_window_set_screen (GTK_WINDOW (popup), - gtk_widget_get_screen (GTK_WIDGET (window))); - - return popup; -} - - -static void -ev_window_update_fullscreen_action (EvWindow *window) -{ - GtkAction *action; - - action = gtk_action_group_get_action (window->priv->action_group, "ViewFullscreen"); - g_signal_handlers_block_by_func - (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window); - gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), - ev_view_get_fullscreen (EV_VIEW (window->priv->view))); - g_signal_handlers_unblock_by_func - (action, G_CALLBACK (ev_window_cmd_view_fullscreen), window); -} - -static void -ev_window_run_fullscreen (EvWindow *window) -{ - if (window->priv->fullscreen_popup == NULL) - window->priv->fullscreen_popup - = ev_window_create_fullscreen_popup (window); - - g_object_set (G_OBJECT (window->priv->scrolled_window), - "shadow-type", GTK_SHADOW_NONE, - NULL); - - ev_view_set_fullscreen (EV_VIEW (window->priv->view), TRUE); - ev_window_update_fullscreen_action (window); - - gtk_window_fullscreen (GTK_WINDOW (window)); - gtk_widget_grab_focus (window->priv->view); - ev_window_update_fullscreen_popup (window); - - g_signal_connect (window->priv->view, - "motion-notify-event", - G_CALLBACK (fullscreen_motion_notify_cb), - window); - g_signal_connect (window->priv->view, - "leave-notify-event", - G_CALLBACK (fullscreen_leave_notify_cb), - window); - fullscreen_set_timeout (window); - - if (!ev_window_is_empty (window)) - ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", TRUE); -} - -static void -ev_window_stop_fullscreen (EvWindow *window) -{ - EvView *view = EV_VIEW (window->priv->view); - - if (!ev_view_get_fullscreen (EV_VIEW (view))) - return; - - g_object_set (G_OBJECT (window->priv->scrolled_window), - "shadow-type", GTK_SHADOW_IN, - NULL); - - ev_view_set_fullscreen (view, FALSE); - ev_window_update_fullscreen_action (window); - gtk_window_unfullscreen (GTK_WINDOW (window)); - - g_signal_handlers_disconnect_by_func (window->priv->view, - (gpointer) fullscreen_motion_notify_cb, - window); - g_signal_handlers_disconnect_by_func (window->priv->view, - (gpointer) fullscreen_leave_notify_cb, - window); - fullscreen_clear_timeout (window); - - if (!ev_window_is_empty (window)) - ev_metadata_manager_set_boolean (window->priv->uri, "fullscreen", FALSE); -} - -static void -ev_window_cmd_view_fullscreen (GtkAction *action, EvWindow *window) -{ - gboolean fullscreen; - - g_return_if_fail (EV_IS_WINDOW (window)); - ev_window_stop_presentation (window); - - fullscreen = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); - if (fullscreen) { - ev_window_run_fullscreen (window); - } else { - ev_window_stop_fullscreen (window); - } -} - static void ev_window_update_presentation_action (EvWindow *window) { @@ -2867,18 +2948,20 @@ ev_window_run_presentation (EvWindow *window) ev_view_set_presentation (EV_VIEW (window->priv->view), TRUE); ev_window_update_presentation_action (window); + update_chrome_visibility (window); + gtk_widget_grab_focus (window->priv->view); gtk_window_fullscreen (GTK_WINDOW (window)); g_signal_connect (window->priv->view, "motion-notify-event", - G_CALLBACK (fullscreen_motion_notify_cb), + G_CALLBACK (presentation_motion_notify_cb), window); g_signal_connect (window->priv->view, "leave-notify-event", - G_CALLBACK (fullscreen_leave_notify_cb), + G_CALLBACK (presentation_leave_notify_cb), window); - fullscreen_set_timeout (window); + presentation_set_timeout (window); ev_application_screensaver_disable (EV_APP); @@ -2898,15 +2981,16 @@ ev_window_stop_presentation (EvWindow *window) ev_view_set_presentation (EV_VIEW (window->priv->view), FALSE); ev_window_update_presentation_action (window); + update_chrome_visibility (window); gtk_window_unfullscreen (GTK_WINDOW (window)); g_signal_handlers_disconnect_by_func (window->priv->view, - (gpointer) fullscreen_motion_notify_cb, + (gpointer) presentation_motion_notify_cb, window); g_signal_handlers_disconnect_by_func (window->priv->view, - (gpointer) fullscreen_leave_notify_cb, + (gpointer) presentation_leave_notify_cb, window); - fullscreen_clear_timeout (window); + presentation_clear_timeout (window); ev_application_screensaver_enable (EV_APP); @@ -2933,6 +3017,20 @@ ev_window_cmd_view_presentation (GtkAction *action, EvWindow *window) static void ev_window_run_preview (EvWindow *window) { + GtkAction *action; + + if (!window->priv->preview_toolbar) { + window->priv->preview_toolbar = + gtk_ui_manager_get_widget (window->priv->ui_manager, + "/PreviewToolbar"); + + gtk_box_pack_start (GTK_BOX (window->priv->main_box), + window->priv->preview_toolbar, + FALSE, FALSE, 0); + gtk_box_reorder_child (GTK_BOX (window->priv->main_box), + window->priv->preview_toolbar, 1); + } + ev_view_set_continuous (EV_VIEW (window->priv->view), FALSE); update_chrome_flag (window, EV_CHROME_TOOLBAR, FALSE); @@ -2940,36 +3038,18 @@ ev_window_run_preview (EvWindow *window) update_chrome_flag (window, EV_CHROME_SIDEBAR, FALSE); update_chrome_flag (window, EV_CHROME_PREVIEW_TOOLBAR, TRUE); + + action = gtk_action_group_get_action (window->priv->action_group, + "PreviewPrint"); +#if GTK_CHECK_VERSION (2, 11, 0) + gtk_action_set_visible (action, TRUE); +#else + gtk_action_set_visible (action, FALSE); +#endif update_chrome_visibility (window); } -static gboolean -ev_window_focus_in_event (GtkWidget *widget, GdkEventFocus *event) -{ - EvWindow *window = EV_WINDOW (widget); - EvWindowPrivate *priv = window->priv; - - if (ev_view_get_fullscreen (EV_VIEW (priv->view))) - fullscreen_set_timeout (window); - - return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_in_event (widget, event); -} - -static gboolean -ev_window_focus_out_event (GtkWidget *widget, GdkEventFocus *event) -{ - EvWindow *window = EV_WINDOW (widget); - EvWindowPrivate *priv = window->priv; - - if (ev_view_get_fullscreen (EV_VIEW (priv->view))) { - fullscreen_set_timeout (window); - gtk_widget_hide (priv->fullscreen_popup); - } - - return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_out_event (widget, event); -} - static void ev_window_screen_changed (GtkWidget *widget, GdkScreen *old_screen) @@ -3002,18 +3082,6 @@ ev_window_screen_changed (GtkWidget *widget, if (GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed) { GTK_WIDGET_CLASS (ev_window_parent_class)->screen_changed (widget, old_screen); } - - if (priv->fullscreen_popup != NULL) { - g_signal_handlers_disconnect_by_func - (old_screen, G_CALLBACK (screen_size_changed_cb), window); - - g_signal_connect_object (screen, "size-changed", - G_CALLBACK (screen_size_changed_cb), - window, 0); - gtk_window_set_screen (GTK_WINDOW (priv->fullscreen_popup), screen); - - ev_window_update_fullscreen_popup (window); - } } static void @@ -3091,7 +3159,7 @@ ev_window_cmd_edit_toolbar (GtkAction *action, EvWindow *ev_window) gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 400); editor = egg_toolbar_editor_new (ev_window->priv->ui_manager, - ev_application_get_toolbars_model (EV_APP, FALSE)); + ev_application_get_toolbars_model (EV_APP)); gtk_container_set_border_width (GTK_CONTAINER (editor), 5); gtk_box_set_spacing (GTK_BOX (EGG_TOOLBAR_EDITOR (editor)), 5); @@ -3192,7 +3260,7 @@ ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window) gchar *uri; uri = g_strdup (ev_window->priv->uri); - ev_window_open_uri (ev_window, uri, NULL, 0, FALSE); + ev_window_open_uri (ev_window, uri, NULL, 0, FALSE, NULL); g_free (uri); } @@ -3200,21 +3268,178 @@ static void ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window) { GError *error = NULL; + GdkScreen *screen; + char *command; + const char *lang; + char *uri = NULL; - g_return_if_fail (EV_IS_WINDOW (ev_window)); + int i; + + const char * const * langs = g_get_language_names (); + + for (i = 0; langs[i]; i++) { + lang = langs[i]; + if (strchr (lang, '.')) { + continue; + } - gnome_help_display ("evince.xml", NULL, &error); + uri = g_build_filename(GNOMEDATADIR, + "/gnome/help/" PACKAGE, + lang, + "/evince.xml", + NULL); + + if (g_file_test (uri, G_FILE_TEST_EXISTS)) { + break; + } + } - if(error != NULL) { + if (uri == NULL) { + g_warning ("Cannot find help"); + return; + } + + command = g_strconcat ("gnome-help ghelp://", uri, NULL); + g_free (uri); + + screen = gtk_widget_get_screen (GTK_WIDGET (ev_window)); + gdk_spawn_command_line_on_screen (screen, command, &error); + if (error != NULL) { g_warning (error->message); g_error_free (error); } + g_free (command); } static void ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window) { - gtk_window_unfullscreen (GTK_WINDOW (window)); + ev_window_stop_fullscreen (window); +} + +static void +ev_window_cmd_start_presentation (GtkAction *action, EvWindow *window) +{ + ev_window_stop_fullscreen (window); + ev_window_run_presentation (window); +} + +#ifdef WITH_GTK_PRINT +static gboolean +lookup_printer_from_name (GtkPrinter *printer, + EvWindow *window) +{ + const gchar *printer_name; + + printer_name = gtk_print_settings_get_printer (window->priv->print_settings); + + if ((printer_name + && g_ascii_strcasecmp (printer_name, gtk_printer_get_name (printer)) == 0) || + (!printer_name && gtk_printer_is_default (printer))) { + if (window->priv->printer) + g_object_unref (window->priv->printer); + window->priv->printer = g_object_ref (printer); + + return TRUE; + } + + return FALSE; +} + +static void +ev_window_preview_print_finished (GtkPrintJob *print_job, + EvWindow *window, + GError *error) +{ + if (error) { + GtkWidget *dialog; + + dialog = gtk_message_dialog_new (GTK_WINDOW (window), + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + _("Failed to print document")); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + error->message); + + gtk_dialog_run (GTK_DIALOG (dialog)); + gtk_widget_destroy (dialog); + } + + g_object_unref (print_job); + gtk_widget_destroy (GTK_WIDGET (window)); +} +#endif /* WITH_GTK_PRINT */ + +static void +ev_window_cmd_preview_print (GtkAction *action, EvWindow *window) +{ +#ifdef WITH_GTK_PRINT + GtkPrintSettings *print_settings = NULL; + GtkPageSetup *page_setup; + GtkPrintJob *job; + gchar *filename; + GError *error = NULL; +#if GTK_CHECK_VERSION (2, 11, 0) + const gchar *print_settings_file = window->priv->print_settings_file; + + if (print_settings_file) { + if (g_file_test (print_settings_file, G_FILE_TEST_IS_REGULAR)) { + GError *error = NULL; + + print_settings = gtk_print_settings_new_from_file (print_settings_file, + &error); + + if (error) { + g_warning (error->message); + g_error_free (error); + print_settings = NULL; + } + } + } +#endif /* GTK 2.11.0 */ + + if (!print_settings) + print_settings = gtk_print_settings_new (); + + if (window->priv->print_settings) + g_object_unref (window->priv->print_settings); + window->priv->print_settings = print_settings; + + gtk_enumerate_printers ((GtkPrinterFunc) lookup_printer_from_name, + window, NULL, TRUE); + g_assert (GTK_IS_PRINTER (window->priv->printer)); + + page_setup = gtk_page_setup_new (); + + job = gtk_print_job_new ("evince-print", + window->priv->printer, + window->priv->print_settings, + page_setup); + + g_object_unref (window->priv->print_settings); + window->priv->print_settings = NULL; + g_object_unref (window->priv->printer); + window->priv->printer = NULL; + g_object_unref (page_setup); + + filename = g_filename_from_uri (window->priv->local_uri ? + window->priv->local_uri : window->priv->uri, + NULL, NULL); + + if (gtk_print_job_set_source_file (job, filename, &error)) { + gtk_print_job_send (job, + (GtkPrintJobCompleteFunc)ev_window_preview_print_finished, + window, NULL); + } else { + g_warning (error->message); + g_error_free (error); + } + + g_free (filename); + + gtk_widget_hide (GTK_WIDGET (window)); +#endif /* WITH_GTK_PRINT */ } static void @@ -3757,8 +3982,6 @@ find_bar_search_changed_cb (EggFindBar *find_bar, gboolean visible; const char *search_string; - g_return_if_fail (EV_IS_WINDOW (ev_window)); - /* Either the string or case sensitivity could have changed, * we connect this callback to both. We also connect it * to ::visible so when the find bar is hidden, we should @@ -3993,11 +4216,15 @@ ev_window_dispose (GObject *object) priv->history = NULL; } - if (priv->fullscreen_timeout_id) { - g_source_remove (priv->fullscreen_timeout_id); - priv->fullscreen_timeout_id = 0; + if (priv->print_settings_file) { + ev_window_clear_print_settings_file (window); + priv->print_settings_file = NULL; + } + + if (priv->presentation_timeout_id > 0) { + g_source_remove (priv->presentation_timeout_id); + priv->presentation_timeout_id = 0; } - destroy_fullscreen_popup (window); G_OBJECT_CLASS (ev_window_parent_class)->dispose (object); } @@ -4011,8 +4238,6 @@ ev_window_class_init (EvWindowClass *ev_window_class) g_object_class->dispose = ev_window_dispose; g_object_class->finalize = ev_window_finalize; - widget_class->focus_in_event = ev_window_focus_in_event; - widget_class->focus_out_event = ev_window_focus_out_event; widget_class->screen_changed = ev_window_screen_changed; g_type_class_add_private (g_object_class, sizeof (EvWindowPrivate)); @@ -4030,7 +4255,7 @@ static const GtkActionEntry entries[] = { { "FileOpen", GTK_STOCK_OPEN, N_("_Open..."), "O", N_("Open an existing document"), G_CALLBACK (ev_window_cmd_file_open) }, - { "FileOpenCopy", NULL, N_("Open a _Copy"), NULL, + { "FileOpenCopy", NULL, N_("Op_en a Copy"), NULL, N_("Open a copy of the current document in a new window"), G_CALLBACK (ev_window_cmd_file_open_copy) }, { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), "S", @@ -4103,9 +4328,15 @@ static const GtkActionEntry entries[] = { G_CALLBACK (ev_window_cmd_help_about) }, /* Toolbar-only */ - { "LeaveFullscreen", EV_STOCK_LEAVE_FULLSCREEN, N_("Leave Fullscreen"), NULL, + { "LeaveFullscreen", GTK_STOCK_LEAVE_FULLSCREEN, N_("Leave Fullscreen"), NULL, N_("Leave fullscreen mode"), G_CALLBACK (ev_window_cmd_leave_fullscreen) }, + { "StartPresentation", EV_STOCK_RUN_PRESENTATION, N_("Start Presentation"), NULL, + N_("Start a presentation"), + G_CALLBACK (ev_window_cmd_start_presentation) }, + { "PreviewPrint", GTK_STOCK_PRINT, N_("Print"), NULL, + N_("Print this document"), + G_CALLBACK (ev_window_cmd_preview_print) }, /* Accellerators */ { "Escape", NULL, "", "Escape", "", @@ -4245,7 +4476,7 @@ register_custom_actions (EvWindow *window, GtkActionGroup *group) action = g_object_new (EPHY_TYPE_ZOOM_ACTION, "name", ZOOM_CONTROL_ACTION, "label", _("Zoom"), - "stock_id", GTK_STOCK_ZOOM_IN, + "stock_id", EV_STOCK_ZOOM, "tooltip", _("Adjust the zoom level"), "zoom", 1.0, NULL); @@ -4458,10 +4689,45 @@ launch_action (EvWindow *window, EvLinkAction *action) allowing to launch executables is a good idea though. -- marco */ } +static gboolean +uri_is_valid (const gchar *uri) +{ + gchar *p = (gchar *) uri; + + if (!p || !g_ascii_isalpha (*p)) + return FALSE; + + p++; + while (g_ascii_isalnum (*p)) + p++; + + return (g_ascii_strncasecmp (p, "://", strlen ("://")) == 0); +} + static void launch_external_uri (EvWindow *window, EvLinkAction *action) { - gnome_vfs_url_show (ev_link_action_get_uri (action)); + const gchar *uri = ev_link_action_get_uri (action); + + if (!uri_is_valid (uri)) { + GtkWidget *dialog; + + dialog = gtk_message_dialog_new (GTK_WINDOW (window), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("Unable to open external link")); + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + _("Invalid URI: “%s”"), uri); + g_signal_connect (dialog, "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + gtk_widget_show (dialog); + + return; + } + + gnome_vfs_url_show (uri); } static void @@ -4481,6 +4747,7 @@ open_remote_link (EvWindow *window, EvLinkAction *action) ev_link_action_get_dest (action), 0, FALSE, + NULL, GDK_CURRENT_TIME); g_free (uri); @@ -4590,9 +4857,11 @@ image_save_dialog_response_cb (GtkWidget *fc, gint response_id, EvWindow *ev_window) { - gchar *uri; - gchar *filename; - GError *error = NULL; + GnomeVFSURI *target_uri; + gchar *uri; + gchar *filename; + gboolean is_local; + GError *error = NULL; if (response_id != GTK_RESPONSE_OK) { gtk_widget_destroy (fc); @@ -4600,7 +4869,15 @@ image_save_dialog_response_cb (GtkWidget *fc, } uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc)); - filename = g_filename_from_uri (uri, NULL, NULL); + target_uri = gnome_vfs_uri_new (uri); + is_local = gnome_vfs_uri_is_local (target_uri); + + if (is_local) { + filename = g_filename_from_uri (uri, NULL, NULL); + } else { + filename = ev_tmp_filename ("saveimage"); + } + g_free (uri); /* FIXME: allow saving in other image formats than png */ @@ -4612,10 +4889,26 @@ image_save_dialog_response_cb (GtkWidget *fc, _("The image could not be saved."), error); g_error_free (error); + g_free (filename); + gnome_vfs_uri_unref (target_uri); + gtk_widget_destroy (fc); + + return; } - g_free (filename); + if (!is_local) { + GnomeVFSURI *source_uri; + gchar *local_uri; + local_uri = g_filename_to_uri (filename, NULL, NULL); + source_uri = gnome_vfs_uri_new (local_uri); + g_free (local_uri); + ev_window_save_remote (ev_window, source_uri, target_uri); + gnome_vfs_uri_unref (source_uri); + } + + g_free (filename); + gnome_vfs_uri_unref (target_uri); gtk_widget_destroy (fc); } @@ -4637,6 +4930,7 @@ ev_view_popup_cmd_save_image_as (GtkAction *action, EvWindow *window) NULL); gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK); + gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE); filter = gtk_file_filter_new (); @@ -4695,10 +4989,12 @@ attachment_save_dialog_response_cb (GtkWidget *fc, gint response_id, EvWindow *ev_window) { + GnomeVFSURI *target_uri; gchar *uri; GList *l; GtkFileChooserAction fc_action; gboolean is_dir; + gboolean is_local; if (response_id != GTK_RESPONSE_OK) { gtk_widget_destroy (fc); @@ -4706,9 +5002,10 @@ attachment_save_dialog_response_cb (GtkWidget *fc, } uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc)); - + target_uri = gnome_vfs_uri_new (uri); g_object_get (G_OBJECT (fc), "action", &fc_action, NULL); is_dir = (fc_action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); + is_local = gnome_vfs_uri_is_local (target_uri); for (l = ev_window->priv->attach_list; l && l->data; l = g_list_next (l)) { EvAttachment *attachment; @@ -4717,26 +5014,57 @@ attachment_save_dialog_response_cb (GtkWidget *fc, attachment = (EvAttachment *) l->data; - if (is_dir) { - filename = g_strjoin ("/", uri, - ev_attachment_get_name (attachment), - NULL); + if (is_local) { + if (is_dir) { + filename = g_strjoin ("/", uri, + ev_attachment_get_name (attachment), + NULL); + } else { + filename = g_strdup (uri); + } } else { - filename = g_strdup (uri); + filename = ev_tmp_filename ("saveattachment"); } - + ev_attachment_save (attachment, filename, &error); - g_free (filename); if (error) { ev_window_error_dialog (GTK_WINDOW (ev_window), _("The attachment could not be saved."), error); g_error_free (error); + g_free (filename); + + continue; } + + if (!is_local) { + GnomeVFSURI *src_uri; + GnomeVFSURI *dest_uri; + gchar *local_uri; + + if (is_dir) { + const gchar *name = ev_attachment_get_name (attachment); + + dest_uri = gnome_vfs_uri_append_file_name (target_uri, + name); + } else { + dest_uri = gnome_vfs_uri_ref (target_uri); + } + + local_uri = g_filename_to_uri (filename, NULL, NULL); + src_uri = gnome_vfs_uri_new (local_uri); + g_free (local_uri); + ev_window_save_remote (ev_window, src_uri, dest_uri); + gnome_vfs_uri_unref (src_uri); + gnome_vfs_uri_unref (dest_uri); + } + + g_free (filename); } g_free (uri); + gnome_vfs_uri_unref (target_uri); gtk_widget_destroy (fc); } @@ -4764,6 +5092,7 @@ ev_attachment_popup_cmd_save_attachment_as (GtkAction *action, EvWindow *window) gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE); + gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE); if (attachment) gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), @@ -4782,14 +5111,12 @@ ev_window_init (EvWindow *ev_window) GtkActionGroup *action_group; GtkAccelGroup *accel_group; GError *error = NULL; - GtkWidget *sidebar_widget, *toolbar_dock; + GtkWidget *sidebar_widget; g_signal_connect (ev_window, "configure_event", G_CALLBACK (window_configure_event_cb), NULL); g_signal_connect (ev_window, "window_state_event", G_CALLBACK (window_state_event_cb), NULL); - g_signal_connect (ev_window, "notify", - G_CALLBACK (fullscreen_timeout_cb), NULL); ev_window->priv = EV_WINDOW_GET_PRIVATE (ev_window); @@ -4864,33 +5191,20 @@ ev_window_init (EvWindow *ev_window) ev_window->priv->menubar, FALSE, FALSE, 0); - /* This sucks, but there is no way to have a draw=no, expand=true separator - * in a GtkUIManager-built toolbar. So, just add another toolbar. - * See gtk+ bug 166489. - */ - toolbar_dock = ev_window->priv->toolbar_dock = gtk_hbox_new (FALSE, 0); - gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), toolbar_dock, - FALSE, FALSE, 0); - gtk_widget_show (toolbar_dock); ev_window->priv->toolbar = GTK_WIDGET (g_object_new (EGG_TYPE_EDITABLE_TOOLBAR, "ui-manager", ev_window->priv->ui_manager, "popup-path", "/ToolbarPopup", - "model", ev_application_get_toolbars_model (EV_APP, FALSE), + "model", ev_application_get_toolbars_model (EV_APP), NULL)); egg_editable_toolbar_show (EGG_EDITABLE_TOOLBAR (ev_window->priv->toolbar), "DefaultToolBar"); - gtk_box_pack_start (GTK_BOX (toolbar_dock), ev_window->priv->toolbar, - TRUE, TRUE, 0); - gtk_widget_show (ev_window->priv->toolbar); - - /* Preview toolbar */ - ev_window->priv->preview_toolbar = egg_editable_toolbar_new_with_model - (ev_window->priv->ui_manager, ev_application_get_toolbars_model (EV_APP, TRUE), NULL); - gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), ev_window->priv->preview_toolbar, + gtk_box_pack_start (GTK_BOX (ev_window->priv->main_box), + ev_window->priv->toolbar, FALSE, FALSE, 0); + gtk_widget_show (ev_window->priv->toolbar); /* Add the main area */ ev_window->priv->hpaned = gtk_hpaned_new (); @@ -4911,6 +5225,17 @@ ev_window_init (EvWindow *ev_window) /* Stub sidebar, for now */ + sidebar_widget = ev_sidebar_thumbnails_new (); + ev_window->priv->sidebar_thumbs = sidebar_widget; + g_signal_connect (sidebar_widget, + "notify::main-widget", + G_CALLBACK (sidebar_page_main_widget_update_cb), + ev_window); + sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, ev_window); + gtk_widget_show (sidebar_widget); + ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar), + sidebar_widget); + sidebar_widget = ev_sidebar_links_new (); ev_window->priv->sidebar_links = sidebar_widget; g_signal_connect (sidebar_widget, @@ -4936,17 +5261,6 @@ ev_window_init (EvWindow *ev_window) ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar), sidebar_widget); - sidebar_widget = ev_sidebar_thumbnails_new (); - ev_window->priv->sidebar_thumbs = sidebar_widget; - g_signal_connect (sidebar_widget, - "notify::main-widget", - G_CALLBACK (sidebar_page_main_widget_update_cb), - ev_window); - sidebar_page_main_widget_update_cb (G_OBJECT (sidebar_widget), NULL, ev_window); - gtk_widget_show (sidebar_widget); - ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar), - sidebar_widget); - ev_window->priv->scrolled_window = GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW, "shadow-type", GTK_SHADOW_IN, @@ -5094,6 +5408,13 @@ ev_window_init (EvWindow *ev_window) ev_window_setup_action_sensitivity (ev_window); } +/** + * ev_window_new: + * + * Creates a #GtkWidget that represents the window. + * + * Returns: the #GtkWidget that represents the window. + */ GtkWidget * ev_window_new (void) {