* 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>
-#include <gtk/gtkunixprint.h>
#ifdef WITH_GCONF
#include <gconf/gconf-client.h>
GtkWidget *sidebar_attachments;
GtkWidget *sidebar_layers;
+ /* Menubar accels */
+ guint menubar_accel_keyval;
+ GdkModifierType menubar_accel_modifier;
+
/* Progress Messages */
guint progress_idle;
GCancellable *progress_cancellable;
/* 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,
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
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;
}
set_widget_visibility (priv->sidebar, sidebar);
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));
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_page_cache_check_dimensions (ev_window->priv->page_cache)) {
+ 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;
}
/* 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_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_page_cache_get_n_pages (ev_window->priv->page_cache) <= 0) {
+ if (ev_document_get_n_pages (document) <= 0) {
ev_window_warning_message (ev_window, "%s",
_("The document contains no pages"));
- } else if (ev_page_cache_check_dimensions (ev_window->priv->page_cache)) {
+ } else if (!ev_document_check_dimensions (document)) {
ev_window_warning_message (ev_window, "%s",
_("The document contains only empty pages"));
} else {
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
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
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:
EvWindow *ev_window)
{
GtkWidget *widget;
+ 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);
-
+
+ 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)) {
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;
}
}
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);
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"),
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
}
}
+static void
+ev_window_setup_gtk_settings (EvWindow *window)
+{
+ GtkSettings *settings;
+ GdkScreen *screen;
+ gchar *menubar_accel_accel;
+
+ screen = gtk_window_get_screen (GTK_WINDOW (window));
+ settings = gtk_settings_get_for_screen (screen);
+
+ 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;
+ }
+
+ g_free (menubar_accel_accel);
+}
+
static void
ev_window_screen_changed (GtkWidget *widget,
GdkScreen *old_screen)
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
"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",
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;
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);
- gboolean handled = FALSE;
+ 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 (ev_window->priv->view) {
- g_object_ref (ev_window->priv->view);
- if (GTK_WIDGET_IS_SENSITIVE (ev_window->priv->view))
- handled = gtk_widget_event (ev_window->priv->view, (GdkEvent*) event);
- g_object_unref (ev_window->priv->view);
+ 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)
{
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);
}
}
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",
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_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);