* Copyright (C) 2004 Martin Kretzschmar
* Copyright (C) 2004 Red Hat, Inc.
* Copyright (C) 2000, 2001, 2002, 2003, 2004 Marco Pesenti Gritti
- * Copyright (C) 2003, 2004, 2005 Christian Persch
+ * Copyright © 2003, 2004, 2005, 2009 Christian Persch
*
* Author:
* Martin Kretzschmar <martink@gnome.org>
#include <glib/gi18n.h>
#include <gio/gio.h>
#include <gtk/gtk.h>
-#if GTK_CHECK_VERSION (2, 14, 0)
-#include <gtk/gtkunixprint.h>
-#else
-#include <gtk/gtkprintunixdialog.h>
-#endif
+
#ifdef WITH_GCONF
#include <gconf/gconf-client.h>
#endif
#include "ev-jobs.h"
#include "ev-message-area.h"
#include "ev-metadata-manager.h"
-#include "ev-mount-operation.h"
#include "ev-navigation-action.h"
#include "ev-open-recent-action.h"
#include "ev-page-action.h"
EV_CHROME_RAISE_TOOLBAR = 1 << 3,
EV_CHROME_FULLSCREEN_TOOLBAR = 1 << 4,
EV_CHROME_SIDEBAR = 1 << 5,
- EV_CHROME_PREVIEW_TOOLBAR = 1 << 6,
EV_CHROME_NORMAL = EV_CHROME_MENUBAR | EV_CHROME_TOOLBAR | EV_CHROME_SIDEBAR
} EvChrome;
GtkWidget *sidebar_attachments;
GtkWidget *sidebar_layers;
+ /* Menubar accels */
+ guint menubar_accel_keyval;
+ GdkModifierType menubar_accel_modifier;
+
/* Progress Messages */
guint progress_idle;
GCancellable *progress_cancellable;
/* Presentation mode */
guint presentation_timeout_id;
- /* Preview mode */
- GtkWidget *preview_toolbar;
- gchar *print_settings_file;
-
/* Popup view */
GtkWidget *view_popup;
EvLink *link;
char *uri;
glong uri_mtime;
char *local_uri;
- gboolean unlink_temp_file;
gboolean in_reload;
EvFileMonitor *monitor;
guint setup_document_idle;
/* Printing */
GQueue *print_queue;
- GtkPrinter *printer;
GtkPrintSettings *print_settings;
GtkPageSetup *print_page_setup;
gboolean close_after_print;
EvWindowPageMode page_mode);
static void ev_window_load_job_cb (EvJob *job,
gpointer data);
-static void ev_window_reload_document (EvWindow *window);
+static void ev_window_reload_document (EvWindow *window,
+ EvLinkDest *dest);
static void ev_window_reload_job_cb (EvJob *job,
EvWindow *window);
static void ev_window_set_icon_from_thumbnail (EvJobThumbnail *job,
gboolean unfullscreen_window);
static void ev_window_cmd_view_presentation (GtkAction *action,
EvWindow *window);
-static void ev_window_run_preview (EvWindow *window);
static void ev_view_popup_cmd_open_link (GtkAction *action,
EvWindow *window);
static void ev_view_popup_cmd_open_link_new_window (GtkAction *action,
static void find_bar_search_changed_cb (EggFindBar *find_bar,
GParamSpec *param,
EvWindow *ev_window);
-static void ev_window_do_preview_print (EvWindow *window);
static void ev_window_load_file_remote (EvWindow *ev_window,
GFile *source_file);
static void ev_window_media_player_key_pressed (EvWindow *window,
if (document) {
has_document = TRUE;
- info = ev_page_cache_get_info (ev_window->priv->page_cache);
+ info = ev_document_get_info (document);
}
if (has_document && ev_window->priv->page_cache) {
- has_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0;
+ has_pages = ev_document_get_n_pages (document) > 0;
}
if (!info || info->fields_mask == 0) {
ok_to_copy = (info->permissions & EV_DOCUMENT_PERMISSIONS_OK_TO_COPY);
}
- if (has_document && !EV_IS_FILE_EXPORTER(document))
+ if (has_document && !ev_print_operation_exists_for_document(document))
ok_to_print = FALSE;
#ifdef WITH_GCONF
/* File menu */
ev_window_set_action_sensitive (ev_window, "FileOpenCopy", has_document);
ev_window_set_action_sensitive (ev_window, "FileSaveAs", has_document && ok_to_copy);
- ev_window_set_action_sensitive (ev_window, "FilePrintSetup", has_pages && ok_to_print);
+ ev_window_set_action_sensitive (ev_window, "FilePageSetup", has_pages && ok_to_print);
ev_window_set_action_sensitive (ev_window, "FilePrint", has_pages && ok_to_print);
ev_window_set_action_sensitive (ev_window, "FileProperties", has_document && has_properties);
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, FALSE);
- ev_window_set_action_sensitive (ev_window, "PreviewPrint", has_pages && ok_to_print);
ev_window_update_actions (ev_window);
}
if (ev_window->priv->document && ev_window->priv->page_cache) {
page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
- n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
+ n_pages = ev_document_get_n_pages (ev_window->priv->document);
has_pages = n_pages > 0;
}
has_pages && can_find_in_page);
ev_window_set_action_sensitive (ev_window, "EditFindPrevious",
has_pages && can_find_in_page);
+ ev_window_set_action_sensitive (ev_window, "F3",
+ has_pages && can_find_in_page);
presentation_mode = ev_view_get_presentation (view);
EvWindowPrivate *priv = window->priv;
gboolean menubar, toolbar, findbar, fullscreen_toolbar, sidebar;
gboolean fullscreen_mode, presentation, fullscreen;
- gboolean preview_toolbar;
presentation = ev_view_get_presentation (EV_VIEW (priv->view));
fullscreen = ev_view_get_fullscreen (EV_VIEW (priv->view));
(priv->chrome & EV_CHROME_RAISE_TOOLBAR) != 0) && fullscreen;
findbar = (priv->chrome & EV_CHROME_FINDBAR) != 0;
sidebar = (priv->chrome & EV_CHROME_SIDEBAR) != 0 && !presentation;
- preview_toolbar = (priv->chrome& EV_CHROME_PREVIEW_TOOLBAR);
set_widget_visibility (priv->menubar, menubar);
set_widget_visibility (priv->toolbar, toolbar);
set_widget_visibility (priv->find_bar, findbar);
set_widget_visibility (priv->sidebar, sidebar);
- 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_toolbar != NULL) {
set_widget_visibility (priv->fullscreen_toolbar, fullscreen_toolbar);
} else {
dest = ev_link_dest_new_page (page);
action = ev_link_action_new_dest (dest);
- page_label = ev_page_cache_get_page_label (window->priv->page_cache, page);
+ page_label = ev_document_get_page_label (window->priv->document, page);
}
if (!page_label)
gint n_pages;
gint new_page;
- n_pages = ev_page_cache_get_n_pages (window->priv->page_cache);
+ n_pages = ev_document_get_n_pages (window->priv->document);
new_page = CLAMP (g_value_get_int (&page), 0, n_pages - 1);
ev_page_cache_set_current_page (window->priv->page_cache,
new_page);
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;
+ gdouble document_width;
+ gdouble document_height;
GdkScreen *screen;
gint request_width;
gint request_height;
- ev_page_cache_get_max_width (window->priv->page_cache,
- 0, 1.0,
- &document_width);
- ev_page_cache_get_max_height (window->priv->page_cache,
- 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;
+ ev_document_get_max_page_size (window->priv->document,
+ &document_width, &document_height);
+
+ request_width = (gint)(g_value_get_double (&width_ratio) * document_width + 0.5);
+ request_height = (gint)(g_value_get_double (&height_ratio) * document_height + 0.5);
screen = gtk_window_get_screen (GTK_WINDOW (window));
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),
- request_width,
- request_height);
+
+ if (request_width > 0 && request_height > 0) {
+ gtk_window_resize (GTK_WINDOW (window),
+ request_width,
+ request_height);
+ }
g_value_unset (&width_ratio);
g_value_unset (&height_ratio);
}
static void
ev_window_refresh_window_thumbnail (EvWindow *ev_window, int rotation)
{
- gint page_width, page_height;
+ gdouble page_width;
gdouble scale;
EvDocument *document = ev_window->priv->document;
-
+
if (!EV_IS_DOCUMENT_THUMBNAILS (document) ||
- ev_page_cache_get_n_pages (ev_window->priv->page_cache) <= 0) {
+ ev_document_get_n_pages (document) <= 0 ||
+ !ev_document_check_dimensions (document)) {
return;
}
-
+
ev_window_clear_thumbnail_job (ev_window);
-
- ev_page_cache_get_size (ev_window->priv->page_cache,
- 0, 0, 1.0,
- &page_width, &page_height);
- scale = (gdouble)128 / (gdouble)page_width;
-
+
+ ev_document_get_page_size (document, 0, &page_width, NULL);
+ scale = 128. / page_width;
+
ev_window->priv->thumbnail_job = ev_job_thumbnail_new (document, 0, rotation, scale);
g_signal_connect (ev_window->priv->thumbnail_job, "finished",
G_CALLBACK (ev_window_set_icon_from_thumbnail),
ev_window->priv->document);
}
- info = ev_page_cache_get_info (ev_window->priv->page_cache);
+ info = ev_document_get_info (document);
update_document_mode (ev_window, info->mode);
+ gtk_widget_grab_focus (ev_window->priv->view);
+
return FALSE;
}
g_signal_connect (ev_window->priv->page_cache, "history-changed",
G_CALLBACK (history_changed_cb), ev_window);
- if (ev_page_cache_get_n_pages (ev_window->priv->page_cache) > 0) {
- ev_view_set_document (view, document);
- } else {
+ if (ev_window->priv->in_reload && ev_window->priv->dest) {
+ gint page;
+
+ /* Restart the current page */
+ page = CLAMP (ev_link_dest_get_page (ev_window->priv->dest),
+ 0,
+ ev_document_get_n_pages (document) - 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;
+ }
+
+ if (ev_document_get_n_pages (document) <= 0) {
ev_window_warning_message (ev_window, "%s",
_("The document contains no pages"));
+ } else if (!ev_document_check_dimensions (document)) {
+ ev_window_warning_message (ev_window, "%s",
+ _("The document contains only empty pages"));
+ } else {
+ ev_view_set_document (view, document);
}
if (ev_window->priv->setup_document_idle > 0)
g_source_remove (ev_window->priv->setup_document_idle);
+
ev_window->priv->setup_document_idle = g_idle_add ((GSourceFunc)ev_window_setup_document, ev_window);
}
ev_window_document_changed (EvWindow *ev_window,
gpointer user_data)
{
- ev_window_reload_document (ev_window);
+ ev_window_reload_document (ev_window, NULL);
}
static void
}
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)
+ev_window_clear_temp_symlink (EvWindow *ev_window)
{
GFile *file, *tempdir;
return;
file = g_file_new_for_uri (ev_window->priv->uri);
- tempdir = g_file_new_for_path (g_get_tmp_dir ());
+ tempdir = g_file_new_for_path (ev_tmp_dir ());
if (g_file_has_prefix (file, tempdir)) {
- g_file_delete (file, NULL, NULL);
+ GFileInfo *file_info;
+ GError *error = NULL;
+
+ file_info = g_file_query_info (file,
+ G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK,
+ G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
+ NULL, &error);
+ if (file_info) {
+ if (g_file_info_get_is_symlink (file_info))
+ g_file_delete (file, NULL, NULL);
+ g_object_unref (file_info);
+ } else {
+ g_warning ("Error deleting temp symlink: %s\n", error->message);
+ g_error_free (error);
+ }
}
g_object_unref (file);
g_object_unref (tempdir);
}
+static void
+ev_window_handle_link (EvWindow *ev_window,
+ EvLinkDest *dest)
+{
+ if (dest) {
+ EvLink *link;
+ EvLinkAction *link_action;
+
+ link_action = ev_link_action_new_dest (dest);
+ link = ev_link_new (NULL, link_action);
+ ev_view_handle_link (EV_VIEW (ev_window->priv->view), link);
+ g_object_unref (link);
+ }
+}
+
/* This callback will executed when load job will be finished.
*
* Since the flow of the error dialog is very confusing, we assume that both
ev_window_set_document (ev_window, document);
setup_document_from_metadata (ev_window);
-
- if (ev_window->priv->window_mode != EV_WINDOW_MODE_PREVIEW) {
- setup_view_from_metadata (ev_window);
- }
+ setup_view_from_metadata (ev_window);
- if (!ev_window->priv->unlink_temp_file) {
- ev_window_add_recent (ev_window, ev_window->priv->uri);
- }
+ ev_window_add_recent (ev_window, ev_window->priv->uri);
ev_window_title_set_type (ev_window->priv->title,
EV_WINDOW_TITLE_DOCUMENT);
flags);
}
- if (ev_window->priv->dest) {
- EvLink *link;
- EvLinkAction *link_action;
-
- 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;
- }
+ ev_window_handle_link (ev_window, ev_window->priv->dest);
+ /* 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 (ev_window->priv->window_mode) {
case EV_WINDOW_MODE_FULLSCREEN:
case EV_WINDOW_MODE_PRESENTATION:
ev_window_run_presentation (ev_window);
break;
- case EV_WINDOW_MODE_PREVIEW:
- ev_window_run_preview (ev_window);
- break;
default:
break;
}
EvWindow *ev_window)
{
GtkWidget *widget;
- gint page;
+ EvLinkDest *dest = NULL;
if (ev_job_is_failed (job)) {
ev_window_clear_reload_job (ev_window);
return;
}
-
+
+ if (ev_window->priv->dest) {
+ dest = g_object_ref (ev_window->priv->dest);
+ }
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;
-
+ ev_window_handle_link (ev_window, dest);
+
/* 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)) {
{
GtkWidget *area;
gchar *text;
+ gchar *display_name;
if (ev_window->priv->message_area)
return FALSE;
-
- text = g_strdup_printf (_("Loading document from %s"),
- ev_window->priv->uri);
+
+ display_name = escape_uri_for_display (ev_window->priv->uri);
+ text = g_strdup_printf (_("Loading document from “%s”"),
+ display_name);
+
area = ev_progress_message_area_new (GTK_STOCK_OPEN,
text,
GTK_STOCK_CLOSE,
ev_window);
gtk_widget_show (area);
ev_window_set_message_area (ev_window, area);
+
g_free (text);
+ g_free (display_name);
return FALSE;
}
return;
}
- if (error->domain == G_IO_ERROR &&
- error->code == G_IO_ERROR_NOT_MOUNTED) {
+ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) {
GMountOperation *operation;
- operation = ev_mount_operation_new (GTK_WINDOW (ev_window));
+ operation = gtk_mount_operation_new (GTK_WINDOW (ev_window));
g_file_mount_enclosing_volume (source,
G_MOUNT_MOUNT_NONE,
operation, NULL,
(GAsyncReadyCallback)mount_volume_ready_cb,
ev_window);
g_object_unref (operation);
- } else if (error->domain == G_IO_ERROR &&
- error->code == G_IO_ERROR_CANCELLED) {
+ } else if (g_error_matches (error, G_IO_ERROR, 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);
const char *uri,
EvLinkDest *dest,
EvWindowRunMode mode,
- const gchar *search_string,
- gboolean unlink_temp_file,
- const gchar *print_settings)
+ const gchar *search_string)
{
GFile *source_file;
if (ev_window->priv->uri &&
g_ascii_strcasecmp (ev_window->priv->uri, uri) == 0) {
- ev_window_reload_document (ev_window);
+ ev_window_reload_document (ev_window, dest);
return;
}
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;
ev_window->priv->window_mode = mode;
- 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);
g_file_copy_finish (remote, async_result, &error);
if (error) {
- if (error->domain != G_IO_ERROR ||
- error->code != G_IO_ERROR_CANCELLED)
+ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
ev_window_error_message (ev_window, error,
"%s", _("Failed to reload document."));
g_error_free (error);
}
static void
-ev_window_reload_document (EvWindow *ev_window)
+ev_window_reload_document (EvWindow *ev_window,
+ EvLinkDest *dest)
{
gint page;
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);
+ ev_window->priv->dest = dest ? g_object_ref (dest) : ev_link_dest_new_page (page);
if (ev_window->priv->local_uri) {
ev_window_reload_remote (ev_window);
gint response_id,
EvWindow *ev_window)
{
- gchar *uri;
-
if (response_id == GTK_RESPONSE_OK) {
GSList *uris;
+ gchar *uri;
uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (chooser));
ev_application_open_uri_list (EV_APP, uris,
gtk_window_get_screen (GTK_WINDOW (ev_window)),
GDK_CURRENT_TIME);
-
- g_slist_foreach (uris, (GFunc)g_free, NULL);
+
+ g_slist_foreach (uris, (GFunc)g_free, NULL);
g_slist_free (uris);
- }
- uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (chooser));
- ev_application_set_chooser_uri (EV_APP, uri);
- g_free (uri);
+ uri = gtk_file_chooser_get_current_folder_uri (GTK_FILE_CHOOSER (chooser));
+ ev_application_set_filechooser_uri (EV_APP,
+ GTK_FILE_CHOOSER_ACTION_OPEN,
+ uri);
+ g_free (uri);
+ }
gtk_widget_destroy (chooser);
}
static void
ev_window_cmd_file_open (GtkAction *action, EvWindow *window)
{
- GtkWidget *chooser;
+ GtkWidget *chooser;
+ const gchar *default_uri;
+ gchar *parent_uri = NULL;
chooser = gtk_file_chooser_dialog_new (_("Open Document"),
GTK_WINDOW (window),
ev_document_factory_add_filters (chooser, NULL);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (chooser), TRUE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), FALSE);
- if (ev_application_get_chooser_uri (EV_APP) != NULL) {
- gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
- ev_application_get_chooser_uri (EV_APP));
- } else if (window->priv->uri != NULL) {
- gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (chooser),
- window->priv->uri);
+
+ default_uri = ev_application_get_filechooser_uri (EV_APP, GTK_FILE_CHOOSER_ACTION_OPEN);
+ if (!default_uri && window->priv->uri) {
+ GFile *file, *parent;
+
+ file = g_file_new_for_uri (window->priv->uri);
+ parent = g_file_get_parent (file);
+ if (parent) {
+ parent_uri = g_file_get_uri (parent);
+ default_uri = parent_uri;
+ g_object_unref (parent);
+ }
+ g_object_unref (file);
+ }
+
+ if (default_uri) {
+ gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (chooser), default_uri);
} else {
const gchar *folder;
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser),
folder ? folder : g_get_home_dir ());
}
-
+ g_free (parent_uri);
+
g_signal_connect (chooser, "response",
G_CALLBACK (file_open_dialog_response_cb),
window);
static gchar *
ev_window_create_tmp_symlink (const gchar *filename, GError **error)
{
- gchar *tmp_filename = NULL;
- gchar *name;
- gint res;
- guint i = 0;
+ gchar *tmp_filename = NULL;
+ gchar *name;
+ guint i = 0;
+ GError *link_error = NULL;
+ GFile *tmp_file = NULL;
name = g_path_get_basename (filename);
if (tmp_filename)
g_free (tmp_filename);
+ if (tmp_file)
+ g_object_unref (tmp_file);
+ g_clear_error (&link_error);
basename = g_strdup_printf ("%s-%d", name, i++);
tmp_filename = g_build_filename (ev_tmp_dir (),
basename, NULL);
g_free (basename);
- } while ((res = symlink (filename, tmp_filename)) != 0 && errno == EEXIST);
-
- g_free (name);
+ tmp_file = g_file_new_for_path (tmp_filename);
+ } while (!g_file_make_symbolic_link (tmp_file, filename, NULL, &link_error) &&
+ g_error_matches (link_error, G_IO_ERROR, G_IO_ERROR_EXISTS));
- if (res != 0 && errno != EEXIST) {
- if (error) {
- *error = g_error_new (G_FILE_ERROR,
- g_file_error_from_errno (errno),
- _("Couldn't create symlink “%s”: %s"),
- tmp_filename, strerror (errno));
- }
+ g_free (name);
+ g_object_unref (tmp_file);
+ if (link_error) {
+ g_propagate_prefixed_error (error,
+ link_error,
+ _("Couldn't create symlink “%s”: "),
+ tmp_filename);
g_free (tmp_filename);
-
+
return NULL;
}
-
+
return tmp_filename;
}
dest,
0,
NULL,
- TRUE,
- NULL,
GDK_CURRENT_TIME);
g_free (symlink_uri);
}
ev_application_open_uri_at_dest (EV_APP, uri,
gtk_window_get_screen (GTK_WINDOW (window)),
- NULL, 0, NULL, FALSE, NULL,
- GDK_CURRENT_TIME);
+ NULL, 0, NULL, GDK_CURRENT_TIME);
}
static void
{
ev_application_open_uri_at_dest (EV_APP, uri,
gtk_window_get_screen (GTK_WINDOW (window)),
- NULL, 0, NULL, FALSE, NULL,
- GDK_CURRENT_TIME);
+ NULL, 0, NULL, GDK_CURRENT_TIME);
}
static void
return;
}
- if (error->domain != G_IO_ERROR ||
- error->code != G_IO_ERROR_CANCELLED) {
+ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
gchar *name;
name = g_file_get_basename (dst);
EvWindow *ev_window)
{
gchar *uri;
-
+ GFile *file, *parent;
+
if (response_id != GTK_RESPONSE_OK) {
gtk_widget_destroy (fc);
return;
}
-
+
uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (fc));
+ file = g_file_new_for_uri (uri);
+ parent = g_file_get_parent (file);
+ g_object_unref (file);
+ if (parent) {
+ gchar *folder_uri;
+
+ folder_uri = g_file_get_uri (parent);
+ ev_application_set_filechooser_uri (EV_APP,
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ folder_uri);
+ g_free (folder_uri);
+ g_object_unref (parent);
+ }
+
/* 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,
uri, ev_window->priv->uri);
GtkWidget *fc;
gchar *base_name;
GFile *file;
- const gchar *folder;
+ const gchar *default_uri;
fc = gtk_file_chooser_dialog_new (
_("Save a Copy"),
ev_document_factory_add_filters (fc, ev_window->priv->document);
gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (fc),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
file = g_file_new_for_uri (ev_window->priv->uri);
base_name = g_file_get_basename (file);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (fc), base_name);
-
- folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
- gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc),
- folder ? folder : g_get_home_dir ());
-
+
+ default_uri = ev_application_get_filechooser_uri (EV_APP, GTK_FILE_CHOOSER_ACTION_SAVE);
+ if (default_uri) {
+ gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (fc), default_uri);
+ } else {
+ const gchar *folder;
+
+ folder = g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS);
+ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (fc),
+ folder ? folder : g_get_home_dir ());
+ }
+
g_object_unref (file);
g_free (base_name);
-
+
g_signal_connect (fc, "response",
G_CALLBACK (file_save_dialog_response_cb),
ev_window);
ev_window->priv->print_queue = g_queue_new ();
op = ev_print_operation_new (ev_window->priv->document);
+ if (!op) {
+ g_warning ("%s", "Printing is not supported for document\n");
+ return;
+ }
+
g_signal_connect (op, "begin_print",
G_CALLBACK (ev_window_print_operation_begin_print),
(gpointer)ev_window);
page_cache = ev_page_cache_get (ev_window->priv->document);
current_page = ev_page_cache_get_current_page (page_cache);
- document_last_page = ev_page_cache_get_n_pages (page_cache);
+ document_last_page = ev_document_get_n_pages (ev_window->priv->document);
if (!ev_window->priv->print_settings) {
ev_window->priv->print_settings = gtk_print_settings_copy (
ev_window_load_print_settings_from_metadata (ev_window);
}
+ if (!ev_window->priv->print_page_setup) {
+ ev_window->priv->print_page_setup = gtk_page_setup_copy (
+ ev_application_get_page_setup (EV_APP));
+ ev_window_load_print_page_setup_from_metadata (ev_window);
+ }
+
if (first_page != 1 || last_page != document_last_page) {
GtkPageRange range;
ev_print_operation_set_job_name (op, gtk_window_get_title (GTK_WINDOW (ev_window)));
ev_print_operation_set_current_page (op, current_page);
ev_print_operation_set_print_settings (op, ev_window->priv->print_settings);
- if (ev_window->priv->print_page_setup)
- ev_print_operation_set_default_page_setup (op, ev_window->priv->print_page_setup);
+ ev_print_operation_set_default_page_setup (op, ev_window->priv->print_page_setup);
ev_print_operation_run (op, GTK_WINDOW (ev_window));
}
static void
ev_window_print (EvWindow *window)
{
- EvPageCache *page_cache;
- gint last_page;
-
- 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, last_page);
+ ev_window_print_range (window, 1,
+ ev_document_get_n_pages (window->priv->document));
}
static void
GTK_RESPONSE_YES,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ GTK_RESPONSE_YES,
+ GTK_RESPONSE_NO,
+ GTK_RESPONSE_CANCEL,
+ -1);
g_signal_connect (dialog, "response",
G_CALLBACK (print_jobs_confirmation_dialog_response),
}
static void
-ev_window_run_preview (EvWindow *window)
+ev_window_setup_gtk_settings (EvWindow *window)
{
- GtkAction *action;
-
- if (!window->priv->preview_toolbar) {
- window->priv->preview_toolbar =
- gtk_ui_manager_get_widget (window->priv->ui_manager,
- "/PreviewToolbar");
+ GtkSettings *settings;
+ GdkScreen *screen;
+ gchar *menubar_accel_accel;
- 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);
- update_chrome_flag (window, EV_CHROME_MENUBAR, FALSE);
- update_chrome_flag (window, EV_CHROME_SIDEBAR, FALSE);
+ screen = gtk_window_get_screen (GTK_WINDOW (window));
+ settings = gtk_settings_get_for_screen (screen);
- update_chrome_flag (window, EV_CHROME_PREVIEW_TOOLBAR, TRUE);
-
- action = gtk_action_group_get_action (window->priv->action_group,
- "PreviewPrint");
- gtk_action_set_visible (action, TRUE);
+ g_object_get (settings,
+ "gtk-menu-bar-accel", &menubar_accel_accel,
+ NULL);
+ if (menubar_accel_accel != NULL && menubar_accel_accel[0] != '\0') {
+ gtk_accelerator_parse (menubar_accel_accel,
+ &window->priv->menubar_accel_keyval,
+ &window->priv->menubar_accel_modifier);
+ if (window->priv->menubar_accel_keyval == 0) {
+ g_warning ("Failed to parse menu bar accelerator '%s'\n",
+ menubar_accel_accel);
+ }
+ } else {
+ window->priv->menubar_accel_keyval = 0;
+ window->priv->menubar_accel_modifier = 0;
+ }
- update_chrome_visibility (window);
+ g_free (menubar_accel_accel);
}
static void
if (screen == old_screen)
return;
+ ev_window_setup_gtk_settings (window);
ev_view_set_screen_dpi (EV_VIEW (priv->view),
get_screen_dpi (GTK_WINDOW (window)));
static void
ev_window_cmd_go_last_page (GtkAction *action, EvWindow *ev_window)
{
- int n_pages;
-
g_return_if_fail (EV_IS_WINDOW (ev_window));
- n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
- ev_page_cache_set_current_page (ev_window->priv->page_cache, n_pages - 1);
+ ev_page_cache_set_current_page (ev_window->priv->page_cache,
+ ev_document_get_n_pages (ev_window->priv->document) - 1);
}
static void
g_return_if_fail (EV_IS_WINDOW (ev_window));
- n_pages = ev_page_cache_get_n_pages (ev_window->priv->page_cache);
+ n_pages = ev_document_get_n_pages (ev_window->priv->document);
current_page = ev_page_cache_get_current_page (ev_window->priv->page_cache);
if (current_page + 10 < n_pages)
static void
ev_window_cmd_view_reload (GtkAction *action, EvWindow *ev_window)
{
- ev_window_reload_document (ev_window);
+ ev_window_reload_document (ev_window, NULL);
}
static void
ev_view_autoscroll_start (EV_VIEW (ev_window->priv->view));
}
-#if GTK_CHECK_VERSION (2, 14, 0)
static void
ev_window_cmd_help_contents (GtkAction *action, EvWindow *ev_window)
{
g_error_free (error);
}
}
-#else /* !GTK_CHECK_VERSION (2, 14, 0) */
-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;
-
- int i;
-
- const char * const * langs = g_get_language_names ();
-
- for (i = 0; langs[i]; i++) {
- lang = langs[i];
- if (strchr (lang, '.')) {
- continue;
- }
-
- uri = g_build_filename(GNOMEDATADIR,
- "/gnome/help/" PACKAGE,
- lang,
- "/evince.xml",
- NULL);
-
- if (g_file_test (uri, G_FILE_TEST_EXISTS)) {
- break;
- }
- g_free (uri);
- uri = 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 ("%s", error->message);
- g_error_free (error);
- }
- g_free (command);
-}
-#endif /* GTK_CHECK_VERSION (2, 14, 0) */
static void
ev_window_cmd_leave_fullscreen (GtkAction *action, EvWindow *window)
ev_window_run_presentation (window);
}
-static gboolean
-ev_window_enumerate_printer_cb (GtkPrinter *printer,
- EvWindow *window)
-{
- EvWindowPrivate *priv = window->priv;
- const gchar *printer_name;
-
- printer_name = gtk_print_settings_get_printer (priv->print_settings);
- if ((printer_name
- && strcmp (printer_name, gtk_printer_get_name (printer)) == 0) ||
- (!printer_name && gtk_printer_is_default (printer))) {
- if (priv->printer)
- g_object_unref (priv->printer);
- priv->printer = g_object_ref (printer);
-
- /* Now that we have the printer, we'll start the print */
- ev_window_do_preview_print (window);
-
- return TRUE; /* we're done */
- }
-
- return FALSE; /* continue the enumeration */
-}
-
-static void
-ev_window_preview_print_finished (GtkPrintJob *print_job,
- EvWindow *window,
- GError *error)
-{
- if (error) {
- ev_window_error_message (window, error,
- "%s", _("Failed to print document"));
- }
-
- g_object_unref (print_job);
- gtk_widget_destroy (GTK_WIDGET (window));
-}
-
-static void
-ev_window_do_preview_print (EvWindow *window)
-{
- EvWindowPrivate *priv = window->priv;
- GtkPrintJob *job;
- gchar *filename;
- GError *error = NULL;
-
- g_assert (priv->print_settings != NULL);
- g_assert (priv->printer != NULL);
-
- job = gtk_print_job_new (gtk_window_get_title (GTK_WINDOW (window)),
- priv->printer,
- priv->print_settings,
- priv->print_page_setup);
-
- g_object_unref (priv->print_settings);
- priv->print_settings = NULL;
- g_object_unref (priv->print_page_setup);
- priv->print_page_setup = NULL;
- g_object_unref (priv->printer);
- priv->printer = NULL;
-
- filename = g_filename_from_uri (priv->local_uri ?
- priv->local_uri : 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 ("%s", error->message);
- g_error_free (error);
- }
-
- g_free (filename);
-
- gtk_widget_hide (GTK_WIDGET (window));
-}
-
-static void
-ev_window_cmd_preview_print (GtkAction *action, EvWindow *window)
-{
- EvWindowPrivate *priv = window->priv;
- GtkPrintSettings *print_settings;
- GtkPageSetup *page_setup;
- const gchar *print_settings_file = priv->print_settings_file;
-
- if (print_settings_file && g_file_test (print_settings_file, G_FILE_TEST_IS_REGULAR)) {
- GKeyFile *key_file;
- GError *error = NULL;
-
- key_file = g_key_file_new ();
- g_key_file_load_from_file (key_file,
- print_settings_file,
- G_KEY_FILE_KEEP_COMMENTS |
- G_KEY_FILE_KEEP_TRANSLATIONS,
- &error);
- if (!error) {
- print_settings =
- gtk_print_settings_new_from_key_file (key_file,
- "Print Settings",
- NULL);
- print_settings = print_settings ? print_settings : gtk_print_settings_new ();
-
- page_setup = gtk_page_setup_new_from_key_file (key_file,
- "Page Setup",
- NULL);
- page_setup = page_setup ? page_setup : gtk_page_setup_new ();
- } else {
- print_settings = gtk_print_settings_new ();
- page_setup = gtk_page_setup_new ();
- g_error_free (error);
- }
-
- g_key_file_free (key_file);
- } else {
- print_settings = gtk_print_settings_new ();
- page_setup = gtk_page_setup_new ();
- }
-
- if (priv->print_settings)
- g_object_unref (priv->print_settings);
- priv->print_settings = print_settings;
- if (priv->print_page_setup)
- g_object_unref (priv->print_page_setup);
- priv->print_page_setup = page_setup;
-
- gtk_enumerate_printers ((GtkPrinterFunc) ev_window_enumerate_printer_cb,
- window, NULL, FALSE);
-}
-
static void
ev_window_cmd_escape (GtkAction *action, EvWindow *window)
{
enum_value->value_nick);
}
+static void
+ev_window_set_view_size (EvWindow *window)
+{
+ gint width, height;
+ GtkRequisition vsb_requisition;
+ GtkRequisition hsb_requisition;
+ gint scrollbar_spacing;
+ GtkWidget *scrolled_window = window->priv->scrolled_window;
+
+ if (!window->priv->view)
+ return;
+
+ /* Calculate the width available for the content */
+ width = scrolled_window->allocation.width;
+ height = scrolled_window->allocation.height;
+
+ if (gtk_scrolled_window_get_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window)) == GTK_SHADOW_IN) {
+ width -= 2 * window->priv->view->style->xthickness;
+ height -= 2 * window->priv->view->style->ythickness;
+ }
+
+ gtk_widget_size_request (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar,
+ &vsb_requisition);
+ gtk_widget_size_request (GTK_SCROLLED_WINDOW (scrolled_window)->hscrollbar,
+ &hsb_requisition);
+ gtk_widget_style_get (scrolled_window,
+ "scrollbar_spacing",
+ &scrollbar_spacing,
+ NULL);
+
+ ev_view_set_zoom_for_size (EV_VIEW (window->priv->view),
+ MAX (1, width),
+ MAX (1, height),
+ vsb_requisition.width + scrollbar_spacing,
+ hsb_requisition.height + scrollbar_spacing);
+}
+
static void
ev_window_sizing_mode_changed_cb (EvView *view, GParamSpec *pspec,
EvWindow *ev_window)
{
- GtkWidget *scrolled_window;
EvSizingMode sizing_mode;
g_object_get (ev_window->priv->view,
"sizing-mode", &sizing_mode,
NULL);
- scrolled_window = ev_window->priv->scrolled_window;
-
- g_signal_handlers_disconnect_by_func (ev_window->priv->view, ev_view_update_view_size, scrolled_window);
-
- if (sizing_mode != EV_SIZING_FREE)
- ev_view_update_view_size (EV_VIEW (ev_window->priv->view),
- GTK_SCROLLED_WINDOW (scrolled_window));
-
- switch (sizing_mode) {
- case EV_SIZING_BEST_FIT:
- g_object_set (G_OBJECT (scrolled_window),
- "hscrollbar-policy", GTK_POLICY_NEVER,
- "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
- NULL);
- g_signal_connect (ev_window->priv->view, "zoom_invalid",
- G_CALLBACK (ev_view_update_view_size),
- scrolled_window);
- break;
- case EV_SIZING_FIT_WIDTH:
- g_object_set (G_OBJECT (scrolled_window),
- "hscrollbar-policy", GTK_POLICY_NEVER,
- "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
- NULL);
- g_signal_connect (ev_window->priv->view, "zoom_invalid",
- G_CALLBACK (ev_view_update_view_size),
- scrolled_window);
- break;
- case EV_SIZING_FREE:
- g_object_set (G_OBJECT (scrolled_window),
- "hscrollbar-policy", GTK_POLICY_AUTOMATIC,
- "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
- NULL);
- break;
- }
+ g_object_set (ev_window->priv->scrolled_window,
+ "hscrollbar-policy",
+ sizing_mode == EV_SIZING_FREE ?
+ GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER,
+ "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
+ NULL);
update_sizing_buttons (ev_window);
save_sizing_mode (ev_window);
"Bryan Clark <clarkbw@gnome.org>",
"Carlos Garcia Campos <carlosgc@gnome.org>",
"Wouter Bolsterlee <wbolster@gnome.org>",
+ "Christian Persch <chpe" "\100" "gnome.org>",
NULL
};
"name", _("Evince"),
"version", VERSION,
"copyright",
- _("\xc2\xa9 1996-2007 The Evince authors"),
+ _("© 1996–2009 The Evince authors"),
"license", license_trans,
"website", "http://www.gnome.org/projects/evince",
"comments", comments,
if (search_string && search_string[0]) {
ev_window->priv->find_job = ev_job_find_new (ev_window->priv->document,
ev_page_cache_get_current_page (ev_window->priv->page_cache),
- ev_page_cache_get_n_pages (ev_window->priv->page_cache),
+ ev_document_get_n_pages (ev_window->priv->document),
search_string,
case_sensitive);
g_signal_connect (ev_window->priv->find_job, "finished",
} else {
mode = EV_SIZING_FREE;
}
-
+
ev_view_set_sizing_mode (EV_VIEW (ev_window->priv->view), mode);
if (mode == EV_SIZING_FREE) {
guint time)
{
- EvWindow *window = EV_WINDOW (widget);
- gchar **uris;
- gint i = 0;
- GSList *uri_list = NULL;
+ EvWindow *window = EV_WINDOW (widget);
+ gchar **uris;
+ gint i = 0;
+ GSList *uri_list = NULL;
+ GtkWidget *source;
+
+ source = gtk_drag_get_source_widget (context);
+ if (source && widget == gtk_widget_get_toplevel (source)) {
+ gtk_drag_finish (context, FALSE, FALSE, time);
+ return;
+ }
uris = gtk_selection_data_get_uris (selection_data);
if (!uris) {
ev_window_close_dialogs (window);
- if (window->priv->printer) {
- g_object_unref (window->priv->printer);
- window->priv->printer = NULL;
- }
-
if (window->priv->print_settings) {
g_object_unref (window->priv->print_settings);
window->priv->print_settings = NULL;
}
if (priv->uri) {
- if (priv->unlink_temp_file)
- ev_window_clear_temp_file (window);
+ /* Delete the uri if it's a temp symlink (open a copy) */
+ ev_window_clear_temp_symlink (window);
g_free (priv->uri);
priv->uri = NULL;
}
priv->history = NULL;
}
- 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;
G_OBJECT_CLASS (ev_window_parent_class)->dispose (object);
}
+static void
+menubar_deactivate_cb (GtkWidget *menubar,
+ EvWindow *window)
+{
+ g_signal_handlers_disconnect_by_func (menubar,
+ G_CALLBACK (menubar_deactivate_cb),
+ window);
+
+ gtk_menu_shell_deselect (GTK_MENU_SHELL (menubar));
+
+ update_chrome_visibility (window);
+}
+
+static gboolean
+ev_window_key_press_event (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ EvWindow *ev_window = EV_WINDOW (widget);
+ EvWindowPrivate *priv = ev_window->priv;
+ gboolean handled = FALSE;
+
+ /* Propagate the event to the view first
+ * It's needed to be able to type in
+ * annot popups windows
+ */
+ if (priv->view) {
+ g_object_ref (priv->view);
+ if (GTK_WIDGET_IS_SENSITIVE (priv->view))
+ handled = gtk_widget_event (priv->view, (GdkEvent*) event);
+ g_object_unref (priv->view);
+ }
+
+ if (!handled && !ev_view_get_presentation (EV_VIEW (priv->view))) {
+ guint modifier = event->state & gtk_accelerator_get_default_mod_mask ();
+
+ if (priv->menubar_accel_keyval != 0 &&
+ event->keyval == priv->menubar_accel_keyval &&
+ modifier == priv->menubar_accel_modifier) {
+ if (!GTK_WIDGET_VISIBLE (priv->menubar)) {
+ g_signal_connect (priv->menubar, "deactivate",
+ G_CALLBACK (menubar_deactivate_cb),
+ ev_window);
+
+ gtk_widget_show (priv->menubar);
+ gtk_menu_shell_select_first (GTK_MENU_SHELL (priv->menubar),
+ FALSE);
+
+ handled = TRUE;
+ }
+ }
+ }
+
+ if (!handled)
+ handled = GTK_WIDGET_CLASS (ev_window_parent_class)->key_press_event (widget, event);
+
+ return handled;
+}
+
static void
ev_window_class_init (EvWindowClass *ev_window_class)
{
g_object_class->dispose = ev_window_dispose;
g_object_class->finalize = ev_window_finalize;
+ widget_class->key_press_event = ev_window_key_press_event;
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;
{ "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), "<control>S",
N_("Save a copy of the current document"),
G_CALLBACK (ev_window_cmd_save_as) },
- { "FilePrintSetup", NULL, N_("Print Set_up..."), NULL,
+ { "FilePageSetup", GTK_STOCK_PAGE_SETUP, N_("Page Set_up..."), NULL,
N_("Setup the page settings for printing"),
G_CALLBACK (ev_window_cmd_file_print_setup) },
{ "FilePrint", GTK_STOCK_PRINT, N_("_Print..."), "<control>P",
G_CALLBACK (ev_window_cmd_edit_find_previous) },
{ "EditToolbar", NULL, N_("T_oolbar"), NULL, NULL,
G_CALLBACK (ev_window_cmd_edit_toolbar) },
- { "EditRotateLeft", EV_STOCK_ROTATE_LEFT, N_("Rotate _Left"), "<alt>Left", NULL,
+ { "EditRotateLeft", EV_STOCK_ROTATE_LEFT, N_("Rotate _Left"), "<control>Left", NULL,
G_CALLBACK (ev_window_cmd_edit_rotate_left) },
- { "EditRotateRight", EV_STOCK_ROTATE_RIGHT, N_("Rotate _Right"), "<alt>Right", NULL,
+ { "EditRotateRight", EV_STOCK_ROTATE_RIGHT, N_("Rotate _Right"), "<control>Right", NULL,
G_CALLBACK (ev_window_cmd_edit_rotate_right) },
/* View menu */
{ "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", "",
G_CALLBACK (ev_window_cmd_escape) },
{ "Slash", GTK_STOCK_FIND, NULL, "slash", NULL,
G_CALLBACK (ev_window_cmd_edit_find) },
+ { "F3", NULL, "", "F3", NULL,
+ G_CALLBACK (ev_window_cmd_edit_find_next) },
{ "PageDown", NULL, "", "Page_Down", NULL,
G_CALLBACK (ev_window_cmd_scroll_forward) },
{ "PageUp", NULL, "", "Page_Up", NULL,
{
char *uri = window->priv->uri;
GdkWindowState state;
- int x, y, width, height, document_width, document_height;
+ gdouble document_width, document_height;
state = gdk_window_get_state (GTK_WIDGET (window)->window);
if (!(state & GDK_WINDOW_STATE_FULLSCREEN)) {
- gtk_window_get_position (GTK_WINDOW (window), &x, &y);
- gtk_window_get_size (GTK_WINDOW (window), &width, &height);
-
- if (!ev_window_is_empty (window) && window->priv->page_cache) {
- ev_page_cache_get_max_width (window->priv->page_cache,
- 0, 1.0,
- &document_width);
- ev_page_cache_get_max_height (window->priv->page_cache,
- 0, 1.0,
- &document_height);
- ev_metadata_manager_set_double (uri, "window_width_ratio",
- (double)width / document_width);
- ev_metadata_manager_set_double (uri, "window_height_ratio",
- (double)height / document_height);
-
- ev_metadata_manager_set_int (uri, "window_x", x);
- ev_metadata_manager_set_int (uri, "window_y", y);
- ev_metadata_manager_set_int (uri, "window_width", width);
- ev_metadata_manager_set_int (uri, "window_height", height);
+ if (!ev_window_is_empty (window) && window->priv->document) {
+ ev_document_get_max_page_size (window->priv->document,
+ &document_width, &document_height);
+ ev_metadata_manager_set_double (uri, "window_width_ratio",
+ (double)event->width / document_width);
+ ev_metadata_manager_set_double (uri, "window_height_ratio",
+ (double)event->height / document_height);
+
+ ev_metadata_manager_set_int (uri, "window_x", event->x);
+ ev_metadata_manager_set_int (uri, "window_y", event->y);
+ ev_metadata_manager_set_int (uri, "window_width", event->width);
+ ev_metadata_manager_set_int (uri, "window_height", event->height);
}
}
GAppInfo *app_info;
GFile *file;
GList file_list = {NULL};
- GAppLaunchContext *context = NULL;
+ GAppLaunchContext *context;
GError *error = NULL;
if (filename == NULL)
return;
}
-#if GTK_CHECK_VERSION (2, 14, 0)
context = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
gtk_window_get_screen (GTK_WINDOW (window)));
gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context), GDK_CURRENT_TIME);
-#endif
file_list.data = file;
if (!g_app_info_launch (app_info, &file_list, context, &error)) {
const gchar *uri = ev_link_action_get_uri (action);
GError *error = NULL;
gboolean ret;
-#if GTK_CHECK_VERSION (2, 14, 0)
- GAppLaunchContext *context = NULL;
-#endif
+ GAppLaunchContext *context;
-#if GTK_CHECK_VERSION (2, 14, 0)
context = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
gdk_app_launch_context_set_screen (GDK_APP_LAUNCH_CONTEXT (context),
gtk_window_get_screen (GTK_WINDOW (window)));
gdk_app_launch_context_set_timestamp (GDK_APP_LAUNCH_CONTEXT (context),
GDK_CURRENT_TIME);
-#endif
if (!g_strstr_len (uri, strlen (uri), "://") &&
!g_str_has_prefix (uri, "mailto:")) {
ev_link_action_get_dest (action),
0,
NULL,
- FALSE,
- NULL,
GDK_CURRENT_TIME);
g_free (uri);
ev_window_cmd_edit_find (NULL, window);
} else if (g_ascii_strcasecmp (name, "Close") == 0) {
ev_window_cmd_file_close_window (NULL, window);
+ } else if (g_ascii_strcasecmp (name, "Print") == 0) {
+ ev_window_cmd_file_print (NULL, window);
} else {
g_warning ("Unimplemented named action: %s, please post a "
"bug report in Evince bugzilla "
format = get_gdk_pixbuf_format_by_extension (uri);
}
+ if (format == NULL && g_strrstr (uri, ".") == NULL) {
+ /* no extension found and no extension provided within uri */
+ format = get_gdk_pixbuf_format_by_extension (".png");
+ if (format == NULL) {
+ /* no .png support, try .jpeg */
+ format = get_gdk_pixbuf_format_by_extension (".jpeg");
+ }
+ }
+
if (format == NULL) {
ev_window_error_message (ev_window, NULL,
"%s",
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (fc),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (fc), GTK_RESPONSE_OK);
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (fc),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), FALSE);
GError *error = NULL;
GtkWidget *sidebar_widget;
GObject *mpkeys;
+ gchar *ui_path;
g_signal_connect (ev_window, "configure_event",
G_CALLBACK (window_configure_event_cb), NULL);
gtk_ui_manager_insert_action_group (ev_window->priv->ui_manager,
action_group, 0);
- if (!gtk_ui_manager_add_ui_from_file (ev_window->priv->ui_manager,
- DATADIR"/evince-ui.xml",
- &error)) {
+ ui_path = g_build_filename (ev_application_get_data_dir (EV_APP),
+ "evince-ui.xml", NULL);
+ if (!gtk_ui_manager_add_ui_from_file (
+ ev_window->priv->ui_manager, ui_path, &error))
+ {
g_warning ("building menus failed: %s", error->message);
g_error_free (error);
}
+ g_free (ui_path);
ev_window->priv->recent_manager = gtk_recent_manager_get_default ();
ev_window->priv->recent_action_group = NULL;
g_signal_connect_object (ev_window->priv->view, "handle-link",
G_CALLBACK (view_handle_link_cb),
ev_window, 0);
-
+ g_signal_connect_swapped (ev_window->priv->view, "zoom_invalid",
+ G_CALLBACK (ev_window_set_view_size),
+ ev_window);
g_signal_connect_object (ev_window->priv->view,
"popup",
G_CALLBACK (view_menu_popup_cb),
G_CALLBACK (ev_window_media_player_key_pressed),
ev_window);
}
-
+
/* Give focus to the document view */
gtk_widget_grab_focus (ev_window->priv->view);
/* Set it user interface params */
ev_window_setup_recent (ev_window);
+ ev_window_setup_gtk_settings (ev_window);
+
setup_chrome_from_metadata (ev_window);
set_chrome_actions (ev_window);
update_chrome_visibility (ev_window);