]> www.fi.muni.cz Git - evince.git/blob - shell/ev-application.c
[shell] Use new methods to get page and page label from a link
[evince.git] / shell / ev-application.c
1 /* this file is part of evince, a gnome document viewer
2  *
3  *  Copyright (C) 2004 Martin Kretzschmar
4  *  Copyright © 2010 Christian Persch
5  *
6  *  Author:
7  *    Martin Kretzschmar <martink@gnome.org>
8  *
9  * Evince is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * Evince is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22  */
23
24
25 #include <config.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include <glib.h>
30 #include <glib/gi18n.h>
31 #include <glib/gstdio.h>
32 #include <gtk/gtk.h>
33 #ifdef GDK_WINDOWING_X11
34 #include <gdk/gdkx.h>
35 #endif
36 #include <unistd.h>
37
38 #include "totem-scrsaver.h"
39
40 #ifdef WITH_SMCLIENT
41 #include "eggsmclient.h"
42 #endif
43
44 #include "ev-application.h"
45 #include "ev-file-helpers.h"
46 #include "ev-stock-icons.h"
47
48 #ifdef ENABLE_DBUS
49 #include "ev-media-player-keys.h"
50 #endif /* ENABLE_DBUS */
51
52 struct _EvApplication {
53         GObject base_instance;
54
55         gchar *uri;
56
57         gchar *dot_dir;
58         gchar *data_dir;
59
60 #ifdef ENABLE_DBUS
61         GDBusConnection *connection;
62         guint registration_id;
63         EvMediaPlayerKeys *keys;
64         gboolean doc_registered;
65 #endif
66
67         TotemScrsaver *scr_saver;
68
69 #ifdef WITH_SMCLIENT
70         EggSMClient *smclient;
71 #endif
72
73         gchar *filechooser_open_uri;
74         gchar *filechooser_save_uri;
75 };
76
77 struct _EvApplicationClass {
78         GObjectClass base_class;
79 };
80
81 static EvApplication *instance;
82
83 G_DEFINE_TYPE (EvApplication, ev_application, G_TYPE_OBJECT);
84
85 #ifdef ENABLE_DBUS
86 #define APPLICATION_DBUS_OBJECT_PATH "/org/gnome/evince/Evince"
87 #define APPLICATION_DBUS_INTERFACE   "org.gnome.evince.Application"
88
89 #define EVINCE_DAEMON_SERVICE        "org.gnome.evince.Daemon"
90 #define EVINCE_DAEMON_OBJECT_PATH    "/org/gnome/evince/Daemon"
91 #define EVINCE_DAEMON_INTERFACE      "org.gnome.evince.Daemon"
92 #endif
93
94 static const gchar *userdir = NULL;
95
96 static void _ev_application_open_uri_at_dest (EvApplication  *application,
97                                               const gchar    *uri,
98                                               GdkScreen      *screen,
99                                               EvLinkDest     *dest,
100                                               EvWindowRunMode mode,
101                                               const gchar    *search_string,
102                                               guint           timestamp);
103 static void ev_application_open_uri_in_window (EvApplication  *application,
104                                                const char     *uri,
105                                                EvWindow       *ev_window,
106                                                GdkScreen      *screen,
107                                                EvLinkDest     *dest,
108                                                EvWindowRunMode mode,
109                                                const gchar    *search_string,
110                                                guint           timestamp);
111
112 /**
113  * ev_application_get_instance:
114  *
115  * Checks for #EvApplication instance, if it doesn't exist it does create it.
116  *
117  * Returns: an instance of the #EvApplication data.
118  */
119 EvApplication *
120 ev_application_get_instance (void)
121 {
122         if (!instance) {
123                 instance = EV_APPLICATION (g_object_new (EV_TYPE_APPLICATION, NULL));
124         }
125
126         return instance;
127 }
128
129 /* Session */
130 gboolean
131 ev_application_load_session (EvApplication *application)
132 {
133         GKeyFile *state_file;
134         gchar    *uri;
135
136 #ifdef WITH_SMCLIENT
137         if (egg_sm_client_is_resumed (application->smclient)) {
138                 state_file = egg_sm_client_get_state_file (application->smclient);
139                 if (!state_file)
140                         return FALSE;
141         } else
142 #endif /* WITH_SMCLIENT */
143                 return FALSE;
144
145         uri = g_key_file_get_string (state_file, "Evince", "uri", NULL);
146         if (!uri)
147                 return FALSE;
148
149         ev_application_open_uri_at_dest (application, uri,
150                                          gdk_screen_get_default (),
151                                          NULL, 0, NULL,
152                                          GDK_CURRENT_TIME);
153         g_free (uri);
154         g_key_file_free (state_file);
155
156         return TRUE;
157 }
158
159 #ifdef WITH_SMCLIENT
160
161 static void
162 smclient_save_state_cb (EggSMClient   *client,
163                         GKeyFile      *state_file,
164                         EvApplication *application)
165 {
166         if (!application->uri)
167                 return;
168
169         g_key_file_set_string (state_file, "Evince", "uri", application->uri);
170 }
171
172 static void
173 smclient_quit_cb (EggSMClient   *client,
174                   EvApplication *application)
175 {
176         ev_application_shutdown (application);
177 }
178 #endif /* WITH_SMCLIENT */
179
180 static void
181 ev_application_init_session (EvApplication *application)
182 {
183 #ifdef WITH_SMCLIENT
184         application->smclient = egg_sm_client_get ();
185         g_signal_connect (application->smclient, "save_state",
186                           G_CALLBACK (smclient_save_state_cb),
187                           application);
188         g_signal_connect (application->smclient, "quit",
189                           G_CALLBACK (smclient_quit_cb),
190                           application);
191 #endif
192 }
193
194 /**
195  * ev_display_open_if_needed:
196  * @name: the name of the display to be open if it's needed.
197  *
198  * Search among all the open displays if any of them have the same name as the
199  * passed name. If the display isn't found it tries the open it.
200  *
201  * Returns: a #GdkDisplay of the display with the passed name.
202  */
203 static GdkDisplay *
204 ev_display_open_if_needed (const gchar *name)
205 {
206         GSList     *displays;
207         GSList     *l;
208         GdkDisplay *display = NULL;
209
210         displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
211
212         for (l = displays; l != NULL; l = l->next) {
213                 const gchar *display_name = gdk_display_get_name ((GdkDisplay *) l->data);
214
215                 if (g_ascii_strcasecmp (display_name, name) == 0) {
216                         display = l->data;
217                         break;
218                 }
219         }
220
221         g_slist_free (displays);
222
223         return display != NULL ? display : gdk_display_open (name);
224 }
225
226 static void
227 child_setup (gpointer user_data)
228 {
229         gchar *startup_id;
230
231         startup_id = g_strdup_printf ("_TIME%lu",
232                                       (unsigned long)GPOINTER_TO_INT (user_data));
233         g_setenv ("DESKTOP_STARTUP_ID", startup_id, TRUE);
234         g_free (startup_id);
235 }
236
237 static void
238 ev_spawn (const char     *uri,
239           GdkScreen      *screen,
240           EvLinkDest     *dest,
241           EvWindowRunMode mode,
242           const gchar    *search_string,
243           guint           timestamp)
244 {
245         gchar   *argv[6];
246         guint    arg = 0;
247         gint     i;
248         gboolean res;
249         GError  *error = NULL;
250
251 #ifdef G_OS_WIN32
252 {
253         gchar *dir;
254
255         dir = g_win32_get_package_installation_directory_of_module (NULL);
256         argv[arg++] = g_build_filename (dir, "bin", "evince", NULL);
257         g_free (dir);
258 }
259 #else
260         argv[arg++] = g_build_filename (BINDIR, "evince", NULL);
261 #endif
262
263         /* Page label */
264         if (dest) {
265                 const gchar *page_label;
266
267                 page_label = ev_link_dest_get_page_label (dest);
268                 if (page_label)
269                         argv[arg++] = g_strdup_printf ("--page-label=%s", page_label);
270                 else
271                         argv[arg++] = g_strdup_printf ("--page-label=%d",
272                                                        ev_link_dest_get_page (dest));
273         }
274
275         /* Find string */
276         if (search_string) {
277                 argv[arg++] = g_strdup_printf ("--find=%s", search_string);
278         }
279
280         /* Mode */
281         switch (mode) {
282         case EV_WINDOW_MODE_FULLSCREEN:
283                 argv[arg++] = g_strdup ("-f");
284                 break;
285         case EV_WINDOW_MODE_PRESENTATION:
286                 argv[arg++] = g_strdup ("-s");
287                 break;
288         default:
289                 break;
290         }
291
292         argv[arg++] = (gchar *)uri;
293         argv[arg] = NULL;
294
295         res = gdk_spawn_on_screen (screen, NULL /* wd */, argv, NULL /* env */,
296                                    0,
297                                    child_setup,
298                                    GINT_TO_POINTER(timestamp),
299                                    NULL, &error);
300         if (!res) {
301                 g_warning ("Error launching evince %s: %s\n", uri, error->message);
302                 g_error_free (error);
303         }
304
305         for (i = 0; i < arg - 1; i++) {
306                 g_free (argv[i]);
307         }
308 }
309
310 static GList *
311 ev_application_get_windows (EvApplication *application)
312 {
313         GList *l, *toplevels;
314         GList *windows = NULL;
315
316         toplevels = gtk_window_list_toplevels ();
317
318         for (l = toplevels; l != NULL; l = l->next) {
319                 if (EV_IS_WINDOW (l->data)) {
320                         windows = g_list_append (windows, l->data);
321                 }
322         }
323
324         g_list_free (toplevels);
325
326         return windows;
327 }
328
329 static EvWindow *
330 ev_application_get_empty_window (EvApplication *application,
331                                  GdkScreen     *screen)
332 {
333         EvWindow *empty_window = NULL;
334         GList    *windows = ev_application_get_windows (application);
335         GList    *l;
336
337         for (l = windows; l != NULL; l = l->next) {
338                 EvWindow *window = EV_WINDOW (l->data);
339
340                 if (ev_window_is_empty (window) &&
341                     gtk_window_get_screen (GTK_WINDOW (window)) == screen) {
342                         empty_window = window;
343                         break;
344                 }
345         }
346
347         g_list_free (windows);
348
349         return empty_window;
350 }
351
352
353 #ifdef ENABLE_DBUS
354 typedef struct {
355         gchar          *uri;
356         GdkScreen      *screen;
357         EvLinkDest     *dest;
358         EvWindowRunMode mode;
359         gchar          *search_string;
360         guint           timestamp;
361 } EvRegisterDocData;
362
363 static void
364 ev_register_doc_data_free (EvRegisterDocData *data)
365 {
366         if (!data)
367                 return;
368
369         g_free (data->uri);
370         if (data->search_string)
371                 g_free (data->search_string);
372         if (data->dest)
373                 g_object_unref (data->dest);
374
375         g_free (data);
376 }
377
378 static void
379 on_reload_cb (GObject      *source_object,
380               GAsyncResult *res,
381               gpointer      user_data)
382 {
383         GDBusConnection *connection = G_DBUS_CONNECTION (source_object);
384         GVariant        *value;
385         GError          *error = NULL;
386
387         value = g_dbus_connection_call_finish (connection, res, &error);
388         if (!value) {
389                 g_warning ("Failed to Reload: %s", error->message);
390                 g_error_free (error);
391         }
392         g_variant_unref (value);
393
394         ev_application_shutdown (EV_APP);
395 }
396
397 static void
398 on_register_uri_cb (GObject      *source_object,
399                     GAsyncResult *res,
400                     gpointer      user_data)
401 {
402         GDBusConnection   *connection = G_DBUS_CONNECTION (source_object);
403         EvRegisterDocData *data = (EvRegisterDocData *)user_data;
404         EvApplication     *application = EV_APP;
405         GVariant          *value;
406         const gchar       *owner;
407         GVariantBuilder    builder;
408         GError            *error = NULL;
409
410         value = g_dbus_connection_call_finish (connection, res, &error);
411         if (!value) {
412                 g_warning ("Error registering document: %s\n", error->message);
413                 g_error_free (error);
414
415                 _ev_application_open_uri_at_dest (application,
416                                                   data->uri,
417                                                   data->screen,
418                                                   data->dest,
419                                                   data->mode,
420                                                   data->search_string,
421                                                   data->timestamp);
422                 ev_register_doc_data_free (data);
423
424                 return;
425         }
426
427         g_variant_get (value, "(&s)", &owner);
428
429         /* This means that the document wasn't already registered; go
430          * ahead with opening it.
431          */
432         if (owner[0] == '\0') {
433                 g_variant_unref (value);
434
435                 application->doc_registered = TRUE;
436
437                 _ev_application_open_uri_at_dest (application,
438                                                   data->uri,
439                                                   data->screen,
440                                                   data->dest,
441                                                   data->mode,
442                                                   data->search_string,
443                                                   data->timestamp);
444                 ev_register_doc_data_free (data);
445
446                 return;
447         }
448
449         /* Already registered */
450         g_variant_builder_init (&builder, G_VARIANT_TYPE ("(a{sv}u)"));
451         g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
452         g_variant_builder_add (&builder, "{sv}",
453                                "display",
454                                g_variant_new_string (gdk_display_get_name (gdk_screen_get_display (data->screen))));
455         g_variant_builder_add (&builder, "{sv}",
456                                "screen",
457                                g_variant_new_int32 (gdk_screen_get_number (data->screen)));
458         if (data->dest) {
459                 g_variant_builder_add (&builder, "{sv}",
460                                        "page-label",
461                                        g_variant_new_string (ev_link_dest_get_page_label (data->dest)));
462         }
463         if (data->search_string) {
464                 g_variant_builder_add (&builder, "{sv}",
465                                        "find-string",
466                                        g_variant_new_string (data->search_string));
467         }
468         if (data->mode != EV_WINDOW_MODE_NORMAL) {
469                 g_variant_builder_add (&builder, "{sv}",
470                                        "mode",
471                                        g_variant_new_uint32 (data->mode));
472         }
473         g_variant_builder_close (&builder);
474
475         g_variant_builder_add (&builder, "u", data->timestamp);
476
477         g_dbus_connection_call (connection,
478                                 owner,
479                                 APPLICATION_DBUS_OBJECT_PATH,
480                                 APPLICATION_DBUS_INTERFACE,
481                                 "Reload",
482                                 g_variant_builder_end (&builder),
483                                 NULL,
484                                 G_DBUS_CALL_FLAGS_NONE,
485                                 -1,
486                                 NULL,
487                                 on_reload_cb,
488                                 NULL);
489         g_variant_unref (value);
490         ev_register_doc_data_free (data);
491 }
492
493 /*
494  * ev_application_register_uri:
495  * @application:
496  * @uri:
497  * @screen:
498  * @dest:
499  * @mode:
500  * @search_string:
501  * @timestamp:
502  *
503  * Registers @uri with evince-daemon.
504  *
505  */
506 static void
507 ev_application_register_uri (EvApplication  *application,
508                              const gchar    *uri,
509                              GdkScreen      *screen,
510                              EvLinkDest     *dest,
511                              EvWindowRunMode mode,
512                              const gchar    *search_string,
513                              guint           timestamp)
514 {
515         EvRegisterDocData *data;
516
517         if (!application->connection)
518                 return;
519
520         if (application->doc_registered) {
521                 /* Already registered, reload */
522                 GList *windows, *l;
523
524                 windows = ev_application_get_windows (application);
525                 for (l = windows; l != NULL; l = g_list_next (l)) {
526                         EvWindow *ev_window = EV_WINDOW (l->data);
527
528                         ev_application_open_uri_in_window (application, uri, ev_window,
529                                                            screen, dest, mode,
530                                                            search_string,
531                                                            timestamp);
532                 }
533                 g_list_free (windows);
534
535                 return;
536         }
537
538         data = g_new (EvRegisterDocData, 1);
539         data->uri = g_strdup (uri);
540         data->screen = screen;
541         data->dest = dest ? g_object_ref (dest) : NULL;
542         data->mode = mode;
543         data->search_string = search_string ? g_strdup (search_string) : NULL;
544         data->timestamp = timestamp;
545
546         g_dbus_connection_call (application->connection,
547                                 EVINCE_DAEMON_SERVICE,
548                                 EVINCE_DAEMON_OBJECT_PATH,
549                                 EVINCE_DAEMON_INTERFACE,
550                                 "RegisterDocument",
551                                 g_variant_new ("(s)", uri),
552                                 G_VARIANT_TYPE ("(s)"),
553                                 G_DBUS_CALL_FLAGS_NONE,
554                                 -1,
555                                 NULL,
556                                 on_register_uri_cb,
557                                 data);
558 }
559
560 static void
561 ev_application_unregister_uri (EvApplication *application,
562                                const gchar   *uri)
563 {
564         GVariant *value;
565         GError   *error = NULL;
566
567         if (!application->doc_registered)
568                 return;
569
570         /* This is called from ev_application_shutdown(),
571          * so it's safe to use the sync api
572          */
573         value = g_dbus_connection_call_sync (
574                 application->connection,
575                 EVINCE_DAEMON_SERVICE,
576                 EVINCE_DAEMON_OBJECT_PATH,
577                 EVINCE_DAEMON_INTERFACE,
578                 "UnregisterDocument",
579                 g_variant_new ("(s)", uri),
580                 NULL,
581                 G_DBUS_CALL_FLAGS_NO_AUTO_START,
582                 -1,
583                 NULL,
584                 &error);
585         if (value == NULL) {
586                 g_warning ("Error unregistering document: %s\n", error->message);
587                 g_error_free (error);
588         } else {
589                 g_variant_unref (value);
590         }
591 }
592 #endif /* ENABLE_DBUS */
593
594 static void
595 ev_application_open_uri_in_window (EvApplication  *application,
596                                    const char     *uri,
597                                    EvWindow       *ev_window,
598                                    GdkScreen      *screen,
599                                    EvLinkDest     *dest,
600                                    EvWindowRunMode mode,
601                                    const gchar    *search_string,
602                                    guint           timestamp)
603 {
604 #ifdef GDK_WINDOWING_X11
605         GdkWindow *gdk_window;
606 #endif
607
608         if (screen) {
609                 ev_stock_icons_set_screen (screen);
610                 gtk_window_set_screen (GTK_WINDOW (ev_window), screen);
611         }
612
613         /* We need to load uri before showing the window, so
614            we can restore window size without flickering */
615         ev_window_open_uri (ev_window, uri, dest, mode, search_string);
616
617         if (!gtk_widget_get_realized (GTK_WIDGET (ev_window)))
618                 gtk_widget_realize (GTK_WIDGET (ev_window));
619
620 #ifdef GDK_WINDOWING_X11
621         gdk_window = gtk_widget_get_window (GTK_WIDGET (ev_window));
622
623         if (timestamp <= 0)
624                 timestamp = gdk_x11_get_server_time (gdk_window);
625         gdk_x11_window_set_user_time (gdk_window, timestamp);
626
627         gtk_window_present (GTK_WINDOW (ev_window));
628 #else
629         gtk_window_present_with_time (GTK_WINDOW (ev_window), timestamp);
630 #endif /* GDK_WINDOWING_X11 */
631 }
632
633 static void
634 _ev_application_open_uri_at_dest (EvApplication  *application,
635                                   const gchar    *uri,
636                                   GdkScreen      *screen,
637                                   EvLinkDest     *dest,
638                                   EvWindowRunMode mode,
639                                   const gchar    *search_string,
640                                   guint           timestamp)
641 {
642         EvWindow *ev_window;
643
644         ev_window = ev_application_get_empty_window (application, screen);
645         if (!ev_window)
646                 ev_window = EV_WINDOW (ev_window_new ());
647
648         ev_application_open_uri_in_window (application, uri, ev_window,
649                                            screen, dest, mode,
650                                            search_string,
651                                            timestamp);
652 }
653
654 /**
655  * ev_application_open_uri_at_dest:
656  * @application: The instance of the application.
657  * @uri: The uri to be opened.
658  * @screen: Thee screen where the link will be shown.
659  * @dest: The #EvLinkDest of the document.
660  * @mode: The run mode of the window.
661  * @timestamp: Current time value.
662  */
663 void
664 ev_application_open_uri_at_dest (EvApplication  *application,
665                                  const char     *uri,
666                                  GdkScreen      *screen,
667                                  EvLinkDest     *dest,
668                                  EvWindowRunMode mode,
669                                  const gchar    *search_string,
670                                  guint           timestamp)
671 {
672         g_return_if_fail (uri != NULL);
673
674         if (application->uri && strcmp (application->uri, uri) != 0) {
675                 /* spawn a new evince process */
676                 ev_spawn (uri, screen, dest, mode, search_string, timestamp);
677                 return;
678         } else if (!application->uri) {
679                 application->uri = g_strdup (uri);
680         }
681
682 #ifdef ENABLE_DBUS
683         /* Register the uri or send Reload to
684          * remote instance if already registered
685          */
686         ev_application_register_uri (application, uri, screen, dest, mode, search_string, timestamp);
687 #else
688         _ev_application_open_uri_at_dest (application, uri, screen, dest, mode, search_string, timestamp);
689 #endif /* ENABLE_DBUS */
690 }
691
692 /**
693  * ev_application_open_window:
694  * @application: The instance of the application.
695  * @timestamp: Current time value.
696  *
697  * Creates a new window
698  */
699 void
700 ev_application_open_window (EvApplication *application,
701                             GdkScreen     *screen,
702                             guint32        timestamp)
703 {
704         GtkWidget *new_window = ev_window_new ();
705 #ifdef GDK_WINDOWING_X11
706         GdkWindow *gdk_window;
707 #endif
708
709         if (screen) {
710                 ev_stock_icons_set_screen (screen);
711                 gtk_window_set_screen (GTK_WINDOW (new_window), screen);
712         }
713
714         if (!gtk_widget_get_realized (new_window))
715                 gtk_widget_realize (new_window);
716
717 #ifdef GDK_WINDOWING_X11
718         gdk_window = gtk_widget_get_window (GTK_WIDGET (new_window));
719
720         if (timestamp <= 0)
721                 timestamp = gdk_x11_get_server_time (gdk_window);
722         gdk_x11_window_set_user_time (gdk_window, timestamp);
723
724         gtk_window_present (GTK_WINDOW (new_window));
725 #else
726         gtk_window_present_with_time (GTK_WINDOW (new_window), timestamp);
727 #endif /* GDK_WINDOWING_X11 */
728 }
729
730 #ifdef ENABLE_DBUS
731 static void
732 method_call_cb (GDBusConnection       *connection,
733                 const gchar           *sender,
734                 const gchar           *object_path,
735                 const gchar           *interface_name,
736                 const gchar           *method_name,
737                 GVariant              *parameters,
738                 GDBusMethodInvocation *invocation,
739                 gpointer               user_data)
740 {
741         EvApplication   *application = EV_APPLICATION (user_data);
742         GList           *windows, *l;
743         guint            timestamp;
744         GVariantIter    *iter;
745         const gchar     *key;
746         GVariant        *value;
747         GdkDisplay      *display = NULL;
748         int              screen_number = 0;
749         EvLinkDest      *dest = NULL;
750         EvWindowRunMode  mode = EV_WINDOW_MODE_NORMAL;
751         const gchar     *search_string = NULL;
752         GdkScreen       *screen = NULL;
753
754         if (g_strcmp0 (method_name, "Reload") == 0) {
755                 g_variant_get (parameters, "(a{sv}u)", &iter, &timestamp);
756
757                 while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) {
758                         if (strcmp (key, "display") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {
759                                 display = ev_display_open_if_needed (g_variant_get_string (value, NULL));
760                         } else if (strcmp (key, "screen") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {
761                                 screen_number = g_variant_get_int32 (value);
762                         } else if (strcmp (key, "mode") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_UINT32) {
763                         mode = g_variant_get_uint32 (value);
764                         } else if (strcmp (key, "page-label") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {
765                                 dest = ev_link_dest_new_page_label (g_variant_get_string (value, NULL));
766                         } else if (strcmp (key, "find-string") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {
767                                 search_string = g_variant_get_string (value, NULL);
768                         }
769                 }
770                 g_variant_iter_free (iter);
771
772                 if (display != NULL &&
773                     screen_number >= 0 &&
774                     screen_number < gdk_display_get_n_screens (display))
775                         screen = gdk_display_get_screen (display, screen_number);
776                 else
777                         screen = gdk_screen_get_default ();
778
779                 windows = ev_application_get_windows (application);
780                 for (l = windows; l != NULL; l = g_list_next (l)) {
781                         EvWindow *ev_window = EV_WINDOW (l->data);
782
783                         ev_application_open_uri_in_window (application, application->uri,
784                                                            ev_window,
785                                                            screen, dest, mode,
786                                                            search_string,
787                                                            timestamp);
788                 }
789                 g_list_free (windows);
790
791                 if (dest)
792                         g_object_unref (dest);
793
794                 g_dbus_method_invocation_return_value (invocation, g_variant_new ("()"));
795         } else if (g_strcmp0 (method_name, "GetWindowList") == 0) {
796                 GList          *windows = ev_application_get_windows (application);
797                 GVariantBuilder builder;
798                 GList          *l;
799
800                 g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ao)"));
801                 g_variant_builder_open (&builder, G_VARIANT_TYPE ("ao"));
802
803                 for (l = windows; l; l = g_list_next (l)) {
804                         EvWindow *window = (EvWindow *)l->data;
805
806                         g_variant_builder_add (&builder, "o", ev_window_get_dbus_object_path (window));
807                 }
808
809                 g_variant_builder_close (&builder);
810                 g_list_free (windows);
811
812                 g_dbus_method_invocation_return_value (invocation, g_variant_builder_end (&builder));
813         }
814 }
815
816 static const char introspection_xml[] =
817         "<node>"
818           "<interface name='org.gnome.evince.Application'>"
819             "<method name='Reload'>"
820               "<arg type='a{sv}' name='args' direction='in'/>"
821               "<arg type='u' name='timestamp' direction='in'/>"
822             "</method>"
823             "<method name='GetWindowList'>"
824               "<arg type='ao' name='window_list' direction='out'/>"
825             "</method>"
826           "</interface>"
827         "</node>";
828
829 static const GDBusInterfaceVTable interface_vtable = {
830         method_call_cb,
831         NULL,
832         NULL
833 };
834
835 static GDBusNodeInfo *introspection_data;
836 #endif /* ENABLE_DBUS */
837
838 void
839 ev_application_open_uri_list (EvApplication *application,
840                               GSList        *uri_list,
841                               GdkScreen     *screen,
842                               guint          timestamp)
843 {
844         GSList *l;
845
846         for (l = uri_list; l != NULL; l = l->next) {
847                 ev_application_open_uri_at_dest (application, (char *)l->data,
848                                                  screen, NULL, 0, NULL,
849                                                  timestamp);
850         }
851 }
852
853 static void
854 ev_application_accel_map_save (EvApplication *application)
855 {
856         gchar *accel_map_file;
857         gchar *tmp_filename;
858         gint   fd;
859
860         if (userdir) {
861                 accel_map_file = g_build_filename (userdir, "accels",
862                                                    "evince", NULL);
863         } else {
864                 accel_map_file = g_build_filename (g_get_home_dir (),
865                                                    ".gnome2", "accels",
866                                                    "evince", NULL);
867         }
868
869         tmp_filename = g_strdup_printf ("%s.XXXXXX", accel_map_file);
870
871         fd = g_mkstemp (tmp_filename);
872         if (fd == -1) {
873                 g_free (accel_map_file);
874                 g_free (tmp_filename);
875
876                 return;
877         }
878         gtk_accel_map_save_fd (fd);
879         close (fd);
880
881         if (g_rename (tmp_filename, accel_map_file) == -1) {
882                 /* FIXME: win32? */
883                 g_unlink (tmp_filename);
884         }
885
886         g_free (accel_map_file);
887         g_free (tmp_filename);
888 }
889
890 static void
891 ev_application_accel_map_load (EvApplication *application)
892 {
893         gchar *accel_map_file;
894
895         if (userdir) {
896                 accel_map_file = g_build_filename (userdir, "accels",
897                                                    "evince", NULL);
898         } else {
899                 accel_map_file = g_build_filename (g_get_home_dir (),
900                                                    ".gnome2", "accels",
901                                                    "evince", NULL);
902         }
903
904         gtk_accel_map_load (accel_map_file);
905         g_free (accel_map_file);
906 }
907
908 void
909 ev_application_shutdown (EvApplication *application)
910 {
911         if (application->uri) {
912 #ifdef ENABLE_DBUS
913                 ev_application_unregister_uri (application,
914                                                application->uri);
915 #endif
916                 g_free (application->uri);
917                 application->uri = NULL;
918         }
919
920         ev_application_accel_map_save (application);
921
922         g_object_unref (application->scr_saver);
923         application->scr_saver = NULL;
924
925 #ifdef ENABLE_DBUS
926         if (application->keys) {
927                 g_object_unref (application->keys);
928                 application->keys = NULL;
929         }
930         if (application->registration_id != 0) {
931                 g_dbus_connection_unregister_object (application->connection,
932                                                      application->registration_id);
933                 application->registration_id = 0;
934         }
935         if (application->connection != NULL) {
936                 g_object_unref (application->connection);
937                 application->connection = NULL;
938         }
939         if (introspection_data) {
940                 g_dbus_node_info_ref (introspection_data);
941                 introspection_data = NULL;
942         }
943 #endif /* ENABLE_DBUS */
944         
945         g_free (application->dot_dir);
946         application->dot_dir = NULL;
947         g_free (application->data_dir);
948         application->data_dir = NULL;
949         g_free (application->filechooser_open_uri);
950         application->filechooser_open_uri = NULL;
951         g_free (application->filechooser_save_uri);
952         application->filechooser_save_uri = NULL;
953
954         g_object_unref (application);
955         instance = NULL;
956         
957         gtk_main_quit ();
958 }
959
960 static void
961 ev_application_class_init (EvApplicationClass *ev_application_class)
962 {
963 }
964
965 static void
966 ev_application_init (EvApplication *ev_application)
967 {
968         GError *error = NULL;
969
970         userdir = g_getenv ("GNOME22_USER_DIR");
971         if (userdir)
972                 ev_application->dot_dir = g_build_filename (userdir, "evince", NULL);
973         else
974                 ev_application->dot_dir = g_build_filename (g_get_home_dir (),
975                                                             ".gnome2",
976                                                             "evince",
977                                                             NULL);
978
979 #ifdef G_OS_WIN32
980 {
981         gchar *dir;
982
983         dir = g_win32_get_package_installation_directory_of_module (NULL);
984         ev_application->data_dir = g_build_filename (dir, "share", "evince", NULL);
985         g_free (dir);
986 }
987 #else
988         ev_application->data_dir = g_strdup (EVINCEDATADIR);
989 #endif
990
991         ev_application_init_session (ev_application);
992
993         ev_application_accel_map_load (ev_application);
994
995 #ifdef ENABLE_DBUS
996         ev_application->connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
997         if (ev_application->connection != NULL) {
998                 introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
999                 g_assert (introspection_data != NULL);
1000
1001                 ev_application->registration_id =
1002                     g_dbus_connection_register_object (ev_application->connection,
1003                                                        APPLICATION_DBUS_OBJECT_PATH,
1004                                                        introspection_data->interfaces[0],
1005                                                        &interface_vtable,
1006                                                        ev_application, NULL,
1007                                                        &error);
1008                 if (ev_application->registration_id == 0) {
1009                         g_printerr ("Failed to register bus object: %s\n", error->message);
1010                         g_error_free (error);
1011                 }
1012         } else {
1013                 g_printerr ("Failed to get bus connection: %s\n", error->message);
1014                 g_error_free (error);
1015         }
1016
1017         ev_application->keys = ev_media_player_keys_new ();
1018 #endif /* ENABLE_DBUS */
1019
1020         ev_application->scr_saver = totem_scrsaver_new ();
1021         g_object_set (ev_application->scr_saver,
1022                       "reason", _("Running in presentation mode"),
1023                       NULL);
1024 }
1025
1026 GDBusConnection *
1027 ev_application_get_dbus_connection (EvApplication *application)
1028 {
1029 #ifdef ENABLE_DBUS
1030         return application->connection;
1031 #else
1032         return NULL;
1033 #endif
1034 }
1035
1036 gboolean
1037 ev_application_has_window (EvApplication *application)
1038 {
1039         GList    *l, *toplevels;
1040         gboolean  retval = FALSE;
1041
1042         toplevels = gtk_window_list_toplevels ();
1043
1044         for (l = toplevels; l != NULL && !retval; l = l->next) {
1045                 if (EV_IS_WINDOW (l->data))
1046                         retval = TRUE;
1047         }
1048
1049         g_list_free (toplevels);
1050
1051         return retval;
1052 }
1053
1054 guint
1055 ev_application_get_n_windows (EvApplication *application)
1056 {
1057         GList *l, *toplevels;
1058         guint  retval = 0;
1059
1060         toplevels = gtk_window_list_toplevels ();
1061
1062         for (l = toplevels; l != NULL; l = l->next) {
1063                 if (EV_IS_WINDOW (l->data))
1064                         retval++;
1065         }
1066
1067         g_list_free (toplevels);
1068
1069         return retval;
1070 }
1071
1072 const gchar *
1073 ev_application_get_uri (EvApplication *application)
1074 {
1075         return application->uri;
1076 }
1077
1078 /**
1079  * ev_application_get_media_keys:
1080  * @application: The instance of the application.
1081  *
1082  * It gives you access to the media player keys handler object.
1083  *
1084  * Returns: A #EvMediaPlayerKeys.
1085  */
1086 GObject *
1087 ev_application_get_media_keys (EvApplication *application)
1088 {
1089 #ifdef ENABLE_DBUS
1090         return G_OBJECT (application->keys);
1091 #else
1092         return NULL;
1093 #endif /* ENABLE_DBUS */
1094 }
1095
1096 void
1097 ev_application_set_filechooser_uri (EvApplication       *application,
1098                                     GtkFileChooserAction action,
1099                                     const gchar         *uri)
1100 {
1101         if (action == GTK_FILE_CHOOSER_ACTION_OPEN) {
1102                 g_free (application->filechooser_open_uri);
1103                 application->filechooser_open_uri = g_strdup (uri);
1104         } else if (action == GTK_FILE_CHOOSER_ACTION_SAVE) {
1105                 g_free (application->filechooser_save_uri);
1106                 application->filechooser_save_uri = g_strdup (uri);
1107         }
1108 }
1109
1110 const gchar *
1111 ev_application_get_filechooser_uri (EvApplication       *application,
1112                                     GtkFileChooserAction action)
1113 {
1114         if (action == GTK_FILE_CHOOSER_ACTION_OPEN) {
1115                 if (application->filechooser_open_uri)
1116                         return application->filechooser_open_uri;
1117         } else if (action == GTK_FILE_CHOOSER_ACTION_SAVE) {
1118                 if (application->filechooser_save_uri)
1119                         return application->filechooser_save_uri;
1120         }
1121
1122         return NULL;
1123 }
1124
1125 void
1126 ev_application_screensaver_enable (EvApplication *application)
1127 {
1128         totem_scrsaver_enable (application->scr_saver);
1129 }
1130
1131 void
1132 ev_application_screensaver_disable (EvApplication *application)
1133 {
1134         totem_scrsaver_disable (application->scr_saver);
1135 }
1136
1137 const gchar *
1138 ev_application_get_dot_dir (EvApplication *application,
1139                             gboolean create)
1140 {
1141         if (create)
1142                 g_mkdir_with_parents (application->dot_dir, 0700);
1143
1144         return application->dot_dir;
1145 }
1146
1147 const gchar *
1148 ev_application_get_data_dir (EvApplication   *application)
1149 {
1150         return application->data_dir;
1151 }