#include "ev-password.h"
#include "ev-password-view.h"
#include "ev-print-job.h"
+#include "ev-properties.h"
#include "ev-document-thumbnails.h"
#include "ev-document-links.h"
-#include "ev-document-types.h"
+#include "ev-document-fonts.h"
#include "ev-document-find.h"
#include "ev-document-security.h"
#include "ev-job-queue.h"
+#include "ev-jobs.h"
+#include "ev-statusbar.h"
#include "eggfindbar.h"
#include "egg-recent-view-gtk.h"
#include "egg-recent-view.h"
#include <glib/gi18n.h>
#include <gtk/gtk.h>
#include <gnome.h>
-
-#include <libgnomevfs/gnome-vfs-uri.h>
-#include <libgnomevfs/gnome-vfs-utils.h>
-#include <libgnomevfs/gnome-vfs-ops.h>
#include <libgnomeprintui/gnome-print-dialog.h>
-
+#include <libgnomevfs/gnome-vfs-utils.h>
#include <gconf/gconf-client.h>
#include <string.h>
} EvChrome;
struct _EvWindowPrivate {
+ /* UI */
+ EvChrome chrome;
+
GtkWidget *main_box;
GtkWidget *menubar;
GtkWidget *toolbar_dock;
GtkWidget *view;
GtkWidget *page_view;
GtkWidget *password_view;
+ GtkWidget *statusbar;
+ /* UI Builders */
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
gchar *toolbar_file;
EggToolbarsModel *toolbar_model;
-
- GtkWidget *statusbar;
- guint help_message_cid;
- guint view_message_cid;
+
+ /* Fullscreen mode */
GtkWidget *fullscreen_toolbar;
GtkWidget *fullscreen_popup;
- char *uri;
+ GSource *fullscreen_timeout_source;
+ /* Document */
+ char *uri;
+ char *local_uri;
EvDocument *document;
EvPageCache *page_cache;
EvWindowPageMode page_mode;
+
/* These members are used temporarily when in PAGE_MODE_PASSWORD */
EvDocument *password_document;
GtkWidget *password_dialog;
char *password_uri;
- EvChrome chrome;
- GSource *fullscreen_timeout_source;
+ /* Job used to load document */
+ EvJob *xfer_job;
+ EvJob *load_job;
/* recent file stuff */
EggRecentModel *recent_model;
EvWindow *ev_window);
static void ev_window_set_page_mode (EvWindow *window,
EvWindowPageMode page_mode);
-static gboolean start_loading_document (EvWindow *ev_window,
- EvDocument *document,
- const char *uri);
+static void ev_window_load_job_cb (EvJobLoad *job,
+ gpointer data);
+static void ev_window_xfer_job_cb (EvJobXfer *job,
+ gpointer data);
static void ev_window_sizing_mode_changed_cb (EvView *view,
GParamSpec *pspec,
EvWindow *ev_window);
+static void ev_window_zoom_changed_cb (EvView *view,
+ GParamSpec *pspec,
+ EvWindow *ev_window);
static void ev_window_add_recent (EvWindow *window,
const char *filename);
static void ev_window_fullscreen (EvWindow *window);
static void ev_window_stop_presentation (EvWindow *window);
static void ev_window_cmd_view_presentation (GtkAction *action,
EvWindow *window);
-
+static void show_fullscreen_popup (EvWindow *window);
+
G_DEFINE_TYPE (EvWindow, ev_window, GTK_TYPE_WINDOW)
{
EvView *view;
EvDocument *document;
+ const EvDocumentInfo *info = NULL;
EvWindowPageMode page_mode;
gboolean sensitive, has_pages = FALSE, has_document;
int n_pages = 0, page = -1;
+ gboolean ok_to_print = TRUE;
+ gboolean ok_to_copy = TRUE;
view = EV_VIEW (ev_window->priv->view);
document = ev_window->priv->document;
+ if (document)
+ info = ev_page_cache_get_info (ev_window->priv->page_cache);
page_mode = ev_window->priv->page_mode;
has_document = document != NULL;
if (has_document && ev_window->priv->page_cache) {
has_pages = has_document && n_pages > 0;
}
+ if (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);
+ }
+
/* File menu */
/* "FileOpen": always sensitive */
- set_action_sensitive (ev_window, "FileSaveAs", has_document);
- set_action_sensitive (ev_window, "FilePrint", has_pages);
+ set_action_sensitive (ev_window, "FileSaveAs", has_document && ok_to_copy);
+ set_action_sensitive (ev_window, "FilePrint", has_pages && ok_to_print);
+ set_action_sensitive (ev_window, "FileProperties", has_document);
/* "FileCloseWindow": always sensitive */
/* Edit menu */
-
sensitive = has_pages && ev_document_can_get_text (document);
- set_action_sensitive (ev_window, "EditCopy", sensitive);
- set_action_sensitive (ev_window, "EditSelectAll", sensitive);
+ set_action_sensitive (ev_window, "EditCopy", sensitive && ok_to_copy);
+ set_action_sensitive (ev_window, "EditSelectAll", sensitive && ok_to_copy);
set_action_sensitive (ev_window, "EditFind",
has_pages && EV_IS_DOCUMENT_FIND (document));
set_action_sensitive (ev_window, "Slash",
set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
if (priv->fullscreen_popup != NULL) {
- set_widget_visibility (priv->fullscreen_popup, fullscreen);
+ if (fullscreen)
+ show_fullscreen_popup (window);
+ else
+ set_widget_visibility (priv->fullscreen_popup, FALSE);
}
}
{
g_return_val_if_fail (EV_IS_WINDOW (ev_window), FALSE);
- return ev_window->priv->document == NULL;
+ return (ev_window->priv->document == NULL) &&
+ (ev_window->priv->load_job == NULL) &&
+ (ev_window->priv->xfer_job == NULL);
}
static void
password_needed = (ev_window->priv->password_document != NULL);
if (document && ev_window->priv->page_cache) {
- doc_title = ev_page_cache_get_title (ev_window->priv->page_cache);
+ doc_title = g_strdup (ev_page_cache_get_title (ev_window->priv->page_cache));
/* Make sure we get a valid title back */
if (doc_title) {
if (doc_title[0] == '\000' ||
!g_utf8_validate (doc_title, -1, NULL)) {
- g_free (doc_title);
doc_title = NULL;
}
}
static void
ev_window_setup_document (EvWindow *ev_window)
{
- EvDocumentInfo *info;
+ const EvDocumentInfo *info;
EvDocument *document;
EvView *view = EV_VIEW (ev_window->priv->view);
EvSidebar *sidebar = EV_SIDEBAR (ev_window->priv->sidebar);
GtkAction *action;
document = ev_window->priv->document;
- ev_window->priv->page_cache = ev_document_get_page_cache (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_object (G_OBJECT (document),
ev_page_action_set_document (EV_PAGE_ACTION (action), document);
update_action_sensitivity (ev_window);
- info = ev_document_get_info (document);
+ info = ev_page_cache_get_info (ev_window->priv->page_cache);
update_document_mode (ev_window, info->mode);
- ev_document_info_free (info);
}
static void
ev_window->priv->password_document = NULL;
ev_window->priv->password_uri = NULL;
+
+ ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
+
+ ev_statusbar_push (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_PROGRESS,
+ _("Loading document. Please wait"));
- if (start_loading_document (ev_window, document, uri)) {
- gtk_widget_destroy (password_dialog);
- }
-
+ ev_statusbar_set_progress (EV_STATUSBAR (ev_window->priv->statusbar),
+ TRUE);
+
+ gtk_widget_destroy (password_dialog);
+
g_object_unref (document);
g_free (uri);
gtk_widget_destroy (password_dialog);
}
-/* Called either by start_loading_document or by the "unlock" callback on the
+/* Called either by ev_window_load_job_cb or by the "unlock" callback on the
* password_view page. It assumes that ev_window->priv->password_* has been set
* correctly. These are cleared by password_dialog_response() */
}
}
-/* This wil try to load the document. It might be called multiple times on the
- * same document by the password dialog.
+
+static void
+ev_window_clear_jobs (EvWindow *ev_window)
+{
+ if (ev_window->priv->load_job != NULL) {
+
+ if (!ev_window->priv->load_job->finished)
+ ev_job_queue_remove_job (ev_window->priv->load_job);
+
+ g_signal_handlers_disconnect_by_func (ev_window->priv->load_job, ev_window_load_job_cb, ev_window);
+ g_object_unref (ev_window->priv->load_job);
+ ev_window->priv->load_job = NULL;
+ }
+
+ if (ev_window->priv->xfer_job != NULL) {
+
+ if (!ev_window->priv->xfer_job->finished)
+ ev_job_queue_remove_job (ev_window->priv->xfer_job);
+
+ g_signal_handlers_disconnect_by_func (ev_window->priv->xfer_job, ev_window_xfer_job_cb, ev_window);
+ g_object_unref (ev_window->priv->xfer_job);
+ ev_window->priv->xfer_job = NULL;
+ }
+}
+
+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) {
+ unlink (filename);
+ g_free (filename);
+ }
+ g_free (ev_window->priv->local_uri);
+ ev_window->priv->local_uri = NULL;
+ }
+}
+
+/* This callback will executed when load job will be finished.
*
* Since the flow of the error dialog is very confusing, we assume that both
* document and uri will go away after this function is called, and thus we need
* ev_window->priv->password_{uri,document}, and thus people who call this
* function should _not_ necessarily expect those to exist after being
* called. */
-static gboolean
-start_loading_document (EvWindow *ev_window,
- EvDocument *document,
- const char *uri)
+static void
+ev_window_load_job_cb (EvJobLoad *job,
+ gpointer data)
{
- gboolean result;
- GError *error = NULL;
+ EvWindow *ev_window = EV_WINDOW (data);
+ EvDocument *document = EV_JOB (job)->document;
g_assert (document);
g_assert (document != ev_window->priv->document);
- g_assert (uri);
+ g_assert (job->uri);
+
+ ev_statusbar_pop (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_PROGRESS);
+
+ ev_statusbar_set_progress (EV_STATUSBAR (ev_window->priv->statusbar),
+ FALSE);
+
if (ev_window->priv->password_document) {
g_object_unref (ev_window->priv->password_document);
ev_window->priv->password_document = NULL;
ev_window->priv->password_uri = NULL;
}
- result = ev_document_load (document, uri, &error);
-
/* Success! */
- if (result) {
+ 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_setup_document (ev_window);
- ev_window_add_recent (ev_window, uri);
-
- return TRUE;
+ ev_window_add_recent (ev_window, ev_window->priv->uri);
+ ev_window_clear_jobs (ev_window);
+
+ return;
}
- /* unable to load the document */
- g_assert (error != NULL);
-
- if (error->domain == EV_DOCUMENT_ERROR &&
- error->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
+ if (job->error->domain == EV_DOCUMENT_ERROR &&
+ job->error->code == EV_DOCUMENT_ERROR_ENCRYPTED) {
gchar *base_name, *file_name;
ev_window->priv->password_document = g_object_ref (document);
- ev_window->priv->password_uri = g_strdup (uri);
+ ev_window->priv->password_uri = g_strdup (job->uri);
- base_name = g_path_get_basename (uri);
+ base_name = g_path_get_basename (job->uri);
file_name = gnome_vfs_unescape_string_for_display (base_name);
ev_password_view_set_file_name (EV_PASSWORD_VIEW (ev_window->priv->password_view),
ev_window_popup_password_dialog (ev_window);
} else {
- unable_to_load (ev_window, error->message);
- }
- g_error_free (error);
+ unable_to_load (ev_window, job->error->message);
+ }
- return FALSE;
+ return;
}
-static gboolean
-sanity_check_uri (EvWindow *window, const char *uri)
+static void
+ev_window_xfer_job_cb (EvJobXfer *job,
+ gpointer data)
{
- gboolean result = FALSE;
- GnomeVFSURI *vfs_uri;
- char *err;
-
- vfs_uri = gnome_vfs_uri_new (uri);
- if (vfs_uri) {
- if (gnome_vfs_uri_exists (vfs_uri)) {
- result = TRUE;
- }
- }
+ EvWindow *ev_window = EV_WINDOW (data);
- if (!result) {
- err = g_strdup_printf (_("The file %s does not exist."), uri);
- unable_to_load (window, err);
- g_free (err);
- }
- return result;
+
+ if (job->error != NULL) {
+ ev_statusbar_pop (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_PROGRESS);
+ ev_statusbar_set_progress (EV_STATUSBAR (ev_window->priv->statusbar),
+ FALSE);
+
+ unable_to_load (ev_window, job->error->message);
+ ev_window_clear_jobs (ev_window);
+ } else {
+ char *uri;
+
+ EvDocument *document = g_object_ref (EV_JOB (job)->document);
+
+ if (job->local_uri) {
+ ev_window->priv->local_uri = g_strdup (job->local_uri);
+ uri = ev_window->priv->local_uri;
+ } else {
+ ev_window->priv->local_uri = NULL;
+ uri = ev_window->priv->uri;
+ }
+
+ ev_window_clear_jobs (ev_window);
+
+ ev_window->priv->load_job = ev_job_load_new (document, uri);
+ g_signal_connect (ev_window->priv->load_job,
+ "finished",
+ G_CALLBACK (ev_window_load_job_cb),
+ ev_window);
+ ev_job_queue_add_job (ev_window->priv->load_job, EV_JOB_PRIORITY_HIGH);
+ }
}
void
-ev_window_open (EvWindow *ev_window, const char *uri)
+ev_window_open_uri (EvWindow *ev_window, const char *uri)
{
- EvDocument *document = NULL;
- GType document_type;
- char *mime_type = NULL;
-
- if (!sanity_check_uri (ev_window, uri)) {
- return;
- }
+ if (ev_window->priv->password_dialog)
+ gtk_widget_destroy (ev_window->priv->password_dialog);
g_free (ev_window->priv->uri);
ev_window->priv->uri = g_strdup (uri);
+
+ ev_window_clear_jobs (ev_window);
+ ev_window_clear_local_uri (ev_window);
+
+ ev_window->priv->xfer_job = ev_job_xfer_new (uri);
+ g_signal_connect (ev_window->priv->xfer_job,
+ "finished",
+ G_CALLBACK (ev_window_xfer_job_cb),
+ ev_window);
+ ev_job_queue_add_job (ev_window->priv->xfer_job, EV_JOB_PRIORITY_HIGH);
- document_type = ev_document_type_lookup (uri, &mime_type);
- if (document_type != G_TYPE_INVALID) {
- document = g_object_new (document_type, NULL);
- }
-
- if (document) {
- start_loading_document (ev_window, document, uri);
- /* See the comment on start_loading_document on ref counting.
- * As the password dialog flow is confusing, we're very explicit
- * on ref counting. */
- g_object_unref (document);
- } else {
- char *error_message;
-
- error_message = g_strdup_printf (_("Unhandled MIME type: '%s'"),
- mime_type?mime_type:"<Unknown MIME Type>");
- unable_to_load (ev_window, error_message);
- g_free (error_message);
- }
-
- g_free (mime_type);
+ ev_statusbar_push (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_PROGRESS,
+ _("Loading document. Please wait"));
+ ev_statusbar_set_progress (EV_STATUSBAR (ev_window->priv->statusbar),
+ TRUE);
}
-static void
-ev_window_open_uri_list (EvWindow *ev_window, GList *uri_list)
+void
+ev_window_open_uri_list (EvWindow *ev_window, GSList *uri_list)
{
- GList *list;
- gchar *uri;
+ GSList *list;
+ gchar *uri;
g_return_if_fail (uri_list != NULL);
list = uri_list;
while (list) {
- uri = gnome_vfs_uri_to_string (list->data, GNOME_VFS_URI_HIDE_NONE);
+
+ uri = (gchar *)list->data;
- if (ev_document_type_lookup (uri, NULL) != G_TYPE_INVALID) {
if (ev_window_is_empty (EV_WINDOW (ev_window))) {
- ev_window_open (ev_window, uri);
-
+ ev_window_open_uri (ev_window, uri);
+
gtk_widget_show (GTK_WIDGET (ev_window));
} else {
EvWindow *new_window;
-
+
new_window = ev_application_new_window (EV_APP);
- ev_window_open (new_window, uri);
-
+ ev_window_open_uri (new_window, uri);
+
gtk_widget_show (GTK_WIDGET (new_window));
}
- }
g_free (uri);
- list = g_list_next (list);
+ list = g_slist_next (list);
}
}
window = GTK_WIDGET (ev_application_get_empty_window (EV_APP));
gtk_widget_show (window);
- ev_window_open (EV_WINDOW (window), uri);
+ ev_window_open_uri (EV_WINDOW (window), uri);
g_free (uri);
}
{
EggRecentItem *item;
- if (strstr (filename, "file:///") == NULL)
- return;
-
item = egg_recent_item_new_from_uri (filename);
egg_recent_item_add_group (item, "Evince");
egg_recent_model_add_full (window->priv->recent_model, item);
EvPageCache *page_cache;
int last_page;
- page_cache = ev_document_get_page_cache (window->priv->document);
+ page_cache = ev_page_cache_get (window->priv->document);
last_page = ev_page_cache_get_n_pages (page_cache);
ev_window_print_range (window, 1, -1);
g_return_if_fail (EV_IS_WINDOW (ev_window));
g_return_if_fail (ev_window->priv->document != NULL);
- page_cache = ev_document_get_page_cache (ev_window->priv->document);
+ page_cache = ev_page_cache_get (ev_window->priv->document);
if (last_page == -1) {
last_page = ev_page_cache_get_n_pages (page_cache);
}
ev_window_print (ev_window);
}
+static void
+ev_window_cmd_file_properties (GtkAction *action, EvWindow *ev_window)
+{
+ EvDocument *document = ev_window->priv->document;
+ const EvDocumentInfo *info;
+ GtkDialog *dialog;
+ GtkTreeModel *fonts;
+
+ if (EV_IS_DOCUMENT_FONTS (document)) {
+ fonts = ev_document_fonts_get_fonts_model (EV_DOCUMENT_FONTS (document));
+ } else {
+ fonts = NULL;
+ }
+
+ info = ev_page_cache_get_info (ev_window->priv->page_cache);
+ dialog = ev_properties_new (info, fonts);
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (ev_window));
+ gtk_dialog_run (dialog);
+ gtk_widget_destroy (GTK_WIDGET (dialog));
+}
+
static void
ev_window_cmd_file_close_window (GtkAction *action, EvWindow *ev_window)
{
ev_view_show_cursor (EV_VIEW (window->priv->view));
}
+
+static void
+show_fullscreen_popup (EvWindow *window)
+{
+ if (!GTK_WIDGET_VISIBLE (window->priv->fullscreen_popup)) {
+ g_object_set (window->priv->fullscreen_popup, "visible", TRUE, NULL);
+ ev_view_show_cursor (EV_VIEW (window->priv->view));
+ }
+
+ fullscreen_set_timeout (window);
+}
+
static gboolean
fullscreen_motion_notify_cb (GtkWidget *widget,
GdkEventMotion *event,
{
EvWindow *window = EV_WINDOW (user_data);
- if (!GTK_WIDGET_VISIBLE (window->priv->fullscreen_popup)) {
- g_object_set (window->priv->fullscreen_popup, "visible", TRUE, NULL);
- ev_view_show_cursor (EV_VIEW (window->priv->view));
- }
-
- fullscreen_set_timeout (window);
+ show_fullscreen_popup (window);
return FALSE;
}
EvWindow *window = EV_WINDOW (widget);
if (event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED) {
- gboolean show;
+ gboolean maximized;
- show = (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) == 0;
+ maximized = (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) == 0;
- gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (window->priv->statusbar),
- show);
+ ev_statusbar_set_maximized (EV_STATUSBAR (window->priv->statusbar),
+ maximized);
}
return FALSE;
NULL);
if (fullscreen)
- gtk_widget_show (priv->fullscreen_popup);
+ show_fullscreen_popup (window);
return GTK_WIDGET_CLASS (ev_window_parent_class)->focus_in_event (widget, event);
}
ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FREE);
ev_view_zoom_in (EV_VIEW (ev_window->priv->view));
- update_action_sensitivity (ev_window);
}
static void
ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), EV_SIZING_FREE);
ev_view_zoom_out (EV_VIEW (ev_window->priv->view));
- update_action_sensitivity (ev_window);
}
static void
page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
uri = g_strdup (ev_window->priv->uri);
- ev_window_open (ev_window, uri);
+ ev_window_open_uri (ev_window, uri);
/* In case the number of pages in the document has changed. */
page = CLAMP (page, 0, ev_page_cache_get_n_pages (ev_window->priv->page_cache));
update_sizing_buttons (ev_window);
}
+static void
+ev_window_zoom_changed_cb (EvView *view, GParamSpec *pspec,
+ EvWindow *ev_window)
+{
+ update_action_sensitivity (ev_window);
+}
+
static char *
build_comments_string (void)
{
g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
if (message) {
- gtk_statusbar_push (GTK_STATUSBAR (ev_window->priv->statusbar),
- ev_window->priv->help_message_cid, message);
+ ev_statusbar_push (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_VIEW, message);
g_free (message);
}
}
static void
menu_item_deselect_cb (GtkMenuItem *proxy, EvWindow *ev_window)
{
- gtk_statusbar_pop (GTK_STATUSBAR (ev_window->priv->statusbar),
- ev_window->priv->help_message_cid);
+ ev_statusbar_pop (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_VIEW);
}
static void
{
const char *message;
- gtk_statusbar_pop (GTK_STATUSBAR (ev_window->priv->statusbar),
- ev_window->priv->view_message_cid);
+ ev_statusbar_pop (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_HELP);
message = ev_view_get_status (view);
if (message) {
- gtk_statusbar_push (GTK_STATUSBAR (ev_window->priv->statusbar),
- ev_window->priv->view_message_cid, message);
+ ev_statusbar_push (EV_STATUSBAR (ev_window->priv->statusbar),
+ EV_CONTEXT_HELP, message);
}
}
}
ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), mode);
- update_action_sensitivity (ev_window);
}
static void
priv->page_view = NULL;
}
+ if (priv->load_job || priv->xfer_job) {
+ ev_window_clear_jobs (window);
+ }
+
+ if (priv->local_uri) {
+ ev_window_clear_local_uri (window);
+ }
+
if (priv->password_document) {
g_object_unref (priv->password_document);
priv->password_document = NULL;
priv->password_uri = NULL;
}
+ if (priv->password_dialog) {
+ gtk_widget_destroy (priv->password_dialog);
+ }
+
if (priv->find_bar) {
g_signal_handlers_disconnect_by_func
(window->priv->find_bar,
priv->find_bar = NULL;
}
+ if (window->priv->fullscreen_timeout_source) {
+ g_source_destroy (window->priv->fullscreen_timeout_source);
+ window->priv->fullscreen_timeout_source = NULL;
+ }
destroy_fullscreen_popup (window);
G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
{ "FilePrint", GTK_STOCK_PRINT, N_("Print..."), "<control>P",
N_("Print this document"),
G_CALLBACK (ev_window_cmd_file_print) },
+ { "FileProperties", GTK_STOCK_PROPERTIES, N_("Properties"), "<alt>Return",
+ N_("View the properties of this document"),
+ G_CALLBACK (ev_window_cmd_file_properties) },
{ "FileCloseWindow", GTK_STOCK_CLOSE, NULL, "<control>W",
N_("Close this window"),
G_CALLBACK (ev_window_cmd_file_close_window) },
{ "ViewSidebar", NULL, N_("Side _pane"), "F9",
N_("Show or hide the side pane"),
G_CALLBACK (ev_window_view_sidebar_cb), TRUE },
- { "ViewContinuous", NULL, N_("_Continuous"), NULL,
+ { "ViewContinuous", EV_STOCK_VIEW_CONTINUOUS, N_("_Continuous"), NULL,
N_("Show the entire document"),
G_CALLBACK (ev_window_cmd_continuous), TRUE },
- { "ViewDual", NULL, N_("_Dual"), NULL,
+ { "ViewDual", EV_STOCK_VIEW_DUAL, N_("_Dual"), NULL,
N_("Show two pages at once"),
G_CALLBACK (ev_window_cmd_dual), FALSE },
{ "ViewFullscreen", NULL, N_("_Fullscreen"), "F11",
gint x, gint y, GtkSelectionData *selection_data,
guint info, guint time, gpointer gdata)
{
- GList *uri_list = NULL;
+ GList *uri_list = NULL;
+ GSList *uris = NULL;
+ gchar *uri;
uri_list = gnome_vfs_uri_list_parse ((gchar *) selection_data->data);
if (uri_list) {
- ev_window_open_uri_list (EV_WINDOW (widget), uri_list);
-
+ while (uri_list) {
+ uri = gnome_vfs_uri_to_string (uri_list->data, GNOME_VFS_URI_HIDE_NONE);
+ uris = g_slist_append (uris, (gpointer) uri);
+
+ uri_list = g_list_next (uri_list);
+ }
+
gnome_vfs_uri_list_free (uri_list);
+
+ ev_window_open_uri_list (EV_WINDOW (widget), uris);
+
+ g_slist_free (uris);
gtk_drag_finish (context, TRUE, FALSE, time);
}
sidebar_widget = ev_sidebar_thumbnails_new ();
tree_view = ev_sidebar_thumbnails_get_treeview
(EV_SIDEBAR_THUMBNAILS (sidebar_widget));
- enable_view_actions_for_widget (ev_window, tree_view);
+ //enable_view_actions_for_widget (ev_window, tree_view);
gtk_widget_show (sidebar_widget);
ev_sidebar_add_page (EV_SIDEBAR (ev_window->priv->sidebar),
sidebar_widget);
"notify::sizing-mode",
G_CALLBACK (ev_window_sizing_mode_changed_cb),
ev_window);
+ g_signal_connect (ev_window->priv->view,
+ "notify::zoom",
+ G_CALLBACK (ev_window_zoom_changed_cb),
+ ev_window);
- ev_window->priv->statusbar = gtk_statusbar_new ();
+ ev_window->priv->statusbar = ev_statusbar_new ();
gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
ev_window->priv->statusbar,
FALSE, TRUE, 0);
- ev_window->priv->help_message_cid = gtk_statusbar_get_context_id
- (GTK_STATUSBAR (ev_window->priv->statusbar), "help_message");
- ev_window->priv->view_message_cid = gtk_statusbar_get_context_id
- (GTK_STATUSBAR (ev_window->priv->statusbar), "view_message");
-
+
ev_window->priv->find_bar = egg_find_bar_new ();
gtk_box_pack_end (GTK_BOX (ev_window->priv->main_box),
ev_window->priv->find_bar,
ev_window_sizing_mode_changed_cb (EV_VIEW (ev_window->priv->view), NULL, ev_window);
update_action_sensitivity (ev_window);
}
+
https://www.fi.muni.cz/~kas/git / evince.git / blobdiff