+INCLUDES= \

+ -DEVINCEDATADIR=\"$(pkgdatadir)\" \

+ -DMATEDATADIR=\"$(datadir)\" \

+ -I$(top_srcdir) \

+ -I$(top_builddir) \

+ -I$(top_srcdir)/cut-n-paste/zoom-control/ \

+ -I$(top_srcdir)/cut-n-paste/toolbar-editor/ \

+ -I$(top_srcdir)/cut-n-paste/totem-screensaver/ \

+ -I$(top_srcdir)/cut-n-paste/gimpcellrenderertoggle/ \

+ -I$(top_srcdir)/cut-n-paste/smclient/ \

+ -I$(top_srcdir)/libdocument \

+ -I$(top_builddir)/libdocument \

+ -I$(top_srcdir)/libview \

+ -I$(top_builddir)/libview \

+ -I$(top_srcdir)/libmisc \

+ -I$(top_srcdir)/properties \

+ -DMATEICONDIR=\""$(datadir)/pixmaps"\" \

+ -DBINDIR=\""$(bindir)"\" \

+ -DLIBEXECDIR=\""$(libexecdir)"\" \

+ -DEVINCE_COMPILATION \

+ $(SHELL_CFLAGS) \

+ $(WARN_CFLAGS) \

+ $(DISABLE_DEPRECATED)

+

+bin_PROGRAMS=evince

+

+libexec_PROGRAMS=evince-convert-metadata

+if ENABLE_DBUS

+libexec_PROGRAMS += evinced

+endif

+

+evince_SOURCES= \

+ eggfindbar.c \

+ eggfindbar.h \

+ ev-annotation-properties-dialog.h \

+ ev-annotation-properties-dialog.c \

+ ev-application.c \

+ ev-application.h \

+ ev-file-monitor.h \

+ ev-file-monitor.c \

+ ev-history.c \

+ ev-history.h \

+ ev-keyring.h \

+ ev-keyring.c \

+ ev-marshal.c \

+ ev-marshal.h \

+ ev-message-area.c \

+ ev-message-area.h \

+ ev-metadata.c \

+ ev-metadata.h \

+ ev-navigation-action.c \

+ ev-navigation-action.h \

+ ev-navigation-action-widget.c \

+ ev-navigation-action-widget.h \

+ ev-password-view.h \

+ ev-password-view.c \

+ ev-progress-message-area.h \

+ ev-progress-message-area.c \

+ ev-properties-dialog.c \

+ ev-properties-dialog.h \

+ ev-properties-fonts.c \

+ ev-properties-fonts.h \

+ ev-properties-license.c \

+ ev-properties-license.h \

+ ev-open-recent-action.c \

+ ev-open-recent-action.h \

+ ev-utils.c \

+ ev-utils.h \

+ ev-window.c \

+ ev-window.h \

+ ev-window-title.c \

+ ev-window-title.h \

+ ev-sidebar.c \

+ ev-sidebar.h \

+ ev-sidebar-annotations.c \

+ ev-sidebar-annotations.h \

+ ev-sidebar-attachments.c \

+ ev-sidebar-attachments.h \

+ ev-sidebar-layers.c \

+ ev-sidebar-layers.h \

+ ev-sidebar-links.c \

+ ev-sidebar-links.h \

+ ev-sidebar-page.c \

+ ev-sidebar-page.h \

+ ev-sidebar-thumbnails.c \

+ ev-sidebar-thumbnails.h \

+ main.c

+

+if ENABLE_DBUS

+evince_SOURCES += \

+ ev-media-player-keys.c \

+ ev-media-player-keys.h

+endif

+

+

+evince_LDFLAGS = $(AM_LDFLAGS)

+

+if PLATFORM_WIN32

+evince_LDFLAGS += -mwindows

+endif

+

+evince_LDADD= \

+ $(top_builddir)/cut-n-paste/zoom-control/libephyzoom.la \

+ $(top_builddir)/cut-n-paste/toolbar-editor/libtoolbareditor.la \

+ $(top_builddir)/cut-n-paste/totem-screensaver/libtotemscrsaver.la \

+ $(top_builddir)/cut-n-paste/gimpcellrenderertoggle/libgimpcellrenderertoggle.la \

+ $(top_builddir)/cut-n-paste/smclient/libsmclient.la \

+ $(top_builddir)/properties/libevproperties.la \

+ $(top_builddir)/libdocument/libevdocument.la \

+ $(top_builddir)/libview/libevview.la \

+ $(top_builddir)/libmisc/libevmisc.la \

+ $(SHELL_LIBS)

+

+if PLATFORM_WIN32

+evince_LDADD += evince-icon.o

+

+evince-icon.o: $(srcdir)/evince-icon.rc $(top_srcdir)/data/evince.ico

+ $(WINDRES) $(srcdir)/evince-icon.rc -I $(top_srcdir)/data evince-icon.o

+endif

+

+BUILT_SOURCES = ev-marshal.h ev-marshal.c

+

+evince_convert_metadata_SOURCES= \

+ ev-convert-metadata.c

+

+evince_convert_metadata_LDADD= \

+ $(SHELL_LIBS)

+

+if ENABLE_DBUS

+evinced_SOURCES= \

+ ev-daemon.c

+

+evinced_CFLAGS= \

+ -DEVINCEDATADIR=\"$(pkgdatadir)\" \

+ -DMATEDATADIR=\"$(datadir)\" \

+ -I$(top_srcdir) \

+ -I$(top_builddir) \

+ -DLIBEXECDIR=\""$(libexecdir)"\" \

+ -DEVINCE_COMPILATION \

+ $(EV_DAEMON_CFLAGS) \

+ $(WARN_CFLAGS) \

+ $(DISABLE_DEPRECATED)

+

+evinced_LDADD= \

+ $(EV_DAEMON_LIBS)

+endif

+

+EXTRA_DIST = ev-marshal.list \

+ evince-icon.rc

+

+ev-marshal.h: $(srcdir)/ev-marshal.list

+ $(AM_V_GEN)$(GLIB_GENMARSHAL) --prefix=ev_marshal $(srcdir)/ev-marshal.list --header > ev-marshal.h

+

+ev-marshal.c: $(srcdir)/ev-marshal.list

+ echo '#include "ev-marshal.h"' > ev-marshal.c

+ $(AM_V_GEN)$(GLIB_GENMARSHAL) --prefix=ev_marshal $(srcdir)/ev-marshal.list --body >> ev-marshal.c

+

+DISTCLEANFILES =

+

+-include $(top_srcdir)/git.mk

+/* Copyright (C) 2004 Red Hat, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License as

+ * published by the Free Software Foundation; either version 2 of the

+ * License, or (at your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with the Mate Library; see the file COPYING.LIB. If not,

+ * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

+ * Boston, MA 02110-1301, USA.

+ */

+

+#include "config.h"

+

+#include <string.h>

+

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+#include <gdk/gdkkeysyms.h>

+

+#include "eggfindbar.h"

+

+struct _EggFindBarPrivate

+{

+ gchar *search_string;

+

+ GtkToolItem *next_button;

+ GtkToolItem *previous_button;

+ GtkToolItem *status_separator;

+ GtkToolItem *status_item;

+ GtkToolItem *case_button;

+

+ GtkWidget *find_entry;

+ GtkWidget *status_label;

+

+ gulong set_focus_handler;

+ guint case_sensitive : 1;

+};

+

+#define EGG_FIND_BAR_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EGG_TYPE_FIND_BAR, EggFindBarPrivate))

+

+enum {

+ PROP_0,

+ PROP_SEARCH_STRING,

+ PROP_CASE_SENSITIVE

+};

+

+static void egg_find_bar_finalize (GObject *object);

+static void egg_find_bar_get_property (GObject *object,

+ guint prop_id,

+ GValue *value,

+ GParamSpec *pspec);

+static void egg_find_bar_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec);

+static void egg_find_bar_show (GtkWidget *widget);

+static void egg_find_bar_hide (GtkWidget *widget);

+static void egg_find_bar_grab_focus (GtkWidget *widget);

+

+G_DEFINE_TYPE (EggFindBar, egg_find_bar, GTK_TYPE_TOOLBAR);

+

+enum

+ {

+ NEXT,

+ PREVIOUS,

+ CLOSE,

+ SCROLL,

+ LAST_SIGNAL

+ };

+

+static guint find_bar_signals[LAST_SIGNAL] = { 0 };

+

+static void

+egg_find_bar_class_init (EggFindBarClass *klass)

+{

+ GObjectClass *object_class;

+ GtkWidgetClass *widget_class;

+ GtkBindingSet *binding_set;

+

+ egg_find_bar_parent_class = g_type_class_peek_parent (klass);

+

+ object_class = (GObjectClass *)klass;

+ widget_class = (GtkWidgetClass *)klass;

+

+ object_class->set_property = egg_find_bar_set_property;

+ object_class->get_property = egg_find_bar_get_property;

+

+ object_class->finalize = egg_find_bar_finalize;

+

+ widget_class->show = egg_find_bar_show;

+ widget_class->hide = egg_find_bar_hide;

+

+ widget_class->grab_focus = egg_find_bar_grab_focus;

+

+ find_bar_signals[NEXT] =

+ g_signal_new ("next",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_FIRST,

+ G_STRUCT_OFFSET (EggFindBarClass, next),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+ find_bar_signals[PREVIOUS] =

+ g_signal_new ("previous",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_FIRST,

+ G_STRUCT_OFFSET (EggFindBarClass, previous),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+ find_bar_signals[CLOSE] =

+ g_signal_new ("close",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

+ G_STRUCT_OFFSET (EggFindBarClass, close),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+ find_bar_signals[SCROLL] =

+ g_signal_new ("scroll",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

+ G_STRUCT_OFFSET (EggFindBarClass, scroll),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__ENUM,

+ G_TYPE_NONE, 1,

+ GTK_TYPE_SCROLL_TYPE);

+

+ /**

+ * EggFindBar:search_string:

+ *

+ * The current string to search for. NULL or empty string

+ * both mean no current string.

+ *

+ */

+ g_object_class_install_property (object_class,

+ PROP_SEARCH_STRING,

+ g_param_spec_string ("search_string",

+ "Search string",

+ "The name of the string to be found",

+ NULL,

+ G_PARAM_READWRITE));

+

+ /**

+ * EggFindBar:case_sensitive:

+ *

+ * TRUE for a case sensitive search.

+ *

+ */

+ g_object_class_install_property (object_class,

+ PROP_CASE_SENSITIVE,

+ g_param_spec_boolean ("case_sensitive",

+ "Case sensitive",

+ "TRUE for a case sensitive search",

+ FALSE,

+ G_PARAM_READWRITE));

+

+ /* Style properties */

+ gtk_widget_class_install_style_property (widget_class,

+ g_param_spec_boxed ("all_matches_color",

+ "Highlight color",

+ "Color of highlight for all matches",

+ GDK_TYPE_COLOR,

+ G_PARAM_READABLE));

+

+ gtk_widget_class_install_style_property (widget_class,

+ g_param_spec_boxed ("current_match_color",

+ "Current color",

+ "Color of highlight for the current match",

+ GDK_TYPE_COLOR,

+ G_PARAM_READABLE));

+

+ g_type_class_add_private (object_class, sizeof (EggFindBarPrivate));

+

+ binding_set = gtk_binding_set_by_class (klass);

+

+ gtk_binding_entry_add_signal (binding_set, GDK_Escape, 0,

+ "close", 0);

+

+ gtk_binding_entry_add_signal (binding_set, GDK_Up, 0,

+ "scroll", 1,

+ GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_BACKWARD);

+ gtk_binding_entry_add_signal (binding_set, GDK_Down, 0,

+ "scroll", 1,

+ GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_FORWARD);

+ gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, 0,

+ "scroll", 1,

+ GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_BACKWARD);

+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, 0,

+ "scroll", 1,

+ GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_BACKWARD);

+ gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, 0,

+ "scroll", 1,

+ GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_FORWARD);

+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, 0,

+ "scroll", 1,

+ GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_PAGE_FORWARD);

+}

+

+static void

+egg_find_bar_emit_next (EggFindBar *find_bar)

+{

+ g_signal_emit (find_bar, find_bar_signals[NEXT], 0);

+}

+

+static void

+egg_find_bar_emit_previous (EggFindBar *find_bar)

+{

+ g_signal_emit (find_bar, find_bar_signals[PREVIOUS], 0);

+}

+

+static void

+next_clicked_callback (GtkButton *button,

+ void *data)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (data);

+

+ egg_find_bar_emit_next (find_bar);

+}

+

+static void

+previous_clicked_callback (GtkButton *button,

+ void *data)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (data);

+

+ egg_find_bar_emit_previous (find_bar);

+}

+

+static void

+case_sensitive_toggled_callback (GtkCheckButton *button,

+ void *data)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (data);

+

+ egg_find_bar_set_case_sensitive (find_bar,

+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));

+}

+

+static void

+entry_activate_callback (GtkEntry *entry,

+ void *data)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (data);

+

+ if (find_bar->priv->search_string != NULL)

+ egg_find_bar_emit_next (find_bar);

+}

+

+static void

+entry_changed_callback (GtkEntry *entry,

+ void *data)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (data);

+ char *text;

+

+ /* paranoid strdup because set_search_string() sets

+ * the entry text

+ */

+ text = g_strdup (gtk_entry_get_text (entry));

+

+ egg_find_bar_set_search_string (find_bar, text);

+

+ g_free (text);

+}

+

+static void

+set_focus_cb (GtkWidget *window,

+ GtkWidget *widget,

+ EggFindBar *bar)

+{

+ GtkWidget *wbar = GTK_WIDGET (bar);

+

+ while (widget != NULL && widget != wbar)

+ {

+ widget = gtk_widget_get_parent (widget);

+ }

+

+ /* if widget == bar, the new focus widget is in the bar, so we

+ * don't deactivate.

+ */

+ if (widget != wbar)

+ {

+ g_signal_emit (bar, find_bar_signals[CLOSE], 0);

+ }

+}

+

+static void

+egg_find_bar_init (EggFindBar *find_bar)

+{

+ EggFindBarPrivate *priv;

+ GtkWidget *label;

+ GtkWidget *alignment;

+ GtkWidget *box;

+ GtkToolItem *item;

+ GtkWidget *arrow;

+

+ /* Data */

+ priv = EGG_FIND_BAR_GET_PRIVATE (find_bar);

+

+ find_bar->priv = priv;

+ priv->search_string = NULL;

+

+ gtk_toolbar_set_style (GTK_TOOLBAR (find_bar), GTK_TOOLBAR_BOTH_HORIZ);

+

+ /* Find: |_____| */

+ item = gtk_tool_item_new ();

+ box = gtk_hbox_new (FALSE, 12);

+

+ alignment = gtk_alignment_new (0.0, 0.5, 1.0, 0.0);

+ gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 2, 2);

+

+ label = gtk_label_new_with_mnemonic (_("Find:"));

+

+ priv->find_entry = gtk_entry_new ();

+ gtk_entry_set_width_chars (GTK_ENTRY (priv->find_entry), 32);

+ gtk_entry_set_max_length (GTK_ENTRY (priv->find_entry), 512);

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->find_entry);

+

+ /* Prev */

+ arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE);

+ priv->previous_button = gtk_tool_button_new (arrow, Q_("Find Pre_vious"));

+ gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (priv->previous_button), TRUE);

+ gtk_tool_item_set_is_important (priv->previous_button, TRUE);

+ gtk_widget_set_tooltip_text (GTK_WIDGET (priv->previous_button),

+ _("Find previous occurrence of the search string"));

+

+ /* Next */

+ arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);

+ priv->next_button = gtk_tool_button_new (arrow, Q_("Find Ne_xt"));

+ gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (priv->next_button), TRUE);

+ gtk_tool_item_set_is_important (priv->next_button, TRUE);

+ gtk_widget_set_tooltip_text (GTK_WIDGET (priv->next_button),

+ _("Find next occurrence of the search string"));

+

+ /* Separator*/

+ priv->status_separator = gtk_separator_tool_item_new();

+

+ /* Case button */

+ priv->case_button = gtk_toggle_tool_button_new ();

+ g_object_set (G_OBJECT (priv->case_button), "label", _("C_ase Sensitive"), NULL);

+ gtk_tool_item_set_is_important (priv->case_button, TRUE);

+ gtk_widget_set_tooltip_text (GTK_WIDGET (priv->case_button),

+ _("Toggle case sensitive search"));

+

+ /* Status */

+ priv->status_item = gtk_tool_item_new();

+ gtk_tool_item_set_expand (priv->status_item, TRUE);

+ priv->status_label = gtk_label_new (NULL);

+ gtk_label_set_ellipsize (GTK_LABEL (priv->status_label),

+ PANGO_ELLIPSIZE_END);

+ gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5);

+

+

+ g_signal_connect (priv->find_entry, "changed",

+ G_CALLBACK (entry_changed_callback),

+ find_bar);

+ g_signal_connect (priv->find_entry, "activate",

+ G_CALLBACK (entry_activate_callback),

+ find_bar);

+ g_signal_connect (priv->next_button, "clicked",

+ G_CALLBACK (next_clicked_callback),

+ find_bar);

+ g_signal_connect (priv->previous_button, "clicked",

+ G_CALLBACK (previous_clicked_callback),

+ find_bar);

+ g_signal_connect (priv->case_button, "toggled",

+ G_CALLBACK (case_sensitive_toggled_callback),

+ find_bar);

+

+ gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);

+ gtk_box_pack_start (GTK_BOX (box), priv->find_entry, TRUE, TRUE, 0);

+ gtk_container_add (GTK_CONTAINER (alignment), box);

+ gtk_container_add (GTK_CONTAINER (item), alignment);

+ gtk_toolbar_insert (GTK_TOOLBAR (find_bar), item, -1);

+ gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->previous_button, -1);

+ gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->next_button, -1);

+ gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->case_button, -1);

+ gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_separator, -1);

+ gtk_container_add (GTK_CONTAINER (priv->status_item), priv->status_label);

+ gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_item, -1);

+

+ /* don't show status separator/label until they are set */

+

+ gtk_widget_show_all (GTK_WIDGET (item));

+ gtk_widget_show_all (GTK_WIDGET (priv->next_button));

+ gtk_widget_show_all (GTK_WIDGET (priv->previous_button));

+ gtk_widget_show (priv->status_label);

+}

+

+static void

+egg_find_bar_finalize (GObject *object)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (object);

+ EggFindBarPrivate *priv = (EggFindBarPrivate *)find_bar->priv;

+

+ g_free (priv->search_string);

+

+ G_OBJECT_CLASS (egg_find_bar_parent_class)->finalize (object);

+}

+

+static void

+egg_find_bar_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (object);

+

+ switch (prop_id)

+ {

+ case PROP_SEARCH_STRING:

+ egg_find_bar_set_search_string (find_bar, g_value_get_string (value));

+ break;

+ case PROP_CASE_SENSITIVE:

+ egg_find_bar_set_case_sensitive (find_bar, g_value_get_boolean (value));

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ break;

+ }

+}

+

+static void

+egg_find_bar_get_property (GObject *object,

+ guint prop_id,

+ GValue *value,

+ GParamSpec *pspec)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (object);

+ EggFindBarPrivate *priv = (EggFindBarPrivate *)find_bar->priv;

+

+ switch (prop_id)

+ {

+ case PROP_SEARCH_STRING:

+ g_value_set_string (value, priv->search_string);

+ break;

+ case PROP_CASE_SENSITIVE:

+ g_value_set_boolean (value, priv->case_sensitive);

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ break;

+ }

+}

+

+static void

+egg_find_bar_show (GtkWidget *widget)

+{

+ EggFindBar *bar = EGG_FIND_BAR (widget);

+ EggFindBarPrivate *priv = bar->priv;

+

+ GTK_WIDGET_CLASS (egg_find_bar_parent_class)->show (widget);

+

+ if (priv->set_focus_handler == 0)

+ {

+ GtkWidget *toplevel;

+

+ toplevel = gtk_widget_get_toplevel (widget);

+

+ priv->set_focus_handler =

+ g_signal_connect (toplevel, "set-focus",

+ G_CALLBACK (set_focus_cb), bar);

+ }

+}

+

+static void

+egg_find_bar_hide (GtkWidget *widget)

+{

+ EggFindBar *bar = EGG_FIND_BAR (widget);

+ EggFindBarPrivate *priv = bar->priv;

+

+ if (priv->set_focus_handler != 0)

+ {

+ GtkWidget *toplevel;

+

+ toplevel = gtk_widget_get_toplevel (widget);

+

+ g_signal_handlers_disconnect_by_func

+ (toplevel, (void (*)) G_CALLBACK (set_focus_cb), bar);

+ priv->set_focus_handler = 0;

+ }

+

+ GTK_WIDGET_CLASS (egg_find_bar_parent_class)->hide (widget);

+}

+

+static void

+egg_find_bar_grab_focus (GtkWidget *widget)

+{

+ EggFindBar *find_bar = EGG_FIND_BAR (widget);

+ EggFindBarPrivate *priv = find_bar->priv;

+

+ gtk_widget_grab_focus (priv->find_entry);

+}

+

+/**

+ * egg_find_bar_new:

+ *

+ * Creates a new #EggFindBar.

+ *

+ * Returns: a newly created #EggFindBar

+ *

+ * Since: 2.6

+ */

+GtkWidget *

+egg_find_bar_new (void)

+{

+ EggFindBar *find_bar;

+

+ find_bar = g_object_new (EGG_TYPE_FIND_BAR, NULL);

+

+ return GTK_WIDGET (find_bar);

+}

+

+/**

+ * egg_find_bar_set_search_string:

+ *

+ * Sets the string that should be found/highlighted in the document.

+ * Empty string is converted to NULL.

+ *

+ * Since: 2.6

+ */

+void

+egg_find_bar_set_search_string (EggFindBar *find_bar,

+ const char *search_string)

+{

+ EggFindBarPrivate *priv;

+

+ g_return_if_fail (EGG_IS_FIND_BAR (find_bar));

+

+ priv = (EggFindBarPrivate *)find_bar->priv;

+

+ g_object_freeze_notify (G_OBJECT (find_bar));

+

+ if (priv->search_string != search_string)

+ {

+ char *old;

+

+ old = priv->search_string;

+

+ if (search_string && *search_string == '\0')

+ search_string = NULL;

+

+ /* Only update if the string has changed; setting the entry

+ * will emit changed on the entry which will re-enter

+ * this function, but we'll handle that fine with this

+ * short-circuit.

+ */

+ if ((old && search_string == NULL) ||

+ (old == NULL && search_string) ||

+ (old && search_string &&

+ strcmp (old, search_string) != 0))

+ {

+ gboolean not_empty;

+

+ priv->search_string = g_strdup (search_string);

+ g_free (old);

+

+ gtk_entry_set_text (GTK_ENTRY (priv->find_entry),

+ priv->search_string ?

+ priv->search_string :

+ "");

+

+ not_empty = (search_string == NULL) ? FALSE : TRUE;

+

+ gtk_widget_set_sensitive (GTK_WIDGET (find_bar->priv->next_button), not_empty);

+ gtk_widget_set_sensitive (GTK_WIDGET (find_bar->priv->previous_button), not_empty);

+

+ g_object_notify (G_OBJECT (find_bar),

+ "search_string");

+ }

+ }

+

+ g_object_thaw_notify (G_OBJECT (find_bar));

+}

+

+

+/**

+ * egg_find_bar_get_search_string:

+ *

+ * Gets the string that should be found/highlighted in the document.

+ *

+ * Returns: the string

+ *

+ * Since: 2.6

+ */

+const char*

+egg_find_bar_get_search_string (EggFindBar *find_bar)

+{

+ EggFindBarPrivate *priv;

+

+ g_return_val_if_fail (EGG_IS_FIND_BAR (find_bar), NULL);

+

+ priv = find_bar->priv;

+

+ return priv->search_string ? priv->search_string : "";

+}

+

+/**

+ * egg_find_bar_set_case_sensitive:

+ *

+ * Sets whether the search is case sensitive

+ *

+ * Since: 2.6

+ */

+void

+egg_find_bar_set_case_sensitive (EggFindBar *find_bar,

+ gboolean case_sensitive)

+{

+ EggFindBarPrivate *priv;

+

+ g_return_if_fail (EGG_IS_FIND_BAR (find_bar));

+

+ priv = (EggFindBarPrivate *)find_bar->priv;

+

+ g_object_freeze_notify (G_OBJECT (find_bar));

+

+ case_sensitive = case_sensitive != FALSE;

+

+ if (priv->case_sensitive != case_sensitive)

+ {

+ priv->case_sensitive = case_sensitive;

+

+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->case_button),

+ priv->case_sensitive);

+

+ g_object_notify (G_OBJECT (find_bar),

+ "case_sensitive");

+ }

+

+ g_object_thaw_notify (G_OBJECT (find_bar));

+}

+

+/**

+ * egg_find_bar_get_case_sensitive:

+ *

+ * Gets whether the search is case sensitive

+ *

+ * Returns: TRUE if it's case sensitive

+ *

+ * Since: 2.6

+ */

+gboolean

+egg_find_bar_get_case_sensitive (EggFindBar *find_bar)

+{

+ EggFindBarPrivate *priv;

+

+ g_return_val_if_fail (EGG_IS_FIND_BAR (find_bar), FALSE);

+

+ priv = (EggFindBarPrivate *)find_bar->priv;

+

+ return priv->case_sensitive;

+}

+

+static void

+get_style_color (EggFindBar *find_bar,

+ const char *style_prop_name,

+ GdkColor *color)

+{

+ GdkColor *style_color;

+

+ gtk_widget_ensure_style (GTK_WIDGET (find_bar));

+ gtk_widget_style_get (GTK_WIDGET (find_bar),

+ "color", &style_color, NULL);

+ if (style_color)

+ {

+ *color = *style_color;

+ gdk_color_free (style_color);

+ }

+}

+

+/**

+ * egg_find_bar_get_all_matches_color:

+ *

+ * Gets the color to use to highlight all the

+ * known matches.

+ *

+ * Since: 2.6

+ */

+void

+egg_find_bar_get_all_matches_color (EggFindBar *find_bar,

+ GdkColor *color)

+{

+ GdkColor found_color = { 0, 0, 0, 0x0f0f };

+

+ get_style_color (find_bar, "all_matches_color", &found_color);

+

+ *color = found_color;

+}

+

+/**

+ * egg_find_bar_get_current_match_color:

+ *

+ * Gets the color to use to highlight the match

+ * we're currently on.

+ *

+ * Since: 2.6

+ */

+void

+egg_find_bar_get_current_match_color (EggFindBar *find_bar,

+ GdkColor *color)

+{

+ GdkColor found_color = { 0, 0, 0, 0xffff };

+

+ get_style_color (find_bar, "current_match_color", &found_color);

+

+ *color = found_color;

+}

+

+/**

+ * egg_find_bar_set_status_text:

+ *

+ * Sets some text to display if there's space; typical text would

+ * be something like "5 results on this page" or "No results"

+ *

+ * @text: the text to display

+ *

+ * Since: 2.6

+ */

+void

+egg_find_bar_set_status_text (EggFindBar *find_bar,

+ const char *text)

+{

+ EggFindBarPrivate *priv;

+

+ g_return_if_fail (EGG_IS_FIND_BAR (find_bar));

+

+ priv = (EggFindBarPrivate *)find_bar->priv;

+

+ gtk_label_set_text (GTK_LABEL (priv->status_label), text);

+ g_object_set (priv->status_separator, "visible", text != NULL && *text != '\0', NULL);

+ g_object_set (priv->status_item, "visible", text != NULL && *text !='\0', NULL);

+}

+/* Copyright (C) 2004 Red Hat, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Library General Public License as

+ * published by the Free Software Foundation; either version 2 of the

+ * License, or (at your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Library General Public License for more details.

+ *

+ * You should have received a copy of the GNU Library General Public

+ * License along with the Mate Library; see the file COPYING.LIB. If not,

+ * write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

+ * Boston, MA 02110-1301, USA.

+ *

+ */

+

+#ifndef __EGG_FIND_BAR_H__

+#define __EGG_FIND_BAR_H__

+

+#include <gtk/gtk.h>

+

+G_BEGIN_DECLS

+

+#define EGG_TYPE_FIND_BAR (egg_find_bar_get_type ())

+#define EGG_FIND_BAR(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), EGG_TYPE_FIND_BAR, EggFindBar))

+#define EGG_FIND_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EGG_TYPE_FIND_BAR, EggFindBarClass))

+#define EGG_IS_FIND_BAR(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), EGG_TYPE_FIND_BAR))

+#define EGG_IS_FIND_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EGG_TYPE_FIND_BAR))

+#define EGG_FIND_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EGG_TYPE_FIND_BAR, EggFindBarClass))

+

+typedef struct _EggFindBar EggFindBar;

+typedef struct _EggFindBarClass EggFindBarClass;

+typedef struct _EggFindBarPrivate EggFindBarPrivate;

+

+struct _EggFindBar

+{

+ GtkToolbar parent;

+

+ /*< private >*/

+ EggFindBarPrivate *priv;

+};

+

+struct _EggFindBarClass

+{

+ GtkToolbarClass parent_class;

+

+ void (* next) (EggFindBar *find_bar);

+ void (* previous) (EggFindBar *find_bar);

+ void (* close) (EggFindBar *find_bar);

+ void (* scroll) (EggFindBar *find_bar, GtkScrollType* scroll);

+

+ /* Padding for future expansion */

+ void (*_gtk_reserved1) (void);

+ void (*_gtk_reserved2) (void);

+ void (*_gtk_reserved3) (void);

+ void (*_gtk_reserved4) (void);

+};

+

+GType egg_find_bar_get_type (void) G_GNUC_CONST;

+GtkWidget *egg_find_bar_new (void);

+

+void egg_find_bar_set_search_string (EggFindBar *find_bar,

+ const char *search_string);

+const char* egg_find_bar_get_search_string (EggFindBar *find_bar);

+void egg_find_bar_set_case_sensitive (EggFindBar *find_bar,

+ gboolean case_sensitive);

+gboolean egg_find_bar_get_case_sensitive (EggFindBar *find_bar);

+void egg_find_bar_get_all_matches_color (EggFindBar *find_bar,

+ GdkColor *color);

+void egg_find_bar_get_current_match_color (EggFindBar *find_bar,

+ GdkColor *color);

+void egg_find_bar_set_status_text (EggFindBar *find_bar,

+ const char *text);

+

+G_END_DECLS

+

+#endif /* __EGG_FIND_BAR_H__ */

+

+

+/* ev-annotation-properties-dialog.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2010 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

+ */

+

+#include <config.h>

+

+#include <glib/gi18n.h>

+

+#include "ev-annotation-properties-dialog.h"

+

+enum {

+ PROP_0,

+ PROP_ANNOT_TYPE

+};

+

+struct _EvAnnotationPropertiesDialog {

+ GtkDialog base_instance;

+

+ EvAnnotationType annot_type;

+ EvAnnotation *annot;

+

+ GtkWidget *table;

+

+ GtkWidget *author;

+ GtkWidget *color;

+ GtkWidget *opacity;

+ GtkWidget *popup_state;

+

+ /* Text Annotations */

+ GtkWidget *icon;

+};

+

+struct _EvAnnotationPropertiesDialogClass {

+ GtkDialogClass base_class;

+};

+

+G_DEFINE_TYPE (EvAnnotationPropertiesDialog, ev_annotation_properties_dialog, GTK_TYPE_DIALOG)

+

+static void

+ev_annotation_properties_dialog_dispose (GObject *object)

+{

+ EvAnnotationPropertiesDialog *dialog = EV_ANNOTATION_PROPERTIES_DIALOG (object);

+

+ if (dialog->annot) {

+ g_object_unref (dialog->annot);

+ dialog->annot = NULL;

+ }

+

+ G_OBJECT_CLASS (ev_annotation_properties_dialog_parent_class)->dispose (object);

+}

+

+static void

+ev_annotation_properties_dialog_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec)

+{

+ EvAnnotationPropertiesDialog *dialog = EV_ANNOTATION_PROPERTIES_DIALOG (object);

+

+ switch (prop_id) {

+ case PROP_ANNOT_TYPE:

+ dialog->annot_type = g_value_get_enum (value);

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ }

+}

+

+static void

+ev_annotation_properties_dialog_constructed (GObject *object)

+{

+ EvAnnotationPropertiesDialog *dialog = EV_ANNOTATION_PROPERTIES_DIALOG (object);

+ GtkWidget *contant_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));

+ GtkWidget *table = dialog->table;

+ GtkWidget *label;

+

+ contant_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));

+

+ switch (dialog->annot_type) {

+ case EV_ANNOTATION_TYPE_TEXT:

+ label = gtk_label_new (_("Icon:"));

+ gtk_misc_set_alignment (GTK_MISC (label), 0., 0.5);

+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5, 6,

+ GTK_FILL, GTK_FILL, 0, 0);

+ gtk_widget_show (label);

+

+ dialog->icon = gtk_combo_box_new_text ();

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Note"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Comment"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Key"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Help"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("New Paragraph"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Paragraph"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Insert"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Cross"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Circle"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->icon), _("Unknown"));

+ gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->icon), 0);

+ gtk_table_attach (GTK_TABLE (table), dialog->icon,

+ 1, 2, 5, 6,

+ GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);

+ gtk_widget_show (dialog->icon);

+

+ break;

+ case EV_ANNOTATION_TYPE_ATTACHMENT:

+ /* TODO */

+ default:

+ break;

+ }

+}

+

+static void

+ev_annotation_properties_dialog_init (EvAnnotationPropertiesDialog *annot_dialog)

+{

+ GtkDialog *dialog = GTK_DIALOG (annot_dialog);

+ GtkWidget *content_area;

+ GtkWidget *label;

+ GtkWidget *table;

+ GtkWidget *hbox;

+ gchar *markup;

+ GdkColor color = { 0, 65535, 65535, 0 };

+

+ gtk_window_set_title (GTK_WINDOW (annot_dialog), _("Annotation Properties"));

+ gtk_window_set_destroy_with_parent (GTK_WINDOW (annot_dialog), TRUE);

+ gtk_container_set_border_width (GTK_CONTAINER (annot_dialog), 5);

+ gtk_dialog_set_has_separator (dialog, FALSE);

+ gtk_dialog_add_buttons (dialog,

+ GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,

+ GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,

+ NULL);

+ gtk_dialog_set_default_response (dialog, GTK_RESPONSE_APPLY);

+

+ content_area = gtk_dialog_get_content_area (dialog);

+ gtk_box_set_spacing (GTK_BOX (content_area), 2);

+

+ table = gtk_table_new (5, 2, FALSE);

+ annot_dialog->table = table;

+ gtk_table_set_col_spacings (GTK_TABLE (table), 12);

+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);

+ gtk_container_set_border_width (GTK_CONTAINER (table), 12);

+ gtk_box_pack_start (GTK_BOX (content_area), table, FALSE, FALSE, 0);

+ gtk_widget_show (table);

+

+ label = gtk_label_new (_("Author:"));

+ gtk_misc_set_alignment (GTK_MISC (label), 0., 0.5);

+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,

+ GTK_FILL, GTK_FILL, 0, 0);

+ gtk_widget_show (label);

+

+ annot_dialog->author = gtk_entry_new ();

+ gtk_entry_set_text (GTK_ENTRY (annot_dialog->author), g_get_real_name ());

+ gtk_table_attach (GTK_TABLE (table), annot_dialog->author,

+ 1, 2, 0, 1,

+ GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);

+ gtk_widget_show (annot_dialog->author);

+

+ label = gtk_label_new (_("Color:"));

+ gtk_misc_set_alignment (GTK_MISC (label), 0., 0.5);

+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,

+ GTK_FILL, GTK_FILL, 0, 0);

+ gtk_widget_show (label);

+

+ annot_dialog->color = gtk_color_button_new_with_color (&color);

+ gtk_table_attach (GTK_TABLE (table), annot_dialog->color,

+ 1, 2, 1, 2,

+ GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);

+ gtk_widget_show (annot_dialog->color);

+

+ label = gtk_label_new (_("Style:"));

+ gtk_misc_set_alignment (GTK_MISC (label), 0., 0.5);

+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,

+ GTK_FILL, GTK_FILL, 0, 0);

+ gtk_widget_show (label);

+

+ annot_dialog->opacity = gtk_hscale_new_with_range (0, 100, 5);

+ gtk_range_set_value (GTK_RANGE (annot_dialog->opacity), 100);

+ gtk_table_attach (GTK_TABLE (table), annot_dialog->opacity,

+ 1, 2, 2, 3,

+ GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);

+ gtk_widget_show (annot_dialog->opacity);

+

+ hbox = gtk_hbox_new (FALSE, 6);

+

+ label = gtk_label_new (NULL);

+ markup = g_strdup_printf ("<small>%s</small>", _("Transparent"));

+ gtk_label_set_markup (GTK_LABEL (label), markup);

+ g_free (markup);

+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

+ gtk_widget_show (label);

+

+ label = gtk_label_new (NULL);

+ markup = g_strdup_printf ("<small>%s</small>", _("Opaque"));

+ gtk_label_set_markup (GTK_LABEL (label), markup);

+ g_free (markup);

+ gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);

+ gtk_widget_show (label);

+

+ gtk_table_attach (GTK_TABLE (table), hbox,

+ 1, 2, 3, 4,

+ GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);

+ gtk_widget_show (hbox);

+

+ label = gtk_label_new (_("Initial window state:"));

+ gtk_misc_set_alignment (GTK_MISC (label), 0., 0.5);

+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,

+ GTK_FILL, GTK_FILL, 0, 0);

+ gtk_widget_show (label);

+

+ annot_dialog->popup_state = gtk_combo_box_new_text ();

+ gtk_combo_box_append_text (GTK_COMBO_BOX (annot_dialog->popup_state), _("Open"));

+ gtk_combo_box_append_text (GTK_COMBO_BOX (annot_dialog->popup_state), _("Close"));

+ gtk_combo_box_set_active (GTK_COMBO_BOX (annot_dialog->popup_state), 1);

+ gtk_table_attach (GTK_TABLE (table), annot_dialog->popup_state,

+ 1, 2, 4, 5,

+ GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);

+ gtk_widget_show (annot_dialog->popup_state);

+}

+

+static void

+ev_annotation_properties_dialog_class_init (EvAnnotationPropertiesDialogClass *klass)

+{

+ GObjectClass *object_class = G_OBJECT_CLASS (klass);

+

+ object_class->dispose = ev_annotation_properties_dialog_dispose;

+ object_class->constructed = ev_annotation_properties_dialog_constructed;

+ object_class->set_property = ev_annotation_properties_dialog_set_property;

+

+ g_object_class_install_property (object_class,

+ PROP_ANNOT_TYPE,

+ g_param_spec_enum ("annot-type",

+ "AnnotType",

+ "The type of annotation",

+ EV_TYPE_ANNOTATION_TYPE,

+ EV_ANNOTATION_TYPE_TEXT,

+ G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));

+}

+

+GtkWidget *

+ev_annotation_properties_dialog_new (EvAnnotationType annot_type)

+{

+ return GTK_WIDGET (g_object_new (EV_TYPE_ANNOTATION_PROPERTIES_DIALOG,

+ "annot-type", annot_type,

+ NULL));

+}

+

+GtkWidget *

+ev_annotation_properties_dialog_new_with_annotation (EvAnnotation *annot)

+{

+ EvAnnotationPropertiesDialog *dialog;

+ const gchar *label;

+ gdouble opacity;

+ gboolean is_open;

+ GdkColor color;

+

+ dialog = (EvAnnotationPropertiesDialog *)ev_annotation_properties_dialog_new (ev_annotation_get_annotation_type (annot));

+ dialog->annot = g_object_ref (annot);

+

+ label = ev_annotation_markup_get_label (EV_ANNOTATION_MARKUP (annot));

+ if (label)

+ gtk_entry_set_text (GTK_ENTRY (dialog->author), label);

+

+ ev_annotation_get_color (annot, &color);

+ gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->color), &color);

+

+ opacity = ev_annotation_markup_get_opacity (EV_ANNOTATION_MARKUP (annot));

+ gtk_range_set_value (GTK_RANGE (dialog->opacity), opacity * 100);

+

+ is_open = ev_annotation_markup_get_popup_is_open (EV_ANNOTATION_MARKUP (annot));

+ gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->popup_state),

+ is_open ? 0 : 1);

+

+ if (EV_IS_ANNOTATION_TEXT (annot)) {

+ EvAnnotationText *annot_text = EV_ANNOTATION_TEXT (annot);

+

+ gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->icon),

+ ev_annotation_text_get_icon (annot_text));

+ }

+

+ return GTK_WIDGET (dialog);

+}

+

+const gchar *

+ev_annotation_properties_dialog_get_author (EvAnnotationPropertiesDialog *dialog)

+{

+ return gtk_entry_get_text (GTK_ENTRY (dialog->author));

+}

+

+void

+ev_annotation_properties_dialog_get_color (EvAnnotationPropertiesDialog *dialog,

+ GdkColor *color)

+{

+ gtk_color_button_get_color (GTK_COLOR_BUTTON (dialog->color), color);

+}

+

+gdouble

+ev_annotation_properties_dialog_get_opacity (EvAnnotationPropertiesDialog *dialog)

+{

+ return gtk_range_get_value (GTK_RANGE (dialog->opacity)) / 100;

+}

+

+gboolean

+ev_annotation_properties_dialog_get_popup_is_open (EvAnnotationPropertiesDialog *dialog)

+{

+ return gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->popup_state)) == 0;

+}

+

+EvAnnotationTextIcon

+ev_annotation_properties_dialog_get_text_icon (EvAnnotationPropertiesDialog *dialog)

+{

+ return gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->icon));

+}

+/* ev-annotation-properties-dialog.h

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2010 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

+ */

+

+#ifndef __EV_ANNOTATION_PROPERTIES_DIALOG_H__

+#define __EV_ANNOTATION_PROPERTIES_DIALOG_H__

+

+#include <gtk/gtk.h>

+#include <glib-object.h>

+

+#include <evince-document.h>

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_ANNOTATION_PROPERTIES_DIALOG (ev_annotation_properties_dialog_get_type())

+#define EV_ANNOTATION_PROPERTIES_DIALOG(o) (G_TYPE_CHECK_INSTANCE_CAST((o), EV_TYPE_ANNOTATION_PROPERTIES_DIALOG, EvAnnotationPropertiesDialog))

+#define EV_ANNOTATION_PROPERTIES_DIALOG_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EV_TYPE_ANNOTATION_PROPERTIES_DIALOG, EvAnnotationPropertiesDialogClass))

+#define EV_IS_ANNOTATION_PROPERTIES_DIALOG(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), EV_TYPE_ANNOTATION_PROPERTIES_DIALOG))

+#define EV_IS_ANNOTATION_PROPERTIES_DIALOG_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), EV_TYPE_ANNOTATION_PROPERTIES_DIALOG))

+#define EV_ANNOTATION_PROPERTIES_DIALOG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), EV_TYPE_ANNOTATION_PROPERTIES_DIALOG, EvAnnotationPropertiesDialogClass))

+

+typedef struct _EvAnnotationPropertiesDialog EvAnnotationPropertiesDialog;

+typedef struct _EvAnnotationPropertiesDialogClass EvAnnotationPropertiesDialogClass;

+

+GType ev_annotation_properties_dialog_get_type (void) G_GNUC_CONST;

+GtkWidget *ev_annotation_properties_dialog_new (EvAnnotationType annot_type);

+GtkWidget *ev_annotation_properties_dialog_new_with_annotation (EvAnnotation *annot);

+

+const gchar *ev_annotation_properties_dialog_get_author (EvAnnotationPropertiesDialog *dialog);

+void ev_annotation_properties_dialog_get_color (EvAnnotationPropertiesDialog *dialog,

+ GdkColor *color);

+gdouble ev_annotation_properties_dialog_get_opacity (EvAnnotationPropertiesDialog *dialog);

+gboolean ev_annotation_properties_dialog_get_popup_is_open (EvAnnotationPropertiesDialog *dialog);

+EvAnnotationTextIcon ev_annotation_properties_dialog_get_text_icon (EvAnnotationPropertiesDialog *dialog);

+

+G_END_DECLS

+

+#endif /* __EV_ANNOTATION_PROPERTIES_DIALOG_H__ */

+/* this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2004 Martin Kretzschmar

+ * Copyright © 2010 Christian Persch

+ *

+ * Author:

+ * Martin Kretzschmar <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+

+#include <config.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include <glib.h>

+#include <glib/gi18n.h>

+#include <glib/gstdio.h>

+#include <gtk/gtk.h>

+#ifdef GDK_WINDOWING_X11

+#include <gdk/gdkx.h>

+#endif

+#include <unistd.h>

+

+#include "totem-scrsaver.h"

+

+#ifdef WITH_SMCLIENT

+#include "eggsmclient.h"

+#endif

+

+#include "ev-application.h"

+#include "ev-file-helpers.h"

+#include "ev-stock-icons.h"

+

+#ifdef ENABLE_DBUS

+#include "ev-media-player-keys.h"

+#endif /* ENABLE_DBUS */

+

+struct _EvApplication {

+ GObject base_instance;

+

+ gchar *uri;

+

+ gchar *dot_dir;

+ gchar *data_dir;

+

+#ifdef ENABLE_DBUS

+ GDBusConnection *connection;

+ guint registration_id;

+ EvMediaPlayerKeys *keys;

+ gboolean doc_registered;

+#endif

+

+ TotemScrsaver *scr_saver;

+

+#ifdef WITH_SMCLIENT

+ EggSMClient *smclient;

+#endif

+

+ gchar *filechooser_open_uri;

+ gchar *filechooser_save_uri;

+};

+

+struct _EvApplicationClass {

+ GObjectClass base_class;

+};

+

+static EvApplication *instance;

+

+G_DEFINE_TYPE (EvApplication, ev_application, G_TYPE_OBJECT);

+

+#ifdef ENABLE_DBUS

+#define APPLICATION_DBUS_OBJECT_PATH "/org/mate/evince/Evince"

+#define APPLICATION_DBUS_INTERFACE "org.mate.evince.Application"

+

+#define EVINCE_DAEMON_SERVICE "org.mate.evince.Daemon"

+#define EVINCE_DAEMON_OBJECT_PATH "/org/mate/evince/Daemon"

+#define EVINCE_DAEMON_INTERFACE "org.mate.evince.Daemon"

+#endif

+

+static const gchar *userdir = NULL;

+

+static void _ev_application_open_uri_at_dest (EvApplication *application,

+ const gchar *uri,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint timestamp);

+static void ev_application_open_uri_in_window (EvApplication *application,

+ const char *uri,

+ EvWindow *ev_window,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint timestamp);

+

+/**

+ * ev_application_get_instance:

+ *

+ * Checks for #EvApplication instance, if it doesn't exist it does create it.

+ *

+ * Returns: an instance of the #EvApplication data.

+ */

+EvApplication *

+ev_application_get_instance (void)

+{

+ if (!instance) {

+ instance = EV_APPLICATION (g_object_new (EV_TYPE_APPLICATION, NULL));

+ }

+

+ return instance;

+}

+

+/* Session */

+gboolean

+ev_application_load_session (EvApplication *application)

+{

+ GKeyFile *state_file;

+ gchar *uri;

+

+#ifdef WITH_SMCLIENT

+ if (egg_sm_client_is_resumed (application->smclient)) {

+ state_file = egg_sm_client_get_state_file (application->smclient);

+ if (!state_file)

+ return FALSE;

+ } else

+#endif /* WITH_SMCLIENT */

+ return FALSE;

+

+ uri = g_key_file_get_string (state_file, "Evince", "uri", NULL);

+ if (!uri)

+ return FALSE;

+

+ ev_application_open_uri_at_dest (application, uri,

+ gdk_screen_get_default (),

+ NULL, 0, NULL,

+ GDK_CURRENT_TIME);

+ g_free (uri);

+ g_key_file_free (state_file);

+

+ return TRUE;

+}

+

+#ifdef WITH_SMCLIENT

+

+static void

+smclient_save_state_cb (EggSMClient *client,

+ GKeyFile *state_file,

+ EvApplication *application)

+{

+ if (!application->uri)

+ return;

+

+ g_key_file_set_string (state_file, "Evince", "uri", application->uri);

+}

+

+static void

+smclient_quit_cb (EggSMClient *client,

+ EvApplication *application)

+{

+ ev_application_shutdown (application);

+}

+#endif /* WITH_SMCLIENT */

+

+static void

+ev_application_init_session (EvApplication *application)

+{

+#ifdef WITH_SMCLIENT

+ application->smclient = egg_sm_client_get ();

+ g_signal_connect (application->smclient, "save_state",

+ G_CALLBACK (smclient_save_state_cb),

+ application);

+ g_signal_connect (application->smclient, "quit",

+ G_CALLBACK (smclient_quit_cb),

+ application);

+#endif

+}

+

+/**

+ * ev_display_open_if_needed:

+ * @name: the name of the display to be open if it's needed.

+ *

+ * Search among all the open displays if any of them have the same name as the

+ * passed name. If the display isn't found it tries the open it.

+ *

+ * Returns: a #GdkDisplay of the display with the passed name.

+ */

+static GdkDisplay *

+ev_display_open_if_needed (const gchar *name)

+{

+ GSList *displays;

+ GSList *l;

+ GdkDisplay *display = NULL;

+

+ displays = gdk_display_manager_list_displays (gdk_display_manager_get ());

+

+ for (l = displays; l != NULL; l = l->next) {

+ const gchar *display_name = gdk_display_get_name ((GdkDisplay *) l->data);

+

+ if (g_ascii_strcasecmp (display_name, name) == 0) {

+ display = l->data;

+ break;

+ }

+ }

+

+ g_slist_free (displays);

+

+ return display != NULL ? display : gdk_display_open (name);

+}

+

+static void

+child_setup (gpointer user_data)

+{

+ gchar *startup_id;

+

+ startup_id = g_strdup_printf ("_TIME%lu",

+ (unsigned long)GPOINTER_TO_INT (user_data));

+ g_setenv ("DESKTOP_STARTUP_ID", startup_id, TRUE);

+ g_free (startup_id);

+}

+

+static void

+ev_spawn (const char *uri,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint timestamp)

+{

+ gchar *argv[6];

+ guint arg = 0;

+ gint i;

+ gboolean res;

+ GError *error = NULL;

+

+#ifdef G_OS_WIN32

+{

+ gchar *dir;

+

+ dir = g_win32_get_package_installation_directory_of_module (NULL);

+ argv[arg++] = g_build_filename (dir, "bin", "evince", NULL);

+ g_free (dir);

+}

+#else

+ argv[arg++] = g_build_filename (BINDIR, "evince", NULL);

+#endif

+

+ /* Page label */

+ if (dest) {

+ const gchar *page_label;

+

+ page_label = ev_link_dest_get_page_label (dest);

+ if (page_label)

+ argv[arg++] = g_strdup_printf ("--page-label=%s", page_label);

+ else

+ argv[arg++] = g_strdup_printf ("--page-label=%d",

+ ev_link_dest_get_page (dest));

+ }

+

+ /* Find string */

+ if (search_string) {

+ argv[arg++] = g_strdup_printf ("--find=%s", search_string);

+ }

+

+ /* Mode */

+ switch (mode) {

+ case EV_WINDOW_MODE_FULLSCREEN:

+ argv[arg++] = g_strdup ("-f");

+ break;

+ case EV_WINDOW_MODE_PRESENTATION:

+ argv[arg++] = g_strdup ("-s");

+ break;

+ default:

+ break;

+ }

+

+ argv[arg++] = (gchar *)uri;

+ argv[arg] = NULL;

+

+ res = gdk_spawn_on_screen (screen, NULL /* wd */, argv, NULL /* env */,

+ 0,

+ child_setup,

+ GINT_TO_POINTER(timestamp),

+ NULL, &error);

+ if (!res) {

+ g_warning ("Error launching evince %s: %s\n", uri, error->message);

+ g_error_free (error);

+ }

+

+ for (i = 0; i < arg - 1; i++) {

+ g_free (argv[i]);

+ }

+}

+

+static GList *

+ev_application_get_windows (EvApplication *application)

+{

+ GList *l, *toplevels;

+ GList *windows = NULL;

+

+ toplevels = gtk_window_list_toplevels ();

+

+ for (l = toplevels; l != NULL; l = l->next) {

+ if (EV_IS_WINDOW (l->data)) {

+ windows = g_list_append (windows, l->data);

+ }

+ }

+

+ g_list_free (toplevels);

+

+ return windows;

+}

+

+static EvWindow *

+ev_application_get_empty_window (EvApplication *application,

+ GdkScreen *screen)

+{

+ EvWindow *empty_window = NULL;

+ GList *windows = ev_application_get_windows (application);

+ GList *l;

+

+ for (l = windows; l != NULL; l = l->next) {

+ EvWindow *window = EV_WINDOW (l->data);

+

+ if (ev_window_is_empty (window) &&

+ gtk_window_get_screen (GTK_WINDOW (window)) == screen) {

+ empty_window = window;

+ break;

+ }

+ }

+

+ g_list_free (windows);

+

+ return empty_window;

+}

+

+

+#ifdef ENABLE_DBUS

+typedef struct {

+ gchar *uri;

+ GdkScreen *screen;

+ EvLinkDest *dest;

+ EvWindowRunMode mode;

+ gchar *search_string;

+ guint timestamp;

+} EvRegisterDocData;

+

+static void

+ev_register_doc_data_free (EvRegisterDocData *data)

+{

+ if (!data)

+ return;

+

+ g_free (data->uri);

+ if (data->search_string)

+ g_free (data->search_string);

+ if (data->dest)

+ g_object_unref (data->dest);

+

+ g_free (data);

+}

+

+static void

+on_reload_cb (GObject *source_object,

+ GAsyncResult *res,

+ gpointer user_data)

+{

+ GDBusConnection *connection = G_DBUS_CONNECTION (source_object);

+ GVariant *value;

+ GError *error = NULL;

+

+ value = g_dbus_connection_call_finish (connection, res, &error);

+ if (!value) {

+ g_warning ("Failed to Reload: %s", error->message);

+ g_error_free (error);

+ }

+ g_variant_unref (value);

+

+ ev_application_shutdown (EV_APP);

+}

+

+static void

+on_register_uri_cb (GObject *source_object,

+ GAsyncResult *res,

+ gpointer user_data)

+{

+ GDBusConnection *connection = G_DBUS_CONNECTION (source_object);

+ EvRegisterDocData *data = (EvRegisterDocData *)user_data;

+ EvApplication *application = EV_APP;

+ GVariant *value;

+ const gchar *owner;

+ GVariantBuilder builder;

+ GError *error = NULL;

+

+ value = g_dbus_connection_call_finish (connection, res, &error);

+ if (!value) {

+ g_warning ("Error registering document: %s\n", error->message);

+ g_error_free (error);

+

+ _ev_application_open_uri_at_dest (application,

+ data->uri,

+ data->screen,

+ data->dest,

+ data->mode,

+ data->search_string,

+ data->timestamp);

+ ev_register_doc_data_free (data);

+

+ return;

+ }

+

+ g_variant_get (value, "(&s)", &owner);

+

+ /* This means that the document wasn't already registered; go

+ * ahead with opening it.

+ */

+ if (owner[0] == '\0') {

+ g_variant_unref (value);

+

+ application->doc_registered = TRUE;

+

+ _ev_application_open_uri_at_dest (application,

+ data->uri,

+ data->screen,

+ data->dest,

+ data->mode,

+ data->search_string,

+ data->timestamp);

+ ev_register_doc_data_free (data);

+

+ return;

+ }

+

+ /* Already registered */

+ g_variant_builder_init (&builder, G_VARIANT_TYPE ("(a{sv}u)"));

+ g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));

+ g_variant_builder_add (&builder, "{sv}",

+ "display",

+ g_variant_new_string (gdk_display_get_name (gdk_screen_get_display (data->screen))));

+ g_variant_builder_add (&builder, "{sv}",

+ "screen",

+ g_variant_new_int32 (gdk_screen_get_number (data->screen)));

+ if (data->dest) {

+ g_variant_builder_add (&builder, "{sv}",

+ "page-label",

+ g_variant_new_string (ev_link_dest_get_page_label (data->dest)));

+ }

+ if (data->search_string) {

+ g_variant_builder_add (&builder, "{sv}",

+ "find-string",

+ g_variant_new_string (data->search_string));

+ }

+ if (data->mode != EV_WINDOW_MODE_NORMAL) {

+ g_variant_builder_add (&builder, "{sv}",

+ "mode",

+ g_variant_new_uint32 (data->mode));

+ }

+ g_variant_builder_close (&builder);

+

+ g_variant_builder_add (&builder, "u", data->timestamp);

+

+ g_dbus_connection_call (connection,

+ owner,

+ APPLICATION_DBUS_OBJECT_PATH,

+ APPLICATION_DBUS_INTERFACE,

+ "Reload",

+ g_variant_builder_end (&builder),

+ NULL,

+ G_DBUS_CALL_FLAGS_NONE,

+ -1,

+ NULL,

+ on_reload_cb,

+ NULL);

+ g_variant_unref (value);

+ ev_register_doc_data_free (data);

+}

+

+/*

+ * ev_application_register_uri:

+ * @application:

+ * @uri:

+ * @screen:

+ * @dest:

+ * @mode:

+ * @search_string:

+ * @timestamp:

+ *

+ * Registers @uri with evince-daemon.

+ *

+ */

+static void

+ev_application_register_uri (EvApplication *application,

+ const gchar *uri,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint timestamp)

+{

+ EvRegisterDocData *data;

+

+ if (!application->connection)

+ return;

+

+ if (application->doc_registered) {

+ /* Already registered, reload */

+ GList *windows, *l;

+

+ windows = ev_application_get_windows (application);

+ for (l = windows; l != NULL; l = g_list_next (l)) {

+ EvWindow *ev_window = EV_WINDOW (l->data);

+

+ ev_application_open_uri_in_window (application, uri, ev_window,

+ screen, dest, mode,

+ search_string,

+ timestamp);

+ }

+ g_list_free (windows);

+

+ return;

+ }

+

+ data = g_new (EvRegisterDocData, 1);

+ data->uri = g_strdup (uri);

+ data->screen = screen;

+ data->dest = dest ? g_object_ref (dest) : NULL;

+ data->mode = mode;

+ data->search_string = search_string ? g_strdup (search_string) : NULL;

+ data->timestamp = timestamp;

+

+ g_dbus_connection_call (application->connection,

+ EVINCE_DAEMON_SERVICE,

+ EVINCE_DAEMON_OBJECT_PATH,

+ EVINCE_DAEMON_INTERFACE,

+ "RegisterDocument",

+ g_variant_new ("(s)", uri),

+ G_VARIANT_TYPE ("(s)"),

+ G_DBUS_CALL_FLAGS_NONE,

+ -1,

+ NULL,

+ on_register_uri_cb,

+ data);

+}

+

+static void

+ev_application_unregister_uri (EvApplication *application,

+ const gchar *uri)

+{

+ GVariant *value;

+ GError *error = NULL;

+

+ if (!application->doc_registered)

+ return;

+

+ /* This is called from ev_application_shutdown(),

+ * so it's safe to use the sync api

+ */

+ value = g_dbus_connection_call_sync (

+ application->connection,

+ EVINCE_DAEMON_SERVICE,

+ EVINCE_DAEMON_OBJECT_PATH,

+ EVINCE_DAEMON_INTERFACE,

+ "UnregisterDocument",

+ g_variant_new ("(s)", uri),

+ NULL,

+ G_DBUS_CALL_FLAGS_NO_AUTO_START,

+ -1,

+ NULL,

+ &error);

+ if (value == NULL) {

+ g_warning ("Error unregistering document: %s\n", error->message);

+ g_error_free (error);

+ } else {

+ g_variant_unref (value);

+ }

+}

+#endif /* ENABLE_DBUS */

+

+static void

+ev_application_open_uri_in_window (EvApplication *application,

+ const char *uri,

+ EvWindow *ev_window,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint timestamp)

+{

+#ifdef GDK_WINDOWING_X11

+ GdkWindow *gdk_window;

+#endif

+

+ if (screen) {

+ ev_stock_icons_set_screen (screen);

+ gtk_window_set_screen (GTK_WINDOW (ev_window), screen);

+ }

+

+ /* We need to load uri before showing the window, so

+ we can restore window size without flickering */

+ ev_window_open_uri (ev_window, uri, dest, mode, search_string);

+

+ if (!gtk_widget_get_realized (GTK_WIDGET (ev_window)))

+ gtk_widget_realize (GTK_WIDGET (ev_window));

+

+#ifdef GDK_WINDOWING_X11

+ gdk_window = gtk_widget_get_window (GTK_WIDGET (ev_window));

+

+ if (timestamp <= 0)

+ timestamp = gdk_x11_get_server_time (gdk_window);

+ gdk_x11_window_set_user_time (gdk_window, timestamp);

+

+ gtk_window_present (GTK_WINDOW (ev_window));

+#else

+ gtk_window_present_with_time (GTK_WINDOW (ev_window), timestamp);

+#endif /* GDK_WINDOWING_X11 */

+}

+

+static void

+_ev_application_open_uri_at_dest (EvApplication *application,

+ const gchar *uri,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint timestamp)

+{

+ EvWindow *ev_window;

+

+ ev_window = ev_application_get_empty_window (application, screen);

+ if (!ev_window)

+ ev_window = EV_WINDOW (ev_window_new ());

+

+ ev_application_open_uri_in_window (application, uri, ev_window,

+ screen, dest, mode,

+ search_string,

+ timestamp);

+}

+

+/**

+ * ev_application_open_uri_at_dest:

+ * @application: The instance of the application.

+ * @uri: The uri to be opened.

+ * @screen: Thee screen where the link will be shown.

+ * @dest: The #EvLinkDest of the document.

+ * @mode: The run mode of the window.

+ * @timestamp: Current time value.

+ */

+void

+ev_application_open_uri_at_dest (EvApplication *application,

+ const char *uri,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint timestamp)

+{

+ g_return_if_fail (uri != NULL);

+

+ if (application->uri && strcmp (application->uri, uri) != 0) {

+ /* spawn a new evince process */

+ ev_spawn (uri, screen, dest, mode, search_string, timestamp);

+ return;

+ } else if (!application->uri) {

+ application->uri = g_strdup (uri);

+ }

+

+#ifdef ENABLE_DBUS

+ /* Register the uri or send Reload to

+ * remote instance if already registered

+ */

+ ev_application_register_uri (application, uri, screen, dest, mode, search_string, timestamp);

+#else

+ _ev_application_open_uri_at_dest (application, uri, screen, dest, mode, search_string, timestamp);

+#endif /* ENABLE_DBUS */

+}

+

+/**

+ * ev_application_open_window:

+ * @application: The instance of the application.

+ * @timestamp: Current time value.

+ *

+ * Creates a new window

+ */

+void

+ev_application_open_window (EvApplication *application,

+ GdkScreen *screen,

+ guint32 timestamp)

+{

+ GtkWidget *new_window = ev_window_new ();

+#ifdef GDK_WINDOWING_X11

+ GdkWindow *gdk_window;

+#endif

+

+ if (screen) {

+ ev_stock_icons_set_screen (screen);

+ gtk_window_set_screen (GTK_WINDOW (new_window), screen);

+ }

+

+ if (!gtk_widget_get_realized (new_window))

+ gtk_widget_realize (new_window);

+

+#ifdef GDK_WINDOWING_X11

+ gdk_window = gtk_widget_get_window (GTK_WIDGET (new_window));

+

+ if (timestamp <= 0)

+ timestamp = gdk_x11_get_server_time (gdk_window);

+ gdk_x11_window_set_user_time (gdk_window, timestamp);

+

+ gtk_window_present (GTK_WINDOW (new_window));

+#else

+ gtk_window_present_with_time (GTK_WINDOW (new_window), timestamp);

+#endif /* GDK_WINDOWING_X11 */

+}

+

+#ifdef ENABLE_DBUS

+static void

+method_call_cb (GDBusConnection *connection,

+ const gchar *sender,

+ const gchar *object_path,

+ const gchar *interface_name,

+ const gchar *method_name,

+ GVariant *parameters,

+ GDBusMethodInvocation *invocation,

+ gpointer user_data)

+{

+ EvApplication *application = EV_APPLICATION (user_data);

+ GList *windows, *l;

+ guint timestamp;

+ GVariantIter *iter;

+ const gchar *key;

+ GVariant *value;

+ GdkDisplay *display = NULL;

+ int screen_number = 0;

+ EvLinkDest *dest = NULL;

+ EvWindowRunMode mode = EV_WINDOW_MODE_NORMAL;

+ const gchar *search_string = NULL;

+ GdkScreen *screen = NULL;

+

+ if (g_strcmp0 (method_name, "Reload") == 0) {

+ g_variant_get (parameters, "(a{sv}u)", &iter, &timestamp);

+

+ while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) {

+ if (strcmp (key, "display") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {

+ display = ev_display_open_if_needed (g_variant_get_string (value, NULL));

+ } else if (strcmp (key, "screen") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {

+ screen_number = g_variant_get_int32 (value);

+ } else if (strcmp (key, "mode") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_UINT32) {

+ mode = g_variant_get_uint32 (value);

+ } else if (strcmp (key, "page-label") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {

+ dest = ev_link_dest_new_page_label (g_variant_get_string (value, NULL));

+ } else if (strcmp (key, "find-string") == 0 && g_variant_classify (value) == G_VARIANT_CLASS_STRING) {

+ search_string = g_variant_get_string (value, NULL);

+ }

+ }

+ g_variant_iter_free (iter);

+

+ if (display != NULL &&

+ screen_number >= 0 &&

+ screen_number < gdk_display_get_n_screens (display))

+ screen = gdk_display_get_screen (display, screen_number);

+ else

+ screen = gdk_screen_get_default ();

+

+ windows = ev_application_get_windows (application);

+ for (l = windows; l != NULL; l = g_list_next (l)) {

+ EvWindow *ev_window = EV_WINDOW (l->data);

+

+ ev_application_open_uri_in_window (application, application->uri,

+ ev_window,

+ screen, dest, mode,

+ search_string,

+ timestamp);

+ }

+ g_list_free (windows);

+

+ if (dest)

+ g_object_unref (dest);

+

+ g_dbus_method_invocation_return_value (invocation, g_variant_new ("()"));

+ } else if (g_strcmp0 (method_name, "GetWindowList") == 0) {

+ GList *windows = ev_application_get_windows (application);

+ GVariantBuilder builder;

+ GList *l;

+

+ g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ao)"));

+ g_variant_builder_open (&builder, G_VARIANT_TYPE ("ao"));

+

+ for (l = windows; l; l = g_list_next (l)) {

+ EvWindow *window = (EvWindow *)l->data;

+

+ g_variant_builder_add (&builder, "o", ev_window_get_dbus_object_path (window));

+ }

+

+ g_variant_builder_close (&builder);

+ g_list_free (windows);

+

+ g_dbus_method_invocation_return_value (invocation, g_variant_builder_end (&builder));

+ }

+}

+

+static const char introspection_xml[] =

+ "<node>"

+ "<interface name='org.mate.evince.Application'>"

+ "<method name='Reload'>"

+ "<arg type='a{sv}' name='args' direction='in'/>"

+ "<arg type='u' name='timestamp' direction='in'/>"

+ "</method>"

+ "<method name='GetWindowList'>"

+ "<arg type='ao' name='window_list' direction='out'/>"

+ "</method>"

+ "</interface>"

+ "</node>";

+

+static const GDBusInterfaceVTable interface_vtable = {

+ method_call_cb,

+ NULL,

+ NULL

+};

+

+static GDBusNodeInfo *introspection_data;

+#endif /* ENABLE_DBUS */

+

+void

+ev_application_open_uri_list (EvApplication *application,

+ GSList *uri_list,

+ GdkScreen *screen,

+ guint timestamp)

+{

+ GSList *l;

+

+ for (l = uri_list; l != NULL; l = l->next) {

+ ev_application_open_uri_at_dest (application, (char *)l->data,

+ screen, NULL, 0, NULL,

+ timestamp);

+ }

+}

+

+static void

+ev_application_accel_map_save (EvApplication *application)

+{

+ gchar *accel_map_file;

+ gchar *tmp_filename;

+ gint fd;

+

+ if (userdir) {

+ accel_map_file = g_build_filename (userdir, "accels",

+ "evince", NULL);

+ } else {

+ accel_map_file = g_build_filename (g_get_home_dir (),

+ ".mate2", "accels",

+ "evince", NULL);

+ }

+

+ tmp_filename = g_strdup_printf ("%s.XXXXXX", accel_map_file);

+

+ fd = g_mkstemp (tmp_filename);

+ if (fd == -1) {

+ g_free (accel_map_file);

+ g_free (tmp_filename);

+

+ return;

+ }

+ gtk_accel_map_save_fd (fd);

+ close (fd);

+

+ if (g_rename (tmp_filename, accel_map_file) == -1) {

+ /* FIXME: win32? */

+ g_unlink (tmp_filename);

+ }

+

+ g_free (accel_map_file);

+ g_free (tmp_filename);

+}

+

+static void

+ev_application_accel_map_load (EvApplication *application)

+{

+ gchar *accel_map_file;

+

+ if (userdir) {

+ accel_map_file = g_build_filename (userdir, "accels",

+ "evince", NULL);

+ } else {

+ accel_map_file = g_build_filename (g_get_home_dir (),

+ ".mate2", "accels",

+ "evince", NULL);

+ }

+

+ gtk_accel_map_load (accel_map_file);

+ g_free (accel_map_file);

+}

+

+void

+ev_application_shutdown (EvApplication *application)

+{

+ if (application->uri) {

+#ifdef ENABLE_DBUS

+ ev_application_unregister_uri (application,

+ application->uri);

+#endif

+ g_free (application->uri);

+ application->uri = NULL;

+ }

+

+ ev_application_accel_map_save (application);

+

+ g_object_unref (application->scr_saver);

+ application->scr_saver = NULL;

+

+#ifdef ENABLE_DBUS

+ if (application->keys) {

+ g_object_unref (application->keys);

+ application->keys = NULL;

+ }

+ if (application->registration_id != 0) {

+ g_dbus_connection_unregister_object (application->connection,

+ application->registration_id);

+ application->registration_id = 0;

+ }

+ if (application->connection != NULL) {

+ g_object_unref (application->connection);

+ application->connection = NULL;

+ }

+ if (introspection_data) {

+ g_dbus_node_info_ref (introspection_data);

+ introspection_data = NULL;

+ }

+#endif /* ENABLE_DBUS */

+

+ g_free (application->dot_dir);

+ application->dot_dir = NULL;

+ g_free (application->data_dir);

+ application->data_dir = NULL;

+ g_free (application->filechooser_open_uri);

+ application->filechooser_open_uri = NULL;

+ g_free (application->filechooser_save_uri);

+ application->filechooser_save_uri = NULL;

+

+ g_object_unref (application);

+ instance = NULL;

+

+ gtk_main_quit ();

+}

+

+static void

+ev_application_class_init (EvApplicationClass *ev_application_class)

+{

+}

+

+static void

+ev_application_init (EvApplication *ev_application)

+{

+ GError *error = NULL;

+

+ userdir = g_getenv ("MATE22_USER_DIR");

+ if (userdir)

+ ev_application->dot_dir = g_build_filename (userdir, "evince", NULL);

+ else

+ ev_application->dot_dir = g_build_filename (g_get_home_dir (),

+ ".mate2",

+ "evince",

+ NULL);

+

+#ifdef G_OS_WIN32

+{

+ gchar *dir;

+

+ dir = g_win32_get_package_installation_directory_of_module (NULL);

+ ev_application->data_dir = g_build_filename (dir, "share", "evince", NULL);

+ g_free (dir);

+}

+#else

+ ev_application->data_dir = g_strdup (EVINCEDATADIR);

+#endif

+

+ ev_application_init_session (ev_application);

+

+ ev_application_accel_map_load (ev_application);

+

+#ifdef ENABLE_DBUS

+ ev_application->connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);

+ if (ev_application->connection != NULL) {

+ introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);

+ g_assert (introspection_data != NULL);

+

+ ev_application->registration_id =

+ g_dbus_connection_register_object (ev_application->connection,

+ APPLICATION_DBUS_OBJECT_PATH,

+ introspection_data->interfaces[0],

+ &interface_vtable,

+ ev_application, NULL,

+ &error);

+ if (ev_application->registration_id == 0) {

+ g_printerr ("Failed to register bus object: %s\n", error->message);

+ g_error_free (error);

+ }

+ } else {

+ g_printerr ("Failed to get bus connection: %s\n", error->message);

+ g_error_free (error);

+ }

+

+ ev_application->keys = ev_media_player_keys_new ();

+#endif /* ENABLE_DBUS */

+

+ ev_application->scr_saver = totem_scrsaver_new ();

+ g_object_set (ev_application->scr_saver,

+ "reason", _("Running in presentation mode"),

+ NULL);

+}

+

+GDBusConnection *

+ev_application_get_dbus_connection (EvApplication *application)

+{

+#ifdef ENABLE_DBUS

+ return application->connection;

+#else

+ return NULL;

+#endif

+}

+

+gboolean

+ev_application_has_window (EvApplication *application)

+{

+ GList *l, *toplevels;

+ gboolean retval = FALSE;

+

+ toplevels = gtk_window_list_toplevels ();

+

+ for (l = toplevels; l != NULL && !retval; l = l->next) {

+ if (EV_IS_WINDOW (l->data))

+ retval = TRUE;

+ }

+

+ g_list_free (toplevels);

+

+ return retval;

+}

+

+guint

+ev_application_get_n_windows (EvApplication *application)

+{

+ GList *l, *toplevels;

+ guint retval = 0;

+

+ toplevels = gtk_window_list_toplevels ();

+

+ for (l = toplevels; l != NULL; l = l->next) {

+ if (EV_IS_WINDOW (l->data))

+ retval++;

+ }

+

+ g_list_free (toplevels);

+

+ return retval;

+}

+

+const gchar *

+ev_application_get_uri (EvApplication *application)

+{

+ return application->uri;

+}

+

+/**

+ * ev_application_get_media_keys:

+ * @application: The instance of the application.

+ *

+ * It gives you access to the media player keys handler object.

+ *

+ * Returns: A #EvMediaPlayerKeys.

+ */

+GObject *

+ev_application_get_media_keys (EvApplication *application)

+{

+#ifdef ENABLE_DBUS

+ return G_OBJECT (application->keys);

+#else

+ return NULL;

+#endif /* ENABLE_DBUS */

+}

+

+void

+ev_application_set_filechooser_uri (EvApplication *application,

+ GtkFileChooserAction action,

+ const gchar *uri)

+{

+ if (action == GTK_FILE_CHOOSER_ACTION_OPEN) {

+ g_free (application->filechooser_open_uri);

+ application->filechooser_open_uri = g_strdup (uri);

+ } else if (action == GTK_FILE_CHOOSER_ACTION_SAVE) {

+ g_free (application->filechooser_save_uri);

+ application->filechooser_save_uri = g_strdup (uri);

+ }

+}

+

+const gchar *

+ev_application_get_filechooser_uri (EvApplication *application,

+ GtkFileChooserAction action)

+{

+ if (action == GTK_FILE_CHOOSER_ACTION_OPEN) {

+ if (application->filechooser_open_uri)

+ return application->filechooser_open_uri;

+ } else if (action == GTK_FILE_CHOOSER_ACTION_SAVE) {

+ if (application->filechooser_save_uri)

+ return application->filechooser_save_uri;

+ }

+

+ return NULL;

+}

+

+void

+ev_application_screensaver_enable (EvApplication *application)

+{

+ totem_scrsaver_enable (application->scr_saver);

+}

+

+void

+ev_application_screensaver_disable (EvApplication *application)

+{

+ totem_scrsaver_disable (application->scr_saver);

+}

+

+const gchar *

+ev_application_get_dot_dir (EvApplication *application,

+ gboolean create)

+{

+ if (create)

+ g_mkdir_with_parents (application->dot_dir, 0700);

+

+ return application->dot_dir;

+}

+

+const gchar *

+ev_application_get_data_dir (EvApplication *application)

+{

+ return application->data_dir;

+}

+/* this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2004 Martin Kretzschmar

+ *

+ * Author:

+ * Martin Kretzschmar <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef EV_APPLICATION_H

+#define EV_APPLICATION_H

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include <glib.h>

+#include <gtk/gtk.h>

+

+#include "ev-window.h"

+

+G_BEGIN_DECLS

+

+typedef struct _EvApplication EvApplication;

+typedef struct _EvApplicationClass EvApplicationClass;

+

+#define EV_TYPE_APPLICATION (ev_application_get_type ())

+#define EV_APPLICATION(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_APPLICATION, EvApplication))

+#define EV_APPLICATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_APPLICATION, EvApplicationClass))

+#define EV_IS_APPLICATION(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_APPLICATION))

+#define EV_IS_APPLICATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), EV_TYPE_APPLICATION))

+#define EV_APPLICATION_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object), EV_TYPE_APPLICATION, EvApplicationClass))

+

+#define EV_APP (ev_application_get_instance ())

+

+GType ev_application_get_type (void) G_GNUC_CONST;

+EvApplication *ev_application_get_instance (void);

+

+void ev_application_shutdown (EvApplication *application);

+gboolean ev_application_load_session (EvApplication *application);

+void ev_application_open_window (EvApplication *application,

+ GdkScreen *screen,

+ guint32 timestamp);

+void ev_application_open_uri_at_dest (EvApplication *application,

+ const char *uri,

+ GdkScreen *screen,

+ EvLinkDest *dest,

+ EvWindowRunMode mode,

+ const gchar *search_string,

+ guint32 timestamp);

+void ev_application_open_uri_list (EvApplication *application,

+ GSList *uri_list,

+ GdkScreen *screen,

+ guint32 timestamp);

+GDBusConnection *ev_application_get_dbus_connection (EvApplication *application);

+gboolean ev_application_has_window (EvApplication *application);

+guint ev_application_get_n_windows (EvApplication *application);

+const gchar * ev_application_get_uri (EvApplication *application);

+GObject *ev_application_get_media_keys (EvApplication *application);

+

+void ev_application_set_filechooser_uri (EvApplication *application,

+ GtkFileChooserAction action,

+ const gchar *uri);

+const gchar *ev_application_get_filechooser_uri (EvApplication *application,

+ GtkFileChooserAction action);

+void ev_application_screensaver_enable (EvApplication *application);

+void ev_application_screensaver_disable (EvApplication *application);

+const gchar *ev_application_get_dot_dir (EvApplication *application,

+ gboolean create);

+const gchar *ev_application_get_data_dir (EvApplication *application);

+

+G_END_DECLS

+

+#endif /* !EV_APPLICATION_H */

+

+/* ev-convert-metadata.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2009 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+//#include <config.h>

+

+#include <gtk/gtk.h>

+#include <glib.h>

+#include <gio/gio.h>

+#include <glib/gi18n.h>

+#include <string.h>

+#include <libxml/tree.h>

+

+#define EV_METADATA_NAMESPACE "metadata::evince"

+

+typedef struct {

+ xmlNodePtr cur;

+ xmlChar *uri;

+} DocItem;

+

+typedef struct {

+ GtkWidget *progress;

+ GtkWidget *label;

+

+ xmlDocPtr doc;

+ GList *items;

+ GList *current;

+ guint n_item;

+} ConvertData;

+

+static void

+free_doc_item (DocItem *item)

+{

+ xmlFree (item->uri);

+ g_free (item);

+}

+

+static void

+convert_finish (ConvertData *data)

+{

+ g_list_foreach (data->items, (GFunc)free_doc_item, NULL);

+ g_list_free (data->items);

+ xmlFreeDoc (data->doc);

+ g_free (data);

+

+ gtk_main_quit ();

+}

+

+static gboolean

+convert_file (ConvertData *data)

+{

+ GFile *file;

+ DocItem *item;

+ const gchar *uri;

+ xmlNodePtr node;

+ xmlNodePtr cur;

+ gint total, current;

+ gchar *text;

+

+ if (!data->current)

+ return FALSE;

+

+ item = (DocItem *) data->current->data;

+ uri = (const gchar *)item->uri;

+ node = item->cur;

+ data->current = g_list_next (data->current);

+

+ /* Update progress information */

+ total = g_list_length (data->items);

+ current = ++(data->n_item);

+

+ text = g_strdup_printf (_("Converting %s"), uri);

+ gtk_label_set_text (GTK_LABEL (data->label), text);

+ g_free (text);

+

+ text = g_strdup_printf (_("%d of %d documents converted"), current, total);

+ gtk_progress_bar_set_text (GTK_PROGRESS_BAR (data->progress), text);

+ g_free (text);

+ gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (data->progress),

+ (gdouble)(current - 1) / total);

+

+ file = g_file_new_for_uri (uri);

+ if (!g_file_query_exists (file, NULL)) {

+ g_printerr ("Uri %s does not exist\n", uri);

+ g_object_unref (file);

+

+ return data->current != NULL;

+ }

+

+ for (cur = node->xmlChildrenNode; cur != NULL; cur = cur->next) {

+ xmlChar *key;

+ xmlChar *value;

+

+ if (xmlStrcmp (cur->name, (const xmlChar *)"entry") != 0)

+ continue;

+

+ key = xmlGetProp (cur, (const xmlChar *)"key");

+ value = xmlGetProp (cur, (const xmlChar *)"value");

+ if (key && value) {

+ GFileInfo *info;

+ gchar *gio_key;

+ GError *error = NULL;

+

+ info = g_file_info_new ();

+

+ gio_key = g_strconcat (EV_METADATA_NAMESPACE"::", key, NULL);

+ g_file_info_set_attribute_string (info, gio_key, (const gchar *)value);

+ g_free (gio_key);

+

+ if (!g_file_set_attributes_from_info (file, info, 0, NULL, &error)) {

+ g_printerr ("Error setting metadata for %s: %s\n",

+ uri, error->message);

+ g_error_free (error);

+ }

+

+ g_object_unref (info);

+ }

+

+ if (key)

+ xmlFree (key);

+ if (value)

+ xmlFree (value);

+ }

+

+ g_object_unref (file);

+

+ return data->current != NULL;

+}

+

+static void

+convert_metadata_cancel (GtkDialog *dialog,

+ gint response_id,

+ ConvertData *data)

+{

+ convert_finish (data);

+ exit (1);

+}

+

+static void

+show_progress_dialog (ConvertData *data)

+{

+ GtkWidget *dialog;

+ GtkWidget *action_area;

+ GtkWidget *vbox, *pbox;

+ GtkWidget *label;

+ GtkWidget *progress;

+ gchar *text;

+

+ dialog = gtk_dialog_new_with_buttons (_("Converting metadata"),

+ NULL,

+ GTK_DIALOG_NO_SEPARATOR,

+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,

+ NULL);

+ action_area = gtk_dialog_get_action_area (GTK_DIALOG (dialog));

+ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);

+ gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);

+ gtk_box_set_spacing (GTK_BOX (action_area), 6);

+

+ vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));

+ gtk_box_set_spacing (GTK_BOX (vbox), 12);

+

+ label = gtk_label_new (NULL);

+ gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);

+ text = g_strdup_printf ("<b>%s</b>", _("Converting metadata"));

+ gtk_label_set_markup (GTK_LABEL (label), text);

+ g_free (text);

+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

+ gtk_widget_show (label);

+

+ label = gtk_label_new (_("The metadata format used by Evince "

+ "has changed, and hence it needs to be migrated. "

+ "If the migration is cancelled the metadata "

+ "storage will not work."));

+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);

+ gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

+ gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);

+ gtk_widget_show (label);

+

+ pbox = gtk_vbox_new (FALSE, 6);

+ progress = gtk_progress_bar_new ();

+ data->progress = progress;

+ gtk_box_pack_start (GTK_BOX (pbox), progress, TRUE, TRUE, 0);

+ gtk_widget_show (progress);

+

+ label = gtk_label_new (NULL);

+ data->label = label;

+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);

+ gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);

+ gtk_box_pack_start (GTK_BOX (pbox), label, FALSE, FALSE, 0);

+ gtk_widget_show (label);

+

+ gtk_box_pack_start (GTK_BOX (vbox), pbox, TRUE, TRUE, 0);

+ gtk_widget_show (pbox);

+

+ g_signal_connect (dialog, "response",

+ G_CALLBACK (convert_metadata_cancel),

+ data);

+

+ gtk_widget_show (dialog);

+}

+

+static gboolean

+convert_metadata_file (const gchar *filename)

+{

+ ConvertData *data;

+ xmlDocPtr doc;

+ xmlNodePtr cur;

+

+ if (!g_file_test (filename, G_FILE_TEST_EXISTS))

+ return FALSE;

+

+ doc = xmlParseFile (filename);

+ if (!doc) {

+ g_printerr ("Error loading metadata file %s\n", filename);

+ return FALSE;

+ }

+

+ cur = xmlDocGetRootElement (doc);

+ if (!cur) {

+ g_printerr ("Metadata file %s is empty\n", filename);

+ xmlFreeDoc (doc);

+ return TRUE;

+ }

+

+ if (xmlStrcmp (cur->name, (const xmlChar *) "metadata")) {

+ g_printerr ("File %s is not a valid evince metadata file\n", filename);

+ xmlFreeDoc (doc);

+ return FALSE;

+ }

+

+ data = g_new0 (ConvertData, 1);

+ data->doc = doc;

+

+ for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) {

+ xmlChar *uri;

+ DocItem *item;

+

+ if (xmlStrcmp (cur->name, (const xmlChar *)"document") != 0)

+ continue;

+

+ uri = xmlGetProp (cur, (const xmlChar *)"uri");

+ if (!uri)

+ continue;

+

+ item = g_new (DocItem, 1);

+ item->uri = uri;

+ item->cur = cur;

+ data->items = g_list_prepend (data->items, item);

+ }

+

+ if (!data->items) {

+ xmlFreeDoc (data->doc);

+ g_free (data);

+

+ return TRUE;

+ }

+

+ show_progress_dialog (data);

+

+ data->current = data->items;

+ g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,

+ (GSourceFunc)convert_file,

+ data,

+ (GDestroyNotify)convert_finish);

+

+ return TRUE;

+}

+

+gint

+main (gint argc, gchar **argv)

+{

+ if (argc != 2) {

+ g_printerr ("%s\n", "Usage: evince-convert-metadata FILE");

+ return 1;

+ }

+

+ gtk_init (&argc, &argv);

+

+ if (!convert_metadata_file (argv[1]))

+ return 1;

+

+ gtk_main ();

+

+ return 0;

+}

+/* ev-metadata.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2009 Carlos Garcia Campos <[email protected]>

+ * Copyright © 2010 Christian Persch

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#include "config.h"

+

+#include <glib.h>

+#include <glib/gstdio.h>

+#include <gio/gio.h>

+#include <string.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <sys/wait.h>

+#include <fcntl.h>

+#include <unistd.h>

+

+#define EV_DBUS_DAEMON_NAME "org.mate.evince.Daemon"

+#define EV_DBUS_DAEMON_INTERFACE_NAME "org.mate.evince.Daemon"

+#define EV_DBUS_DAEMON_OBJECT_PATH "/org/mate/evince/Daemon"

+

+#define EV_DBUS_WINDOW_INTERFACE_NAME "org.mate.evince.Window"

+

+#define DAEMON_TIMEOUT (30) /* seconds */

+

+#define LOG g_printerr

+

+static GList *ev_daemon_docs = NULL;

+static guint kill_timer_id;

+static GHashTable *pending_invocations = NULL;

+

+typedef struct {

+ gchar *dbus_name;

+ gchar *uri;

+ guint watch_id;

+ guint loaded_id;

+} EvDoc;

+

+static void

+ev_doc_free (EvDoc *doc)

+{

+ if (!doc)

+ return;

+

+ g_free (doc->dbus_name);

+ g_free (doc->uri);

+

+ g_bus_unwatch_name (doc->watch_id);

+

+ g_free (doc);

+}

+

+static EvDoc *

+ev_daemon_find_doc (const gchar *uri)

+{

+ GList *l;

+

+ for (l = ev_daemon_docs; l != NULL; l = l->next) {

+ EvDoc *doc = (EvDoc *)l->data;

+

+ if (strcmp (doc->uri, uri) == 0)

+ return doc;

+ }

+

+ return NULL;

+}

+

+static void

+ev_daemon_stop_killtimer (void)

+{

+ if (kill_timer_id != 0)

+ g_source_remove (kill_timer_id);

+ kill_timer_id = 0;

+}

+

+static gboolean

+ev_daemon_shutdown (gpointer user_data)

+{

+ GMainLoop *loop = (GMainLoop *) user_data;

+

+ LOG ("Timeout; exiting daemon.\n");

+

+ if (g_main_loop_is_running (loop))

+ g_main_loop_quit (loop);

+

+ return FALSE;

+}

+

+static void

+ev_daemon_maybe_start_killtimer (gpointer data)

+{

+ ev_daemon_stop_killtimer ();

+ if (ev_daemon_docs != NULL)

+ return;

+

+ kill_timer_id = g_timeout_add_seconds (DAEMON_TIMEOUT,

+ (GSourceFunc) ev_daemon_shutdown,

+ data);

+}

+

+static gboolean

+convert_metadata (const gchar *metadata)

+{

+ GFile *file;

+ char *argv[3];

+ gint exit_status;

+ GFileAttributeInfoList *namespaces;

+ gboolean supported = FALSE;

+ GError *error = NULL;

+ gboolean retval;

+

+ /* If metadata is not supported for a local file

+ * is likely because and old gvfs version is running.

+ */

+ file = g_file_new_for_path (metadata);

+ namespaces = g_file_query_writable_namespaces (file, NULL, NULL);

+ if (namespaces) {

+ gint i;

+

+ for (i = 0; i < namespaces->n_infos; i++) {

+ if (strcmp (namespaces->infos[i].name, "metadata") == 0) {

+ supported = TRUE;

+ break;

+ }

+ }

+ g_file_attribute_info_list_unref (namespaces);

+ }

+ if (!supported) {

+ g_warning ("GVFS metadata not supported. "

+ "Evince will run without metadata support.\n");

+ g_object_unref (file);

+ return FALSE;

+ }

+ g_object_unref (file);

+

+ argv[0] = g_build_filename (LIBEXECDIR, "evince-convert-metadata", NULL);

+ argv[1] = (char *) metadata;

+ argv[2] = NULL;

+

+ retval = g_spawn_sync (NULL /* wd */, argv, NULL /* env */,

+ 0, NULL, NULL, NULL, NULL,

+ &exit_status, &error);

+ g_free (argv[0]);

+

+ if (!retval) {

+ g_printerr ("Error migrating metadata: %s\n", error->message);

+ g_error_free (error);

+ }

+

+ return retval && WIFEXITED (exit_status) && WEXITSTATUS (exit_status) == 0;

+}

+

+static void

+ev_migrate_metadata (void)

+{

+ gchar *updated;

+ gchar *metadata;

+ gchar *dot_dir;

+ const gchar *userdir;

+

+ userdir = g_getenv ("MATE22_USER_DIR");

+ if (userdir) {

+ dot_dir = g_build_filename (userdir, "evince", NULL);

+ } else {

+ dot_dir = g_build_filename (g_get_home_dir (),

+ ".mate2",

+ "evince",

+ NULL);

+ }

+

+ updated = g_build_filename (dot_dir, "migrated-to-gvfs", NULL);

+ if (g_file_test (updated, G_FILE_TEST_EXISTS)) {

+ /* Already migrated */

+ g_free (updated);

+ g_free (dot_dir);

+ return;

+ }

+

+ metadata = g_build_filename (dot_dir, "ev-metadata.xml", NULL);

+ if (g_file_test (metadata, G_FILE_TEST_EXISTS)) {

+ if (convert_metadata (metadata)) {

+ gint fd;

+

+ fd = g_creat (updated, 0600);

+ if (fd != -1) {

+ close (fd);

+ }

+ }

+ }

+

+ g_free (dot_dir);

+ g_free (updated);

+ g_free (metadata);

+}

+

+static gboolean

+spawn_evince (const gchar *uri)

+{

+ gchar *argv[3];

+ gboolean retval;

+ GError *error = NULL;

+

+ /* TODO Check that the uri exists */

+ argv[0] = g_build_filename (BINDIR, "evince", NULL);

+ argv[1] = (gchar *) uri;

+ argv[2] = NULL;

+

+ retval = g_spawn_async (NULL /* wd */, argv, NULL /* env */,

+ 0, NULL, NULL, NULL, &error);

+ if (!retval) {

+ g_printerr ("Error spawning evince for uri %s: %s\n", uri, error->message);

+ g_error_free (error);

+ }

+ g_free (argv[0]);

+

+ return retval;

+}

+

+static void

+name_appeared_cb (GDBusConnection *connection,

+ const gchar *name,

+ const gchar *name_owner,

+ gpointer user_data)

+{

+ LOG ("Watch name'%s' appeared with owner '%s'\n", name, name_owner);

+}

+

+static void

+name_vanished_cb (GDBusConnection *connection,

+ const gchar *name,

+ gpointer user_data)

+{

+ GList *l;

+

+ LOG ("Watch name'%s' disappeared\n", name);

+

+ for (l = ev_daemon_docs; l != NULL; l = l->next) {

+ EvDoc *doc = (EvDoc *) l->data;

+

+ if (strcmp (doc->dbus_name, name) != 0)

+ continue;

+

+ LOG ("Watch found URI '%s' for name; removing\n", doc->uri);

+

+ ev_daemon_docs = g_list_delete_link (ev_daemon_docs, l);

+ ev_doc_free (doc);

+

+ ev_daemon_maybe_start_killtimer (user_data);

+ return;

+ }

+}

+

+static void

+process_pending_invocations (const gchar *uri,

+ const gchar *dbus_name)

+{

+ GList *l;

+ GList *uri_invocations;

+

+ LOG ("RegisterDocument process pending invocations for URI %s\n", uri);

+ uri_invocations = g_hash_table_lookup (pending_invocations, uri);

+

+ for (l = uri_invocations; l != NULL; l = l->next) {

+ GDBusMethodInvocation *invocation;

+

+ invocation = (GDBusMethodInvocation *)l->data;

+ g_dbus_method_invocation_return_value (invocation,

+ g_variant_new ("(s)", dbus_name));

+ }

+

+ g_list_free (uri_invocations);

+ g_hash_table_remove (pending_invocations, uri);

+}

+

+static void

+document_loaded_cb (GDBusConnection *connection,

+ const gchar *sender_name,

+ const gchar *object_path,

+ const gchar *interface_name,

+ const gchar *signal_name,

+ GVariant *parameters,

+ EvDoc *doc)

+{

+ const gchar *uri;

+

+ g_variant_get (parameters, "(&s)", &uri);

+ if (strcmp (uri, doc->uri) == 0)

+ process_pending_invocations (uri, sender_name);

+ g_dbus_connection_signal_unsubscribe (connection, doc->loaded_id);

+}

+

+static void

+method_call_cb (GDBusConnection *connection,

+ const gchar *sender,

+ const gchar *object_path,

+ const gchar *interface_name,

+ const gchar *method_name,

+ GVariant *parameters,

+ GDBusMethodInvocation *invocation,

+ gpointer user_data)

+{

+ if (g_strcmp0 (interface_name, EV_DBUS_DAEMON_INTERFACE_NAME) != 0)

+ return;

+

+ if (g_strcmp0 (method_name, "RegisterDocument") == 0) {

+ EvDoc *doc;

+ const gchar *uri;

+

+ g_variant_get (parameters, "(&s)", &uri);

+

+ doc = ev_daemon_find_doc (uri);

+ if (doc != NULL) {

+ LOG ("RegisterDocument found owner '%s' for URI '%s'\n", doc->dbus_name, uri);

+ g_dbus_method_invocation_return_value (invocation,

+ g_variant_new ("(s)", doc->dbus_name));

+ return;

+ }

+

+ ev_daemon_stop_killtimer ();

+

+ doc = g_new (EvDoc, 1);

+ doc->dbus_name = g_strdup (sender);

+ doc->uri = g_strdup (uri);

+

+ doc->loaded_id = g_dbus_connection_signal_subscribe (connection,

+ doc->dbus_name,

+ EV_DBUS_WINDOW_INTERFACE_NAME,

+ "DocumentLoaded",

+ NULL,

+ NULL,

+ 0,

+ (GDBusSignalCallback) document_loaded_cb,

+ doc,

+ NULL);

+ doc->watch_id = g_bus_watch_name_on_connection (connection,

+ sender,

+ G_BUS_NAME_WATCHER_FLAGS_NONE,

+ name_appeared_cb,

+ name_vanished_cb,

+ user_data, NULL);

+

+ LOG ("RegisterDocument registered owner '%s' for URI '%s'\n", doc->dbus_name, uri);

+ ev_daemon_docs = g_list_prepend (ev_daemon_docs, doc);

+

+ g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", ""));

+ } else if (g_strcmp0 (method_name, "UnregisterDocument") == 0) {

+ EvDoc *doc;

+ const gchar *uri;

+

+ g_variant_get (parameters, "(&s)", &uri);

+

+ LOG ("UnregisterDocument URI '%s'\n", uri);

+

+ doc = ev_daemon_find_doc (uri);

+ if (doc == NULL) {

+ LOG ("UnregisterDocument URI was not registered!\n");

+ g_dbus_method_invocation_return_error_literal (invocation,

+ G_DBUS_ERROR,

+ G_DBUS_ERROR_INVALID_ARGS,

+ "URI not registered");

+ return;

+ }

+

+ if (strcmp (doc->dbus_name, sender) != 0) {

+ LOG ("UnregisterDocument called by non-owner (owner '%s' sender '%s')\n",

+ doc->dbus_name, sender);

+

+ g_dbus_method_invocation_return_error_literal (invocation,

+ G_DBUS_ERROR,

+ G_DBUS_ERROR_BAD_ADDRESS,

+ "Only owner can call this method");

+ return;

+ }

+

+ ev_daemon_docs = g_list_remove (ev_daemon_docs, doc);

+ ev_doc_free (doc);

+ ev_daemon_maybe_start_killtimer (user_data);

+

+ g_dbus_method_invocation_return_value (invocation, g_variant_new ("()"));

+ } else if (g_strcmp0 (method_name, "FindDocument") == 0) {

+ EvDoc *doc;

+ const gchar *uri;

+ gboolean spawn;

+

+ g_variant_get (parameters, "(&sb)", &uri, &spawn);

+

+ LOG ("FindDocument URI '%s' \n", uri);

+

+ doc = ev_daemon_find_doc (uri);

+ if (doc != NULL) {

+ g_dbus_method_invocation_return_value (invocation,

+ g_variant_new ("(s)", doc->dbus_name));

+ return;

+ }

+

+ if (spawn) {

+ GList *uri_invocations;

+ gboolean ret_val = TRUE;

+

+ uri_invocations = g_hash_table_lookup (pending_invocations, uri);

+

+ if (uri_invocations == NULL) {

+ /* Only spawn once. */

+ ret_val = spawn_evince (uri);

+ }

+

+ if (ret_val) {

+ /* Only defer DBUS answer if evince was succesfully spawned */

+ uri_invocations = g_list_prepend (uri_invocations, invocation);

+ g_hash_table_insert (pending_invocations,

+ g_strdup (uri),

+ uri_invocations);

+ return;

+ }

+ }

+

+ LOG ("FindDocument URI '%s' was not registered!\n", uri);

+ g_dbus_method_invocation_return_value (invocation,

+ g_variant_new ("(s)",""));

+ }

+}

+

+static const char introspection_xml[] =

+ "<node>"

+ "<interface name='org.mate.evince.Daemon'>"

+ "<method name='RegisterDocument'>"

+ "<arg type='s' name='uri' direction='in'/>"

+ "<arg type='s' name='owner' direction='out'/>"

+ "</method>"

+ "<method name='UnregisterDocument'>"

+ "<arg type='s' name='uri' direction='in'/>"

+ "</method>"

+ "<method name='FindDocument'>"

+ "<arg type='s' name='uri' direction='in'/>"

+ "<arg type='b' name='spawn' direction='in'/>"

+ "<arg type='s' name='owner' direction='out'/>"

+ "</method>"

+ "</interface>"

+ "</node>";

+

+static const GDBusInterfaceVTable interface_vtable = {

+ method_call_cb,

+ NULL,

+ NULL

+};

+

+static GDBusNodeInfo *introspection_data;

+

+static void

+bus_acquired_cb (GDBusConnection *connection,

+ const gchar *name,

+ gpointer user_data)

+{

+ GMainLoop *loop = (GMainLoop *) user_data;

+ guint registration_id;

+ GError *error = NULL;

+

+ if (!introspection_data)

+ introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);

+

+ registration_id = g_dbus_connection_register_object (connection,

+ EV_DBUS_DAEMON_OBJECT_PATH,

+ introspection_data->interfaces[0],

+ &interface_vtable,

+ g_main_loop_ref (loop),

+ (GDestroyNotify) g_main_loop_unref,

+ &error);

+ if (registration_id == 0) {

+ g_printerr ("Failed to register object: %s\n", error->message);

+ g_error_free (error);

+

+ if (g_main_loop_is_running (loop))

+ g_main_loop_quit (loop);

+ }

+}

+

+static void

+name_acquired_cb (GDBusConnection *connection,

+ const gchar *name,

+ gpointer user_data)

+{

+ ev_migrate_metadata ();

+

+ ev_daemon_maybe_start_killtimer (user_data);

+}

+

+static void

+name_lost_cb (GDBusConnection *connection,

+ const gchar *name,

+ gpointer user_data)

+{

+ GMainLoop *loop = (GMainLoop *) user_data;

+

+ /* Failed to acquire the name; exit daemon */

+ if (g_main_loop_is_running (loop))

+ g_main_loop_quit (loop);

+}

+

+gint

+main (gint argc, gchar **argv)

+{

+ GMainLoop *loop;

+ guint owner_id;

+

+ g_set_prgname ("evince-daemon");

+

+ g_type_init ();

+

+ loop = g_main_loop_new (NULL, FALSE);

+

+ pending_invocations = g_hash_table_new_full (g_str_hash,

+ g_str_equal,

+ (GDestroyNotify)g_free,

+ NULL);

+

+ owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,

+ EV_DBUS_DAEMON_NAME,

+ G_BUS_NAME_OWNER_FLAGS_NONE,

+ bus_acquired_cb,

+ name_acquired_cb,

+ name_lost_cb,

+ g_main_loop_ref (loop),

+ (GDestroyNotify) g_main_loop_unref);

+

+ g_main_loop_run (loop);

+

+ g_bus_unown_name (owner_id);

+

+ g_main_loop_unref (loop);

+ if (introspection_data)

+ g_dbus_node_info_unref (introspection_data);

+ g_list_foreach (ev_daemon_docs, (GFunc)ev_doc_free, NULL);

+ g_list_free (ev_daemon_docs);

+ g_hash_table_destroy (pending_invocations);

+

+ return 0;

+}

+/* ev-file-monitor.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#include "config.h"

+

+#include <glib.h>

+#include <gio/gio.h>

+

+#include "ev-file-monitor.h"

+

+enum {

+ CHANGED,

+ N_SIGNALS

+};

+

+struct _EvFileMonitorPrivate {

+ GFileMonitor *monitor;

+

+ guint timeout_id;

+};

+

+static void ev_file_monitor_timeout_start (EvFileMonitor *ev_monitor);

+static void ev_file_monitor_timeout_stop (EvFileMonitor *ev_monitor);

+static void ev_file_monitor_changed_cb (GFileMonitor *monitor,

+ GFile *file,

+ GFile *other_file,

+ GFileMonitorEvent event_type,

+ EvFileMonitor *ev_monitor);

+

+#define EV_FILE_MONITOR_GET_PRIVATE(object) \

+ (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_FILE_MONITOR, EvFileMonitorPrivate))

+

+G_DEFINE_TYPE (EvFileMonitor, ev_file_monitor, G_TYPE_OBJECT)

+

+static guint signals[N_SIGNALS];

+

+static void

+ev_file_monitor_init (EvFileMonitor *ev_monitor)

+{

+ ev_monitor->priv = EV_FILE_MONITOR_GET_PRIVATE (ev_monitor);

+}

+

+static void

+ev_file_monitor_finalize (GObject *object)

+{

+ EvFileMonitor *ev_monitor = EV_FILE_MONITOR (object);

+

+ ev_file_monitor_timeout_stop (ev_monitor);

+

+ if (ev_monitor->priv->monitor) {

+ g_signal_handlers_disconnect_by_func (ev_monitor->priv->monitor,

+ ev_file_monitor_changed_cb,

+ ev_monitor);

+ g_object_unref (ev_monitor->priv->monitor);

+ ev_monitor->priv->monitor = NULL;

+ }

+

+ G_OBJECT_CLASS (ev_file_monitor_parent_class)->finalize (object);

+}

+

+static void

+ev_file_monitor_class_init (EvFileMonitorClass *klass)

+{

+ GObjectClass *g_object_class = G_OBJECT_CLASS (klass);

+

+ g_type_class_add_private (g_object_class, sizeof (EvFileMonitorPrivate));

+

+ g_object_class->finalize = ev_file_monitor_finalize;

+

+ /* Signals */

+ signals[CHANGED] =

+ g_signal_new ("changed",

+ EV_TYPE_FILE_MONITOR,

+ G_SIGNAL_RUN_LAST,

+ G_STRUCT_OFFSET (EvFileMonitorClass, changed),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+}

+

+static gboolean

+timeout_cb (EvFileMonitor *ev_monitor)

+{

+ g_signal_emit (ev_monitor, signals[CHANGED], 0);

+

+ ev_monitor->priv->timeout_id = 0;

+ return FALSE;

+}

+

+static void

+ev_file_monitor_timeout_start (EvFileMonitor *ev_monitor)

+{

+ ev_file_monitor_timeout_stop (ev_monitor);

+

+ ev_monitor->priv->timeout_id =

+ g_timeout_add_seconds (5, (GSourceFunc)timeout_cb, ev_monitor);

+}

+

+static void

+ev_file_monitor_timeout_stop (EvFileMonitor *ev_monitor)

+{

+ if (ev_monitor->priv->timeout_id > 0) {

+ g_source_remove (ev_monitor->priv->timeout_id);

+ ev_monitor->priv->timeout_id = 0;

+ }

+}

+

+static void

+ev_file_monitor_changed_cb (GFileMonitor *monitor,

+ GFile *file,

+ GFile *other_file,

+ GFileMonitorEvent event_type,

+ EvFileMonitor *ev_monitor)

+{

+ switch (event_type) {

+ case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:

+ ev_file_monitor_timeout_stop (ev_monitor);

+ g_signal_emit (ev_monitor, signals[CHANGED], 0);

+

+ break;

+ case G_FILE_MONITOR_EVENT_CHANGED:

+ ev_file_monitor_timeout_start (ev_monitor);

+ break;

+ default:

+ break;

+ }

+}

+

+EvFileMonitor *

+ev_file_monitor_new (const gchar *uri)

+{

+ EvFileMonitor *ev_monitor;

+ GFile *file;

+ GError *error = NULL;

+

+ ev_monitor = EV_FILE_MONITOR (g_object_new (EV_TYPE_FILE_MONITOR, NULL));

+

+ file = g_file_new_for_uri (uri);

+ ev_monitor->priv->monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, &error);

+ if (ev_monitor->priv->monitor) {

+ g_signal_connect (ev_monitor->priv->monitor, "changed",

+ G_CALLBACK (ev_file_monitor_changed_cb), ev_monitor);

+ } else if (error) {

+ g_warning ("%s", error->message);

+ g_error_free (error);

+ }

+

+ g_object_unref (file);

+

+ return ev_monitor;

+}

+/* ev-file-monitor.h

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef EV_FILE_MONITOR_H

+#define EV_FILE_MONITOR_H

+

+#include <glib-object.h>

+

+G_BEGIN_DECLS

+

+typedef struct _EvFileMonitor EvFileMonitor;

+typedef struct _EvFileMonitorClass EvFileMonitorClass;

+typedef struct _EvFileMonitorPrivate EvFileMonitorPrivate;

+

+#define EV_TYPE_FILE_MONITOR (ev_file_monitor_get_type())

+#define EV_FILE_MONITOR(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_FILE_MONITOR, EvFileMonitor))

+#define EV_FILE_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_FILE_MONITOR, EvFileMonitorClass))

+#define EV_IS_FILE_MONITOR(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_FILE_MONITOR))

+#define EV_IS_FILE_MONITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), EV_TYPE_FILE_MONITOR))

+#define EV_FILE_MONITOR_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object), EV_TYPE_FILE_MONITOR, EvFileMonitorClass))

+

+struct _EvFileMonitor {

+ GObject base_instance;

+

+ EvFileMonitorPrivate *priv;

+};

+

+struct _EvFileMonitorClass {

+ GObjectClass base_class;

+

+ /* Signals */

+ void (*changed) (EvFileMonitor *ev_monitor);

+};

+

+GType ev_file_monitor_get_type (void) G_GNUC_CONST;

+EvFileMonitor *ev_file_monitor_new (const gchar *uri);

+

+G_END_DECLS

+

+#endif /* EV_FILE_MONITOR_H */

+/*

+ * Copyright (C) 2005 Marco Pesenti Gritti

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ *

+ */

+

+#include "config.h"

+

+#include <glib/gi18n.h>

+#include <string.h>

+

+#include "ev-history.h"

+

+

+enum

+{

+ HISTORY_CHANGED,

+ N_SIGNALS

+};

+

+static guint signals[N_SIGNALS] = {0, };

+

+struct _EvHistoryPrivate

+{

+ GList *links;

+};

+

+static void ev_history_init (EvHistory *history);

+static void ev_history_class_init (EvHistoryClass *class);

+

+G_DEFINE_TYPE (EvHistory, ev_history, G_TYPE_OBJECT)

+

+#define EV_HISTORY_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_HISTORY, EvHistoryPrivate))

+

+static void

+ev_history_init (EvHistory *history)

+{

+ history->priv = EV_HISTORY_GET_PRIVATE (history);

+

+ history->priv->links = NULL;

+}

+

+static void

+free_links_list (GList *l)

+{

+ g_list_foreach (l, (GFunc)g_object_unref, NULL);

+ g_list_free (l);

+}

+

+static void

+ev_history_finalize (GObject *object)

+{

+ EvHistory *history = EV_HISTORY (object);

+

+ free_links_list (history->priv->links);

+

+ G_OBJECT_CLASS (ev_history_parent_class)->finalize (object);

+}

+

+static void

+ev_history_class_init (EvHistoryClass *class)

+{

+ GObjectClass *object_class = G_OBJECT_CLASS (class);

+

+ object_class->finalize = ev_history_finalize;

+

+ signals[HISTORY_CHANGED] =

+ g_signal_new ("changed",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

+ G_STRUCT_OFFSET (EvHistoryClass, changed),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+

+ g_type_class_add_private (object_class, sizeof (EvHistoryPrivate));

+}

+

+#define HISTORY_LENGTH 7

+

+void

+ev_history_add_link (EvHistory *history, EvLink *link)

+{

+ GList *l;

+

+ g_return_if_fail (EV_IS_HISTORY (history));

+ g_return_if_fail (EV_IS_LINK (link));

+

+ for (l = history->priv->links; l; l = l->next) {

+ if (!strcmp (ev_link_get_title (EV_LINK (l->data)), ev_link_get_title (link))) {

+ g_object_unref (G_OBJECT (l->data));

+ history->priv->links = g_list_delete_link (history->priv->links, l);

+ break;

+ }

+ }

+

+ g_object_ref (link);

+ history->priv->links = g_list_append (history->priv->links,

+ link);

+

+ if (g_list_length (history->priv->links) > HISTORY_LENGTH) {

+ g_object_unref (G_OBJECT (history->priv->links->data));

+ history->priv->links = g_list_delete_link (history->priv->links,

+ history->priv->links);

+ }

+

+ g_signal_emit (history, signals[HISTORY_CHANGED], 0);

+}

+

+EvLink *

+ev_history_get_link_nth (EvHistory *history, int index)

+{

+ GList *l;

+

+ g_return_val_if_fail (EV_IS_HISTORY (history), NULL);

+

+ l = g_list_nth (history->priv->links, index);

+

+ return EV_LINK (l->data);

+}

+

+int

+ev_history_get_n_links (EvHistory *history)

+{

+ g_return_val_if_fail (EV_IS_HISTORY (history), -1);

+

+ return g_list_length (history->priv->links);

+}

+

+EvHistory *

+ev_history_new (void)

+{

+ return EV_HISTORY (g_object_new (EV_TYPE_HISTORY, NULL));

+}

+

+/*

+ * Copyright (C) 2005 Marco Pesenti Gritti

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA..

+ *

+ */

+

+#ifndef EV_HISTORY_H

+#define EV_HISTORY_H

+

+#include <glib-object.h>

+

+#include "ev-link.h"

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_HISTORY (ev_history_get_type ())

+#define EV_HISTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EV_TYPE_HISTORY, EvHistory))

+#define EV_HISTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_HISTORY, EvHistoryClass))

+#define EV_IS_HISTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EV_TYPE_HISTORY))

+#define EV_IS_HISTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), EV_TYPE_HISTORY))

+#define EV_HISTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), EV_TYPE_HISTORY, EvHistoryClass))

+

+typedef struct _EvHistory EvHistory;

+typedef struct _EvHistoryPrivate EvHistoryPrivate;

+typedef struct _EvHistoryClass EvHistoryClass;

+

+struct _EvHistory

+{

+ GObject parent;

+

+ /*< private >*/

+ EvHistoryPrivate *priv;

+};

+

+struct _EvHistoryClass

+{

+ GObjectClass parent_class;

+

+ void (*changed) (EvHistory *history);

+};

+

+GType ev_history_get_type (void);

+EvHistory *ev_history_new (void);

+void ev_history_add_link (EvHistory *history,

+ EvLink *linkk);

+EvLink *ev_history_get_link_nth (EvHistory *history,

+ int index);

+int ev_history_get_n_links (EvHistory *history);

+

+G_END_DECLS

+

+#endif

+/* ev-keyring.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#include "config.h"

+

+#include <glib/gi18n.h>

+

+#include "ev-keyring.h"

+

+#ifdef WITH_KEYRING

+#include <mate-keyring.h>

+

+static const MateKeyringPasswordSchema doc_password_schema = {

+ MATE_KEYRING_ITEM_GENERIC_SECRET,

+ {

+ { "type", MATE_KEYRING_ATTRIBUTE_TYPE_STRING },

+ { "uri", MATE_KEYRING_ATTRIBUTE_TYPE_STRING },

+ { NULL, 0 }

+ }

+};

+const MateKeyringPasswordSchema *EV_DOCUMENT_PASSWORD_SCHEMA = &doc_password_schema;

+#endif /* WITH_KEYRING */

+

+gboolean

+ev_keyring_is_available (void)

+{

+#ifdef WITH_KEYRING

+ return mate_keyring_is_available ();

+#else

+ return FALSE;

+#endif

+}

+

+gchar *

+ev_keyring_lookup_password (const gchar *uri)

+{

+ gchar *retval = NULL;

+#ifdef WITH_KEYRING

+ MateKeyringResult result;

+ gchar *password = NULL;

+

+ g_return_val_if_fail (uri != NULL, NULL);

+

+ if (!mate_keyring_is_available ())

+ return NULL;

+

+ result = mate_keyring_find_password_sync (EV_DOCUMENT_PASSWORD_SCHEMA,

+ &password,

+ "type", "document_password",

+ "uri", uri,

+ NULL);

+ if (result != MATE_KEYRING_RESULT_OK || !password) {

+ if (password)

+ mate_keyring_free_password (password);

+ return NULL;

+ }

+

+ retval = g_strdup (password);

+ mate_keyring_free_password (password);

+#endif /* WITH_KEYRING */

+ return retval;

+}

+

+gboolean

+ev_keyring_save_password (const gchar *uri,

+ const gchar *password,

+ GPasswordSave flags)

+{

+#ifdef WITH_KEYRING

+ MateKeyringResult result;

+ const gchar *keyring;

+ gchar *name;

+ gchar *unescaped_uri;

+

+ g_return_val_if_fail (uri != NULL, FALSE);

+

+ if (!mate_keyring_is_available ())

+ return FALSE;

+

+ if (flags == G_PASSWORD_SAVE_NEVER)

+ return FALSE;

+

+ keyring = (flags == G_PASSWORD_SAVE_FOR_SESSION) ? "session" : NULL;

+ unescaped_uri = g_uri_unescape_string (uri, NULL);

+ name = g_strdup_printf (_("Password for document %s"), unescaped_uri);

+ g_free (unescaped_uri);

+

+ result = mate_keyring_store_password_sync (EV_DOCUMENT_PASSWORD_SCHEMA,

+ keyring, name, password,

+ "type", "document_password",

+ "uri", uri,

+ NULL);

+ g_free (name);

+

+ return (result == MATE_KEYRING_RESULT_OK);

+#else

+ return FALSE;

+#endif /* WITH_KEYRING */

+}

+/* ev-keyring.h

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef __EV_KEYRING_H__

+#define __EV_KEYRING_H__

+

+#include <glib.h>

+#include <gio/gio.h>

+

+G_BEGIN_DECLS

+

+gboolean ev_keyring_is_available (void);

+gchar *ev_keyring_lookup_password (const gchar *uri);

+gboolean ev_keyring_save_password (const gchar *uri,

+ const gchar *password,

+ GPasswordSave flags);

+

+G_END_DECLS

+

+#endif /* __EV_KEYRING_H__ */

+VOID:STRING,STRING

+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

+/*

+ * Copyright (C) 2007 Jan Arne Petersen <[email protected]>

+ * Copyright (C) 2008 Bastien Nocera <[email protected]>

+ * Copyright © 2010 Christian Persch

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+ *

+ */

+

+#include "config.h"

+

+#include "ev-media-player-keys.h"

+

+#include <string.h>

+#include <glib.h>

+#include <gio/gio.h>

+

+#define SD_NAME "org.mate.SettingsDaemon"

+#define SD_OBJECT_PATH "/org/mate/SettingsDaemon/MediaKeys"

+#define SD_INTERFACE "org.mate.SettingsDaemon.MediaKeys"

+

+enum {

+ KEY_PRESSED,

+ LAST_SIGNAL

+};

+

+struct _EvMediaPlayerKeys

+{

+ GObject parent;

+

+ GDBusProxy *proxy;

+ gboolean has_name_owner;

+};

+

+struct _EvMediaPlayerKeysClass

+{

+ GObjectClass parent_class;

+

+ /* Signals */

+ void (* key_pressed) (EvMediaPlayerKeys *keys,

+ const gchar *key);

+};

+

+static guint signals[LAST_SIGNAL];

+

+G_DEFINE_TYPE (EvMediaPlayerKeys, ev_media_player_keys, G_TYPE_OBJECT)

+

+static void ev_media_player_keys_finalize (GObject *object);

+

+static void

+ev_media_player_keys_class_init (EvMediaPlayerKeysClass *klass)

+{

+ GObjectClass *object_class = G_OBJECT_CLASS (klass);

+

+ object_class->finalize = ev_media_player_keys_finalize;

+

+ signals[KEY_PRESSED] =

+ g_signal_new ("key_pressed",

+ EV_TYPE_MEDIA_PLAYER_KEYS,

+ G_SIGNAL_RUN_LAST,

+ G_STRUCT_OFFSET (EvMediaPlayerKeysClass, key_pressed),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__STRING,

+ G_TYPE_NONE,

+ 1, G_TYPE_STRING);

+}

+

+static void

+ev_media_player_keys_update_has_name_owner (EvMediaPlayerKeys *keys)

+{

+ gchar *name_owner;

+

+ if (!keys->proxy) {

+ keys->has_name_owner = FALSE;

+ return;

+ }

+

+ name_owner = g_dbus_proxy_get_name_owner (keys->proxy);

+ keys->has_name_owner = (name_owner != NULL);

+ g_free (name_owner);

+}

+

+static void

+ev_media_player_keys_grab_keys (EvMediaPlayerKeys *keys)

+{

+ if (!keys->has_name_owner)

+ return;

+

+ /*

+ * The uint as second argument is time. We give a very low value so that

+ * if a media player is there it gets higher priority on the keys (0 is

+ * a special value having maximum priority).

+ */

+ g_dbus_proxy_call (keys->proxy,

+ "GrabMediaPlayerKeys",

+ g_variant_new ("(su)", "Evince", 1),

+ G_DBUS_CALL_FLAGS_NO_AUTO_START,

+ -1,

+ NULL, NULL, NULL);

+}

+

+static void

+ev_media_player_keys_release_keys (EvMediaPlayerKeys *keys)

+{

+ if (!keys->has_name_owner)

+ return;

+

+ g_dbus_proxy_call (keys->proxy,

+ "ReleaseMediaPlayerKeys",

+ g_variant_new ("(s)", "Evince"),

+ G_DBUS_CALL_FLAGS_NO_AUTO_START,

+ -1,

+ NULL, NULL, NULL);

+}

+

+static void

+media_player_key_pressed_cb (GDBusProxy *proxy,

+ gchar *sender_name,

+ gchar *signal_name,

+ GVariant *parameters,

+ gpointer user_data)

+{

+ const char *application, *key;

+

+ if (g_strcmp0 (sender_name, SD_NAME) != 0)

+ return;

+

+ if (g_strcmp0 (signal_name, "MediaPlayerKeyPressed") != 0)

+ return;

+

+ if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(ss)")))

+ return;

+

+ g_variant_get (parameters, "(&s&s)", &application, &key);

+

+ if (strcmp ("Evince", application) == 0) {

+ g_signal_emit (user_data, signals[KEY_PRESSED], 0, key);

+ }

+}

+

+static void

+mediakeys_name_owner_changed (GObject *object,

+ GParamSpec *pspec,

+ gpointer user_data)

+{

+ EvMediaPlayerKeys *keys = EV_MEDIA_PLAYER_KEYS (user_data);

+

+ ev_media_player_keys_update_has_name_owner (keys);

+}

+

+static void

+mediakeys_service_appeared_cb (GObject *source_object,

+ GAsyncResult *res,

+ gpointer user_data)

+{

+ EvMediaPlayerKeys *keys = EV_MEDIA_PLAYER_KEYS (user_data);

+ GDBusProxy *proxy;

+

+ proxy = g_dbus_proxy_new_for_bus_finish (res, NULL);

+

+ if (proxy == NULL) {

+ return;

+ }

+

+ g_signal_connect (proxy, "g-signal",

+ G_CALLBACK (media_player_key_pressed_cb),

+ keys);

+ g_signal_connect (proxy, "notify::g-name-owner",

+ G_CALLBACK (mediakeys_name_owner_changed),

+ keys);

+

+ keys->proxy = proxy;

+ ev_media_player_keys_update_has_name_owner (keys);

+ ev_media_player_keys_grab_keys (keys);

+}

+

+static void

+ev_media_player_keys_init (EvMediaPlayerKeys *keys)

+{

+ g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,

+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,

+ NULL,

+ SD_NAME,

+ SD_OBJECT_PATH,

+ SD_INTERFACE,

+ NULL,

+ mediakeys_service_appeared_cb,

+ keys);

+}

+

+void

+ev_media_player_keys_focused (EvMediaPlayerKeys *keys)

+{

+ if (keys->proxy == NULL)

+ return;

+

+ ev_media_player_keys_grab_keys (keys);

+}

+

+static void

+ev_media_player_keys_finalize (GObject *object)

+{

+ EvMediaPlayerKeys *keys = EV_MEDIA_PLAYER_KEYS (object);

+

+ if (keys->proxy != NULL) {

+ ev_media_player_keys_release_keys (keys);

+ g_object_unref (keys->proxy);

+ keys->proxy = NULL;

+ keys->has_name_owner = FALSE;

+ }

+

+ G_OBJECT_CLASS (ev_media_player_keys_parent_class)->finalize (object);

+}

+

+EvMediaPlayerKeys *

+ev_media_player_keys_new (void)

+{

+ return g_object_new (EV_TYPE_MEDIA_PLAYER_KEYS, NULL);

+}

+

+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

+/*

+ * Copyright (C) 2007 Jan Arne Petersen <[email protected]>

+ * Copyright (C) 2008 Bastien Nocera <[email protected]>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

+ *

+ */

+

+#ifndef EV_MEDIA_PLAYER_KEYS_H

+#define EV_MEDIA_PLAYER_KEYS_H

+

+#include <glib-object.h>

+#include <gio/gio.h>

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_MEDIA_PLAYER_KEYS (ev_media_player_keys_get_type ())

+#define EV_MEDIA_PLAYER_KEYS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EV_TYPE_MEDIA_PLAYER_KEYS, EvMediaPlayerKeys))

+#define EV_MEDIA_PLAYER_KEYS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EV_TYPE_MEDIA_PLAYER_KEYS, EvMediaPlayerKeysClass))

+#define EV_IS_MEDIA_PLAYER_KEYS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EV_TYPE_MEDIA_PLAYER_KEYS))

+#define EV_IS_MEDIA_PLAYER_KEYS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EV_TYPE_MEDIA_PLAYER_KEYS))

+#define EV_MEDIA_PLAYER_KEYS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EV_TYPE_MEDIA_PLAYER_KEYS, EvMediaPlayerKeysClass))

+

+typedef struct _EvMediaPlayerKeys EvMediaPlayerKeys;

+typedef struct _EvMediaPlayerKeysClass EvMediaPlayerKeysClass;

+

+

+GType ev_media_player_keys_get_type (void) G_GNUC_CONST;

+

+EvMediaPlayerKeys *ev_media_player_keys_new (void);

+

+void ev_media_player_keys_focused (EvMediaPlayerKeys *keys);

+

+G_END_DECLS

+

+#endif /* !EV_MEDIA_PLAYER_KEYS_H */

+/* ev-message-area.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2007 Carlos Garcia Campos

+ *

+ * Author:

+ * Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#include <config.h>

+

+#include "ev-message-area.h"

+

+#define EV_MESSAGE_AREA_GET_PRIVATE(obj) \

+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EV_TYPE_MESSAGE_AREA, EvMessageAreaPrivate))

+

+struct _EvMessageAreaPrivate {

+ GtkWidget *main_box;

+ GtkWidget *image;

+ GtkWidget *label;

+ GtkWidget *secondary_label;

+

+ guint message_type : 3;

+};

+

+enum {

+ PROP_0,

+ PROP_TEXT,

+ PROP_SECONDARY_TEXT,

+ PROP_IMAGE

+};

+

+static void ev_message_area_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec);

+static void ev_message_area_get_property (GObject *object,

+ guint prop_id,

+ GValue *value,

+ GParamSpec *pspec);

+

+G_DEFINE_TYPE (EvMessageArea, ev_message_area, GTK_TYPE_INFO_BAR)

+

+static void

+ev_message_area_class_init (EvMessageAreaClass *class)

+{

+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);

+

+ gobject_class->set_property = ev_message_area_set_property;

+ gobject_class->get_property = ev_message_area_get_property;

+

+ g_object_class_install_property (gobject_class,

+ PROP_TEXT,

+ g_param_spec_string ("text",

+ "Text",

+ "The primary text of the message dialog",

+ NULL,

+ G_PARAM_READWRITE));

+ g_object_class_install_property (gobject_class,

+ PROP_SECONDARY_TEXT,

+ g_param_spec_string ("secondary-text",

+ "Secondary Text",

+ "The secondary text of the message dialog",

+ NULL,

+ G_PARAM_READWRITE));

+ g_object_class_install_property (gobject_class,

+ PROP_IMAGE,

+ g_param_spec_object ("image",

+ "Image",

+ "The image",

+ GTK_TYPE_WIDGET,

+ G_PARAM_READWRITE));

+

+ g_type_class_add_private (gobject_class, sizeof (EvMessageAreaPrivate));

+}

+

+static void

+ev_message_area_init (EvMessageArea *area)

+{

+ GtkWidget *hbox, *vbox;

+ GtkWidget *content_area;

+

+ area->priv = EV_MESSAGE_AREA_GET_PRIVATE (area);

+

+ area->priv->main_box = gtk_vbox_new (FALSE, 12);

+

+ hbox = gtk_hbox_new (FALSE, 12);

+ vbox = gtk_vbox_new (FALSE, 12);

+

+ area->priv->label = gtk_label_new (NULL);

+ gtk_label_set_use_markup (GTK_LABEL (area->priv->label), TRUE);

+ gtk_label_set_line_wrap (GTK_LABEL (area->priv->label), TRUE);

+ gtk_label_set_selectable (GTK_LABEL (area->priv->label), TRUE);

+ gtk_misc_set_alignment (GTK_MISC (area->priv->label), 0.0, 0.5);

+ gtk_widget_set_can_focus (area->priv->label, TRUE);

+ gtk_box_pack_start (GTK_BOX (vbox), area->priv->label, TRUE, TRUE, 0);

+ gtk_widget_show (area->priv->label);

+

+ area->priv->secondary_label = gtk_label_new (NULL);

+ gtk_label_set_use_markup (GTK_LABEL (area->priv->secondary_label), TRUE);

+ gtk_label_set_line_wrap (GTK_LABEL (area->priv->secondary_label), TRUE);

+ gtk_label_set_selectable (GTK_LABEL (area->priv->secondary_label), TRUE);

+ gtk_misc_set_alignment (GTK_MISC (area->priv->secondary_label), 0.0, 0.5);

+ gtk_widget_set_can_focus (area->priv->secondary_label, TRUE);

+ gtk_box_pack_start (GTK_BOX (vbox), area->priv->secondary_label, TRUE, TRUE, 0);

+

+ area->priv->image = gtk_image_new_from_stock (NULL, GTK_ICON_SIZE_DIALOG);

+ gtk_misc_set_alignment (GTK_MISC (area->priv->image), 0.5, 0.0);

+ gtk_box_pack_start (GTK_BOX (hbox), area->priv->image, FALSE, FALSE, 0);

+ gtk_widget_show (area->priv->image);

+

+ gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);

+ gtk_widget_show (vbox);

+

+ gtk_box_pack_start (GTK_BOX (area->priv->main_box), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (area));

+ gtk_container_add (GTK_CONTAINER (content_area), area->priv->main_box);

+ gtk_widget_show (area->priv->main_box);

+}

+

+static void

+ev_message_area_set_image_for_type (EvMessageArea *area,

+ GtkMessageType type)

+{

+ const gchar *stock_id = NULL;

+ AtkObject *atk_obj;

+

+ switch (type) {

+ case GTK_MESSAGE_INFO:

+ stock_id = GTK_STOCK_DIALOG_INFO;

+ break;

+ case GTK_MESSAGE_QUESTION:

+ stock_id = GTK_STOCK_DIALOG_QUESTION;

+ break;

+ case GTK_MESSAGE_WARNING:

+ stock_id = GTK_STOCK_DIALOG_WARNING;

+ break;

+ case GTK_MESSAGE_ERROR:

+ stock_id = GTK_STOCK_DIALOG_ERROR;

+ break;

+ case GTK_MESSAGE_OTHER:

+ break;

+ default:

+ g_warning ("Unknown GtkMessageType %u", type);

+ break;

+ }

+

+ if (stock_id)

+ gtk_image_set_from_stock (GTK_IMAGE (area->priv->image), stock_id,

+ GTK_ICON_SIZE_DIALOG);

+

+ atk_obj = gtk_widget_get_accessible (GTK_WIDGET (area));

+ if (GTK_IS_ACCESSIBLE (atk_obj)) {

+ atk_object_set_role (atk_obj, ATK_ROLE_ALERT);

+ if (stock_id) {

+ GtkStockItem item;

+

+ gtk_stock_lookup (stock_id, &item);

+ atk_object_set_name (atk_obj, item.label);

+ }

+ }

+}

+

+static void

+ev_message_area_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec)

+{

+ EvMessageArea *area = EV_MESSAGE_AREA (object);

+

+ switch (prop_id) {

+ case PROP_TEXT:

+ ev_message_area_set_text (area, g_value_get_string (value));

+ break;

+ case PROP_SECONDARY_TEXT:

+ ev_message_area_set_secondary_text (area, g_value_get_string (value));

+ break;

+ case PROP_IMAGE:

+ ev_message_area_set_image (area, (GtkWidget *)g_value_get_object (value));

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ break;

+ }

+}

+

+static void

+ev_message_area_get_property (GObject *object,

+ guint prop_id,

+ GValue *value,

+ GParamSpec *pspec)

+{

+ EvMessageArea *area = EV_MESSAGE_AREA (object);

+

+ switch (prop_id) {

+ case PROP_TEXT:

+ g_value_set_string (value, gtk_label_get_label (GTK_LABEL (area->priv->label)));

+ break;

+ case PROP_SECONDARY_TEXT:

+ g_value_set_string (value, gtk_label_get_label (GTK_LABEL (area->priv->secondary_label)));

+ break;

+ case PROP_IMAGE:

+ g_value_set_object (value, area->priv->image);

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ break;

+ }

+}

+

+void

+_ev_message_area_add_buttons_valist (EvMessageArea *area,

+ const gchar *first_button_text,

+ va_list args)

+{

+ const gchar* text;

+ gint response_id;

+

+ if (first_button_text == NULL)

+ return;

+

+ text = first_button_text;

+ response_id = va_arg (args, gint);

+

+ while (text != NULL) {

+ gtk_info_bar_add_button (GTK_INFO_BAR (area), text, response_id);

+

+ text = va_arg (args, gchar*);

+ if (text == NULL)

+ break;

+

+ response_id = va_arg (args, int);

+ }

+}

+

+GtkWidget *

+_ev_message_area_get_main_box (EvMessageArea *area)

+{

+ return area->priv->main_box;

+}

+

+GtkWidget *

+ev_message_area_new (GtkMessageType type,

+ const gchar *text,

+ const gchar *first_button_text,

+ ...)

+{

+ GtkWidget *widget;

+

+ widget = g_object_new (EV_TYPE_MESSAGE_AREA,

+ "message-type", type,

+ "text", text,

+ NULL);

+ ev_message_area_set_image_for_type (EV_MESSAGE_AREA (widget), type);

+ if (first_button_text) {

+ va_list args;

+

+ va_start (args, first_button_text);

+ _ev_message_area_add_buttons_valist (EV_MESSAGE_AREA (widget),

+ first_button_text, args);

+ va_end (args);

+ }

+

+ return widget;

+}

+

+void

+ev_message_area_set_image (EvMessageArea *area,

+ GtkWidget *image)

+{

+ GtkWidget *parent;

+

+ g_return_if_fail (EV_IS_MESSAGE_AREA (area));

+

+ area->priv->message_type = GTK_MESSAGE_OTHER;

+

+ parent = gtk_widget_get_parent (area->priv->image);

+ gtk_container_add (GTK_CONTAINER (parent), image);

+ gtk_container_remove (GTK_CONTAINER (parent), area->priv->image);

+ gtk_box_reorder_child (GTK_BOX (parent), image, 0);

+

+ area->priv->image = image;

+

+ g_object_notify (G_OBJECT (area), "image");

+}

+

+void

+ev_message_area_set_image_from_stock (EvMessageArea *area,

+ const gchar *stock_id)

+{

+ g_return_if_fail (EV_IS_MESSAGE_AREA (area));

+ g_return_if_fail (stock_id != NULL);

+

+ gtk_image_set_from_stock (GTK_IMAGE (area->priv->image),

+ stock_id,

+ GTK_ICON_SIZE_DIALOG);

+}

+

+void

+ev_message_area_set_text (EvMessageArea *area,

+ const gchar *str)

+{

+ g_return_if_fail (EV_IS_MESSAGE_AREA (area));

+

+ if (str) {

+ gchar *msg;

+

+ msg = g_strdup_printf ("<b>%s</b>", str);

+ gtk_label_set_markup (GTK_LABEL (area->priv->label), msg);

+ g_free (msg);

+ } else {

+ gtk_label_set_markup (GTK_LABEL (area->priv->label), NULL);

+ }

+

+ g_object_notify (G_OBJECT (area), "text");

+}

+

+void

+ev_message_area_set_secondary_text (EvMessageArea *area,

+ const gchar *str)

+{

+ g_return_if_fail (EV_IS_MESSAGE_AREA (area));

+

+ if (str) {

+ gchar *msg;

+

+ msg = g_strdup_printf ("<small>%s</small>", str);

+ gtk_label_set_markup (GTK_LABEL (area->priv->secondary_label), msg);

+ g_free (msg);

+ gtk_widget_show (area->priv->secondary_label);

+ } else {

+ gtk_label_set_markup (GTK_LABEL (area->priv->secondary_label), NULL);

+ gtk_widget_hide (area->priv->secondary_label);

+ }

+

+ g_object_notify (G_OBJECT (area), "secondary-text");

+}

+/* ev-message-area.h

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2007 Carlos Garcia Campos

+ *

+ * Author:

+ * Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef EV_MESSAGE_AREA_H

+#define EV_MESSAGE_AREA_H

+

+#include <gtk/gtk.h>

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_MESSAGE_AREA (ev_message_area_get_type ())

+#define EV_MESSAGE_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EV_TYPE_MESSAGE_AREA, EvMessageArea))

+#define EV_MESSAGE_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_MESSAGE_AREA, EvMessageAreaClass))

+#define EV_IS_MESSAGE_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EV_TYPE_MESSAGE_AREA))

+#define EV_IS_MESSAGE_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_MESSAGE_AREA))

+#define EV_MESSAGE_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_MESSAGE_AREA, EvMessageAreaClass))

+

+typedef struct _EvMessageArea EvMessageArea;

+typedef struct _EvMessageAreaClass EvMessageAreaClass;

+typedef struct _EvMessageAreaPrivate EvMessageAreaPrivate;

+

+struct _EvMessageArea {

+ GtkInfoBar parent_instance;

+

+ /*< private >*/

+ EvMessageAreaPrivate *priv;

+};

+

+struct _EvMessageAreaClass {

+ GtkInfoBarClass parent_class;

+};

+

+GType ev_message_area_get_type (void) G_GNUC_CONST;

+GtkWidget *ev_message_area_new (GtkMessageType type,

+ const gchar *text,

+ const gchar *first_button_text,

+ ...);

+void ev_message_area_set_image (EvMessageArea *area,

+ GtkWidget *image);

+void ev_message_area_set_image_from_stock (EvMessageArea *area,

+ const gchar *stock_id);

+void ev_message_area_set_text (EvMessageArea *area,

+ const gchar *str);

+void ev_message_area_set_secondary_text (EvMessageArea *area,

+ const gchar *str);

+

+void _ev_message_area_add_buttons_valist (EvMessageArea *area,

+ const gchar *first_button_text,

+ va_list args);

+GtkWidget *_ev_message_area_get_main_box (EvMessageArea *area);

+

+G_END_DECLS

+

+#endif /* EV_MESSAGE_AREA_H */

+/* ev-metadata.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2009 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#include <gio/gio.h>

+#include <string.h>

+

+#include "ev-metadata.h"

+

+struct _EvMetadata {

+ GObject base;

+

+ GFile *file;

+ GHashTable *items;

+};

+

+struct _EvMetadataClass {

+ GObjectClass base_class;

+};

+

+G_DEFINE_TYPE (EvMetadata, ev_metadata, G_TYPE_OBJECT)

+

+#define EV_METADATA_NAMESPACE "metadata::evince"

+

+static void

+ev_metadata_finalize (GObject *object)

+{

+ EvMetadata *metadata = EV_METADATA (object);

+

+ if (metadata->items) {

+ g_hash_table_destroy (metadata->items);

+ metadata->items = NULL;

+ }

+

+ if (metadata->file) {

+ g_object_unref (metadata->file);

+ metadata->file = NULL;

+ }

+

+ G_OBJECT_CLASS (ev_metadata_parent_class)->finalize (object);

+}

+

+static void

+ev_metadata_init (EvMetadata *metadata)

+{

+ metadata->items = g_hash_table_new_full (g_str_hash,

+ g_str_equal,

+ g_free,

+ g_free);

+}

+

+static void

+ev_metadata_class_init (EvMetadataClass *klass)

+{

+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

+

+ gobject_class->finalize = ev_metadata_finalize;

+}

+

+static void

+ev_metadata_load (EvMetadata *metadata)

+{

+ GFileInfo *info;

+ gchar **attrs;

+ gint i;

+ GError *error = NULL;

+

+ info = g_file_query_info (metadata->file, "metadata::*", 0, NULL, &error);

+ if (!info) {

+ g_warning ("%s", error->message);

+ g_error_free (error);

+

+ return;

+ }

+

+ if (!g_file_info_has_namespace (info, "metadata")) {

+ g_object_unref (info);

+

+ return;

+ }

+

+ attrs = g_file_info_list_attributes (info, "metadata");

+ for (i = 0; attrs[i]; i++) {

+ GFileAttributeType type;

+ gpointer value;

+ const gchar *key;

+

+ if (!g_str_has_prefix (attrs[i], EV_METADATA_NAMESPACE))

+ continue;

+

+ if (!g_file_info_get_attribute_data (info, attrs[i],

+ &type, &value, NULL)) {

+ continue;

+ }

+

+ key = attrs[i] + strlen (EV_METADATA_NAMESPACE"::");

+

+ if (type == G_FILE_ATTRIBUTE_TYPE_STRING) {

+ g_hash_table_insert (metadata->items,

+ g_strdup (key),

+ g_strdup (value));

+ }

+ }

+ g_strfreev (attrs);

+ g_object_unref (info);

+}

+

+EvMetadata *

+ev_metadata_new (GFile *file)

+{

+ EvMetadata *metadata;

+

+ g_return_val_if_fail (G_IS_FILE (file), NULL);

+

+ metadata = EV_METADATA (g_object_new (EV_TYPE_METADATA, NULL));

+ metadata->file = g_object_ref (file);

+

+ ev_metadata_load (metadata);

+

+ return metadata;

+}

+

+gboolean

+ev_metadata_is_empty (EvMetadata *metadata)

+{

+ return g_hash_table_size (metadata->items) == 0;

+}

+

+gboolean

+ev_metadata_get_string (EvMetadata *metadata,

+ const gchar *key,

+ gchar **value)

+{

+ gchar *v;

+

+ v = g_hash_table_lookup (metadata->items, key);

+ if (!v)

+ return FALSE;

+

+ *value = v;

+ return TRUE;

+}

+

+static void

+metadata_set_callback (GObject *file,

+ GAsyncResult *result,

+ EvMetadata *metadata)

+{

+ GError *error = NULL;

+

+ if (!g_file_set_attributes_finish (G_FILE (file), result, NULL, &error)) {

+ g_warning ("%s", error->message);

+ g_error_free (error);

+ }

+}

+

+gboolean

+ev_metadata_set_string (EvMetadata *metadata,

+ const gchar *key,

+ const gchar *value)

+{

+ GFileInfo *info;

+ gchar *gio_key;

+

+ info = g_file_info_new ();

+

+ gio_key = g_strconcat (EV_METADATA_NAMESPACE"::", key, NULL);

+ if (value) {

+ g_file_info_set_attribute_string (info, gio_key, value);

+ } else {

+ g_file_info_set_attribute (info, gio_key,

+ G_FILE_ATTRIBUTE_TYPE_INVALID,

+ NULL);

+ }

+ g_free (gio_key);

+

+ g_hash_table_insert (metadata->items, g_strdup (key), g_strdup (value));

+ g_file_set_attributes_async (metadata->file,

+ info,

+ 0,

+ G_PRIORITY_DEFAULT,

+ NULL,

+ (GAsyncReadyCallback)metadata_set_callback,

+ metadata);

+ g_object_unref (info);

+

+ return TRUE;

+}

+

+gboolean

+ev_metadata_get_int (EvMetadata *metadata,

+ const gchar *key,

+ gint *value)

+{

+ gchar *string_value;

+ gchar *endptr;

+ gint int_value;

+

+ if (!ev_metadata_get_string (metadata, key, &string_value))

+ return FALSE;

+

+ int_value = g_ascii_strtoull (string_value, &endptr, 0);

+ if (int_value == 0 && string_value == endptr)

+ return FALSE;

+

+ *value = int_value;

+ return TRUE;

+}

+

+gboolean

+ev_metadata_set_int (EvMetadata *metadata,

+ const gchar *key,

+ gint value)

+{

+ gchar string_value[32];

+

+ g_snprintf (string_value, sizeof (string_value), "%d", value);

+

+ return ev_metadata_set_string (metadata, key, string_value);

+}

+

+gboolean

+ev_metadata_get_double (EvMetadata *metadata,

+ const gchar *key,

+ gdouble *value)

+{

+ gchar *string_value;

+ gchar *endptr;

+ gdouble double_value;

+

+ if (!ev_metadata_get_string (metadata, key, &string_value))

+ return FALSE;

+

+ double_value = g_ascii_strtod (string_value, &endptr);

+ if (double_value == 0. && string_value == endptr)

+ return FALSE;

+

+ *value = double_value;

+ return TRUE;

+}

+

+gboolean

+ev_metadata_set_double (EvMetadata *metadata,

+ const gchar *key,

+ gdouble value)

+{

+ gchar string_value[G_ASCII_DTOSTR_BUF_SIZE];

+

+ g_ascii_dtostr (string_value, G_ASCII_DTOSTR_BUF_SIZE, value);

+

+ return ev_metadata_set_string (metadata, key, string_value);

+}

+

+gboolean

+ev_metadata_get_boolean (EvMetadata *metadata,

+ const gchar *key,

+ gboolean *value)

+{

+ gint int_value;

+

+ if (!ev_metadata_get_int (metadata, key, &int_value))

+ return FALSE;

+

+ *value = int_value;

+ return TRUE;

+}

+

+gboolean

+ev_metadata_set_boolean (EvMetadata *metadata,

+ const gchar *key,

+ gboolean value)

+{

+ return ev_metadata_set_string (metadata, key, value ? "1" : "0");

+}

+

+gboolean

+ev_is_metadata_supported_for_file (GFile *file)

+{

+ GFileAttributeInfoList *namespaces;

+ gint i;

+ gboolean retval = FALSE;

+

+ namespaces = g_file_query_writable_namespaces (file, NULL, NULL);

+ if (!namespaces)

+ return retval;

+

+ for (i = 0; i < namespaces->n_infos; i++) {

+ if (strcmp (namespaces->infos[i].name, "metadata") == 0) {

+ retval = TRUE;

+ break;

+ }

+ }

+

+ g_file_attribute_info_list_unref (namespaces);

+

+ return retval;

+}

+/* ev-metadata.h

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2009 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef EV_METADATA_H

+#define EV_METADATA_H

+

+#include <glib-object.h>

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_METADATA (ev_metadata_get_type())

+#define EV_METADATA(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_METADATA, EvMetadata))

+#define EV_METADATA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_METADATA, EvMetadataClass))

+#define EV_IS_METADATA(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_METADATA))

+

+typedef struct _EvMetadata EvMetadata;

+typedef struct _EvMetadataClass EvMetadataClass;

+

+GType ev_metadata_get_type (void) G_GNUC_CONST;

+EvMetadata *ev_metadata_new (GFile *file);

+gboolean ev_metadata_is_empty (EvMetadata *metadata);

+

+gboolean ev_metadata_get_string (EvMetadata *metadata,

+ const gchar *key,

+ gchar **value);

+gboolean ev_metadata_set_string (EvMetadata *metadata,

+ const gchar *key,

+ const gchar *value);

+gboolean ev_metadata_get_int (EvMetadata *metadata,

+ const gchar *key,

+ gint *value);

+gboolean ev_metadata_set_int (EvMetadata *metadata,

+ const gchar *key,

+ gint value);

+gboolean ev_metadata_get_double (EvMetadata *metadata,

+ const gchar *key,

+ gdouble *value);

+gboolean ev_metadata_set_double (EvMetadata *metadata,

+ const gchar *key,

+ gdouble value);

+gboolean ev_metadata_get_boolean (EvMetadata *metadata,

+ const gchar *key,

+ gboolean *value);

+gboolean ev_metadata_set_boolean (EvMetadata *metadata,

+ const gchar *key,

+ gboolean value);

+

+gboolean ev_is_metadata_supported_for_file (GFile *file);

+

+G_END_DECLS

+

+#endif /* EV_METADATA_H */

+/*

+ * Copyright (C) 2003, 2004 Marco Pesenti Gritti

+ * Copyright (C) 2003, 2004 Christian Persch

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#include "config.h"

+#include "ev-navigation-action-widget.h"

+

+#include <glib/gi18n.h>

+#include <string.h>

+

+static void ev_navigation_action_widget_init (EvNavigationActionWidget *action_widget);

+static void ev_navigation_action_widget_class_init (EvNavigationActionWidgetClass *action_widget);

+static void ev_navigation_action_widget_toggled (GtkToggleToolButton *toggle);

+static gboolean ev_navigation_action_widget_button_press_event (GtkWidget *widget,

+ GdkEventButton *event,

+ gpointer data);

+

+G_DEFINE_TYPE (EvNavigationActionWidget, ev_navigation_action_widget, GTK_TYPE_TOGGLE_TOOL_BUTTON)

+

+enum

+{

+ SHOW_MENU,

+ LAST_SIGNAL

+};

+

+static gint signals[LAST_SIGNAL];

+

+static void

+ev_navigation_action_widget_init (EvNavigationActionWidget *action_widget)

+{

+ GtkWidget *toggle_button;

+

+ /* It's rather dirty hack but we need a child to connect to

+ * button press event

+ */

+

+ toggle_button = gtk_bin_get_child (GTK_BIN (action_widget));

+

+ g_signal_connect (toggle_button, "button-press-event",

+ G_CALLBACK (ev_navigation_action_widget_button_press_event),

+ action_widget);

+ return;

+}

+

+static void

+ev_navigation_action_widget_class_init (EvNavigationActionWidgetClass *klass)

+{

+ GtkToggleToolButtonClass *toggle_tool_button_class = GTK_TOGGLE_TOOL_BUTTON_CLASS (klass);

+

+ toggle_tool_button_class->toggled = ev_navigation_action_widget_toggled;

+

+ signals[SHOW_MENU] =

+ g_signal_new ("show-menu",

+ G_OBJECT_CLASS_TYPE (klass),

+ G_SIGNAL_RUN_FIRST,

+ G_STRUCT_OFFSET (EvNavigationActionWidgetClass, show_menu),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+}

+

+static int

+menu_deactivate_cb (GtkMenuShell *menu_shell,

+ EvNavigationActionWidget *widget)

+{

+ gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (widget), FALSE);

+ return TRUE;

+}

+

+static void

+menu_detacher (GtkWidget *widget,

+ GtkMenu *menu)

+{

+ EvNavigationActionWidget *button = EV_NAVIGATION_ACTION_WIDGET (widget);

+ g_return_if_fail (button->menu == menu);

+ button->menu = NULL;

+}

+

+void

+ev_navigation_action_widget_set_menu(EvNavigationActionWidget *button, GtkWidget *menu)

+{

+

+ if (button->menu == GTK_MENU (menu))

+ return;

+

+ if (button->menu && gtk_widget_get_visible (GTK_WIDGET (button->menu)))

+ gtk_menu_shell_deactivate (GTK_MENU_SHELL (button->menu));

+

+ if (button->menu) {

+ g_signal_handlers_disconnect_by_func (button->menu,

+ menu_deactivate_cb,

+ button);

+ gtk_menu_detach (button->menu);

+ }

+

+ button->menu = GTK_MENU (menu);

+

+ if (button->menu) {

+ gtk_menu_attach_to_widget (button->menu, GTK_WIDGET (button),

+ menu_detacher);

+ g_signal_connect (button->menu, "deactivate",

+ G_CALLBACK (menu_deactivate_cb), button);

+ }

+}

+

+static void

+menu_position_func (GtkMenu *menu,

+ int *x,

+ int *y,

+ gboolean *push_in,

+ EvNavigationActionWidget *button)

+{

+ GtkWidget *widget = GTK_WIDGET (button);

+ GtkRequisition menu_req;

+ GtkAllocation allocation;

+ GtkTextDirection direction;

+ GdkWindow *gdk_window;

+ GdkRectangle monitor;

+ gint monitor_num;

+ GdkScreen *screen;

+

+ gtk_widget_size_request (GTK_WIDGET (button->menu), &menu_req);

+ direction = gtk_widget_get_direction (widget);

+ screen = gtk_widget_get_screen (GTK_WIDGET (menu));

+

+ gdk_window = gtk_widget_get_window (widget);

+ monitor_num = gdk_screen_get_monitor_at_window (screen, gdk_window);

+ if (monitor_num < 0)

+ monitor_num = 0;

+ gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);

+

+ gdk_window_get_origin (gdk_window, x, y);

+ gtk_widget_get_allocation (widget, &allocation);

+ *x += allocation.x;

+ *y += allocation.y;

+

+ if (direction == GTK_TEXT_DIR_LTR)

+ *x += MAX (allocation.width - menu_req.width, 0);

+ else if (menu_req.width > allocation.width)

+ *x -= menu_req.width - allocation.width;

+

+ if ((*y + allocation.height + menu_req.height) <= monitor.y + monitor.height)

+ *y += allocation.height;

+ else if ((*y - menu_req.height) >= monitor.y)

+ *y -= menu_req.height;

+ else if (monitor.y + monitor.height - (*y + allocation.height) > *y)

+ *y += allocation.height;

+ else

+ *y -= menu_req.height;

+

+ *push_in = FALSE;

+}

+

+static void

+popup_menu_under_arrow (EvNavigationActionWidget *button,

+ GdkEventButton *event)

+{

+ g_signal_emit (button, signals[SHOW_MENU], 0);

+

+ if (!button->menu)

+ return;

+

+ gtk_menu_popup (button->menu, NULL, NULL,

+ (GtkMenuPositionFunc) menu_position_func,

+ button,

+ event ? event->button : 0,

+ event ? event->time : gtk_get_current_event_time ());

+}

+

+static void

+ev_navigation_action_widget_toggled (GtkToggleToolButton *toggle)

+{

+ EvNavigationActionWidget *button = EV_NAVIGATION_ACTION_WIDGET (toggle);

+ if (!button->menu)

+ return;

+

+ if (gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (button)) &&

+ !gtk_widget_get_visible (GTK_WIDGET (button->menu))) {

+ /* we get here only when the menu is activated by a key

+ * press, so that we can select the first menu item */

+ popup_menu_under_arrow (button, NULL);

+ gtk_menu_shell_select_first (GTK_MENU_SHELL (button->menu), FALSE);

+ }

+}

+

+static gboolean

+ev_navigation_action_widget_button_press_event (GtkWidget *widget,

+ GdkEventButton *event,

+ gpointer data)

+{

+ EvNavigationActionWidget *button = EV_NAVIGATION_ACTION_WIDGET (data);

+

+ if (event->button == 1) {

+ popup_menu_under_arrow (button, event);

+ gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (button), TRUE);

+ return TRUE;

+ }

+ return FALSE;

+}

+/*

+ * Copyright (C) 2003, 2004 Marco Pesenti Gritti

+ * Copyright (C) 2003, 2004 Christian Persch

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ *

+ */

+

+#include <gtk/gtk.h>

+

+#define EV_TYPE_NAVIGATION_ACTION_WIDGET (ev_navigation_action_widget_get_type ())

+#define EV_NAVIGATION_ACTION_WIDGET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EV_TYPE_NAVIGATION_ACTION_WIDGET, EvNavigationActionWidget))

+

+typedef struct _EvNavigationActionWidget EvNavigationActionWidget;

+typedef struct _EvNavigationActionWidgetClass EvNavigationActionWidgetClass;

+

+struct _EvNavigationActionWidget

+{

+ GtkToggleToolButton parent;

+

+ GtkMenu *menu;

+};

+

+struct _EvNavigationActionWidgetClass

+{

+ GtkToggleToolButtonClass parent_class;

+

+ void (*show_menu) (EvNavigationActionWidget *widget);

+};

+

+GType ev_navigation_action_widget_get_type (void);

+

+void

+ev_navigation_action_widget_set_menu(EvNavigationActionWidget *widget, GtkWidget *menu);

+/*

+ * Copyright (C) 2003, 2004 Marco Pesenti Gritti

+ * Copyright (C) 2003, 2004 Christian Persch

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ *

+ */

+

+#include "config.h"

+

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+

+#include "ev-navigation-action.h"

+#include "ev-navigation-action-widget.h"

+

+

+enum

+{

+ WIDGET_ACTIVATE_LINK,

+ WIDGET_N_SIGNALS

+};

+

+static guint widget_signals[WIDGET_N_SIGNALS] = {0, };

+

+struct _EvNavigationActionPrivate

+{

+ EvHistory *history;

+};

+

+static void ev_navigation_action_init (EvNavigationAction *action);

+static void ev_navigation_action_class_init (EvNavigationActionClass *class);

+

+G_DEFINE_TYPE (EvNavigationAction, ev_navigation_action, GTK_TYPE_ACTION)

+

+#define MAX_LABEL_LENGTH 48

+

+#define EV_NAVIGATION_ACTION_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_NAVIGATION_ACTION, EvNavigationActionPrivate))

+

+static void

+ev_navigation_action_history_changed (EvHistory *history,

+ gpointer data)

+{

+ EvNavigationAction *action = EV_NAVIGATION_ACTION (data);

+

+ gtk_action_set_sensitive (GTK_ACTION (action),

+ ev_history_get_n_links (history) > 0);

+}

+

+void

+ev_navigation_action_set_history (EvNavigationAction *action,

+ EvHistory *history)

+{

+ action->priv->history = history;

+

+ g_object_add_weak_pointer (G_OBJECT (action->priv->history),

+ (gpointer) &action->priv->history);

+

+ g_signal_connect_object (history, "changed",

+ G_CALLBACK (ev_navigation_action_history_changed),

+ action, 0);

+}

+

+static void

+activate_menu_item_cb (GtkWidget *widget, EvNavigationAction *action)

+{

+ int index;

+

+ g_return_if_fail (EV_IS_HISTORY (action->priv->history));

+

+ index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "index"));

+

+ if (action->priv->history) {

+ EvLink *link;

+

+ link = ev_history_get_link_nth (action->priv->history, index);

+

+ g_signal_emit (action, widget_signals[WIDGET_ACTIVATE_LINK], 0, link);

+ }

+}

+

+static GtkWidget *

+new_history_menu_item (EvNavigationAction *action,

+ EvLink *link,

+ int index)

+{

+ GtkLabel *label;

+ GtkWidget *item;

+ const char *title;

+

+ title = ev_link_get_title (link);

+ item = gtk_image_menu_item_new_with_label (title);

+ label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (item)));

+ gtk_label_set_use_markup (label, TRUE);

+ g_object_set_data (G_OBJECT (item), "index",

+ GINT_TO_POINTER (index));

+

+ gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);

+ gtk_label_set_max_width_chars (label, MAX_LABEL_LENGTH);

+

+ g_signal_connect (item, "activate",

+ G_CALLBACK (activate_menu_item_cb),

+ action);

+

+ gtk_widget_show (item);

+

+ return item;

+}

+

+static GtkWidget *

+build_menu (EvNavigationAction *action)

+{

+ GtkMenuShell *menu;

+ GtkWidget *item;

+ EvLink *link;

+ EvHistory *history = action->priv->history;

+ int start, end, i;

+

+ if (history == NULL || ev_history_get_n_links (history) <= 0) {

+ return NULL;

+ }

+

+ menu = GTK_MENU_SHELL (gtk_menu_new ());

+

+ start = 0;

+ end = ev_history_get_n_links (history);

+

+ for (i = start; i < end; i++) {

+ link = ev_history_get_link_nth (history, i);

+ item = new_history_menu_item (action, link, i);

+ gtk_menu_shell_prepend (menu, item);

+ }

+

+ return GTK_WIDGET (menu);

+}

+

+static void

+menu_activated_cb (EvNavigationActionWidget *button,

+ EvNavigationAction *action)

+{

+ GtkWidget *menu;

+

+ menu = build_menu (action);

+ ev_navigation_action_widget_set_menu (button, menu);

+}

+

+static void

+connect_proxy (GtkAction *action, GtkWidget *proxy)

+{

+ GtkWidget *menu;

+

+ if (GTK_IS_TOOL_ITEM (proxy)) {

+ /* set dummy menu so the arrow gets sensitive */

+ menu = gtk_menu_new ();

+ ev_navigation_action_widget_set_menu (EV_NAVIGATION_ACTION_WIDGET (proxy), menu);

+

+ g_signal_connect (proxy, "show-menu",

+ G_CALLBACK (menu_activated_cb), action);

+ }

+

+ GTK_ACTION_CLASS (ev_navigation_action_parent_class)->connect_proxy (action, proxy);

+}

+

+static GtkWidget *

+create_tool_item (GtkAction *action)

+{

+ EvNavigationActionWidget *proxy;

+

+ proxy = g_object_new (EV_TYPE_NAVIGATION_ACTION_WIDGET, NULL);

+ gtk_widget_show (GTK_WIDGET (proxy));

+

+ return GTK_WIDGET (proxy);

+}

+

+static GtkWidget *

+create_menu_item (GtkAction *action)

+{

+ GtkWidget *menu;

+ GtkWidget *menu_item;

+

+ menu = build_menu (EV_NAVIGATION_ACTION (action));

+

+ menu_item = GTK_ACTION_CLASS (ev_navigation_action_parent_class)->create_menu_item (action);

+

+ gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);

+

+ gtk_widget_show (menu_item);

+

+ return menu_item;

+}

+

+static void

+ev_navigation_action_init (EvNavigationAction *action)

+{

+ action->priv = EV_NAVIGATION_ACTION_GET_PRIVATE (action);

+}

+

+static void

+ev_navigation_action_finalize (GObject *object)

+{

+ EvNavigationAction *action = EV_NAVIGATION_ACTION (object);

+

+ if (action->priv->history) {

+ g_object_remove_weak_pointer (G_OBJECT (action->priv->history),

+ (gpointer) &action->priv->history);

+ action->priv->history = NULL;

+ }

+

+ G_OBJECT_CLASS (ev_navigation_action_parent_class)->finalize (object);

+}

+

+static void

+ev_navigation_action_class_init (EvNavigationActionClass *class)

+{

+ GObjectClass *object_class = G_OBJECT_CLASS (class);

+ GtkActionClass *action_class = GTK_ACTION_CLASS (class);

+

+ object_class->finalize = ev_navigation_action_finalize;

+

+ action_class->toolbar_item_type = GTK_TYPE_TOOL_ITEM;

+ action_class->create_tool_item = create_tool_item;

+ action_class->connect_proxy = connect_proxy;

+ action_class->create_menu_item = create_menu_item;

+

+ widget_signals[WIDGET_ACTIVATE_LINK] = g_signal_new ("activate_link",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

+ G_STRUCT_OFFSET (EvNavigationActionClass, activate_link),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__OBJECT,

+ G_TYPE_NONE, 1,

+ G_TYPE_OBJECT);

+

+ g_type_class_add_private (object_class, sizeof (EvNavigationActionPrivate));

+}

+/*

+ * Copyright (C) 2003, 2004 Marco Pesenti Gritti

+ * Copyright (C) 2003, 2004 Christian Persch

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ *

+ */

+

+#ifndef EV_NAVIGATION_ACTION_H

+#define EV_NAVIGATION_ACTION_H

+

+#include <gtk/gtk.h>

+

+#include "ev-history.h"

+#include "ev-link.h"

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_NAVIGATION_ACTION (ev_navigation_action_get_type ())

+#define EV_NAVIGATION_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EV_TYPE_NAVIGATION_ACTION, EvNavigationAction))

+#define EV_NAVIGATION_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_NAVIGATION_ACTION, EvNavigationActionClass))

+#define EV_IS_NAVIGATION_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EV_TYPE_NAVIGATION_ACTION))

+#define EV_IS_NAVIGATION_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), EV_TYPE_NAVIGATION_ACTION))

+#define EV_NAVIGATION_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), EV_TYPE_NAVIGATION_ACTION, EvNavigationActionClass))

+

+typedef struct _EvNavigationAction EvNavigationAction;

+typedef struct _EvNavigationActionPrivate EvNavigationActionPrivate;

+typedef struct _EvNavigationActionClass EvNavigationActionClass;

+

+struct _EvNavigationAction

+{

+ GtkAction parent;

+

+ /*< private >*/

+ EvNavigationActionPrivate *priv;

+};

+

+struct _EvNavigationActionClass

+{

+ GtkActionClass parent_class;

+

+ void (* activate_link) (EvNavigationAction *action,

+ EvLink *link);

+};

+

+GType ev_navigation_action_get_type (void);

+void ev_navigation_action_set_history (EvNavigationAction *action,

+ EvHistory *history);

+

+G_END_DECLS

+

+#endif

+/*

+ * Copyright (C) 2007, Carlos Garcia Campos <[email protected]>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ *

+ */

+

+#include <config.h>

+

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+

+#include "ev-open-recent-action.h"

+

+

+enum {

+ ITEM_ACTIVATED,

+ N_SIGNALS

+};

+

+static void ev_open_recent_action_init (EvOpenRecentAction *action);

+static void ev_open_recent_action_class_init (EvOpenRecentActionClass *class);

+

+static guint action_signals[N_SIGNALS];

+

+G_DEFINE_TYPE (EvOpenRecentAction, ev_open_recent_action, GTK_TYPE_ACTION)

+

+static void

+recent_chooser_item_activated (GtkRecentChooser *chooser,

+ GtkAction *action)

+{

+ gchar *uri;

+

+ uri = gtk_recent_chooser_get_current_uri (chooser);

+ g_signal_emit (action, action_signals[ITEM_ACTIVATED], 0, uri);

+ g_free (uri);

+}

+

+static GtkWidget *

+ev_open_recent_action_create_tool_item (GtkAction *action)

+{

+ GtkWidget *tool_item;

+ GtkWidget *toolbar_recent_menu;

+ GtkRecentFilter *filter;

+

+ toolbar_recent_menu = gtk_recent_chooser_menu_new_for_manager (gtk_recent_manager_get_default ());

+ gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (toolbar_recent_menu), FALSE);

+ gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (toolbar_recent_menu), GTK_RECENT_SORT_MRU);

+ gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (toolbar_recent_menu), 5);

+ g_signal_connect (toolbar_recent_menu, "item_activated",

+ G_CALLBACK (recent_chooser_item_activated),

+ action);

+

+ filter = gtk_recent_filter_new ();

+ gtk_recent_filter_add_application (filter, g_get_application_name ());

+ gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (toolbar_recent_menu), filter);

+

+ tool_item = GTK_WIDGET (gtk_menu_tool_button_new_from_stock (GTK_STOCK_OPEN));

+ gtk_menu_tool_button_set_arrow_tooltip_text (GTK_MENU_TOOL_BUTTON (tool_item),

+ _("Open a recently used document"));

+ gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (tool_item),

+ GTK_WIDGET (toolbar_recent_menu));

+ return tool_item;

+}

+

+static void

+ev_open_recent_action_init (EvOpenRecentAction *action)

+{

+}

+

+static void

+ev_open_recent_action_class_init (EvOpenRecentActionClass *class)

+{

+ GObjectClass *object_class = G_OBJECT_CLASS (class);

+ GtkActionClass *action_class = GTK_ACTION_CLASS (class);

+

+ action_class->toolbar_item_type = GTK_TYPE_MENU_TOOL_BUTTON;

+ action_class->create_tool_item = ev_open_recent_action_create_tool_item;

+

+ action_signals[ITEM_ACTIVATED] =

+ g_signal_new ("item_activated",

+ G_OBJECT_CLASS_TYPE (object_class),

+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

+ G_STRUCT_OFFSET (EvOpenRecentActionClass, item_activated),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__STRING,

+ G_TYPE_NONE, 1,

+ G_TYPE_STRING);

+}

+/*

+ * Copyright (C) 2007, Carlos Garcia Campos <[email protected]>

+ *

+ * This program is free software; you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2, or (at your option)

+ * any later version.

+ *

+ * This program is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+ * GNU General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA..

+ *

+ */

+

+#ifndef EV_OPEN_RECENT_ACTION_H

+#define EV_OPEN_RECENT_ACTION_H

+

+#include <gtk/gtk.h>

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_OPEN_RECENT_ACTION (ev_open_recent_action_get_type ())

+#define EV_OPEN_RECENT_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EV_TYPE_OPEN_RECENT_ACTION, EvOpenRecentAction))

+#define EV_OPEN_RECENT_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_OPEN_RECENT_ACTION, EvOpenRecentActionClass))

+#define EV_IS_OPEN_RECENT_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EV_TYPE_OPEN_RECENT_ACTION))

+#define EV_IS_OPEN_RECENT_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), EV_TYPE_OPEN_RECENT_ACTION))

+#define EV_OPEN_RECENT_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), EV_TYPE_OPEN_RECENT_ACTION, EvOpenRecentActionClass))

+

+typedef struct _EvOpenRecentAction EvOpenRecentAction;

+typedef struct _EvOpenRecentActionClass EvOpenRecentActionClass;

+

+struct _EvOpenRecentAction {

+ GtkAction parent;

+};

+

+struct _EvOpenRecentActionClass {

+ GtkActionClass parent_class;

+

+ void (* item_activated) (EvOpenRecentAction *action,

+ const gchar *uri);

+};

+

+GType ev_open_recent_action_get_type (void) G_GNUC_CONST;

+

+G_END_DECLS

+

+#endif /* EV_OPEN_RECENT_ACTION_H */

+/* this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>

+ * Copyright (C) 2005 Red Hat, Inc

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+#include <gio/gio.h>

+

+#include "ev-keyring.h"

+#include "ev-password-view.h"

+

+enum {

+ UNLOCK,

+ LAST_SIGNAL

+};

+struct _EvPasswordViewPrivate {

+ GtkWindow *parent_window;

+ GtkWidget *label;

+ GtkWidget *password_entry;

+

+ gchar *password;

+ GPasswordSave password_save;

+

+ GFile *uri_file;

+};

+

+#define EV_PASSWORD_VIEW_GET_PRIVATE(object) \

+ (G_TYPE_INSTANCE_GET_PRIVATE ((object), EV_TYPE_PASSWORD_VIEW, EvPasswordViewPrivate));

+

+static guint password_view_signals [LAST_SIGNAL] = { 0 };

+

+

+G_DEFINE_TYPE (EvPasswordView, ev_password_view, GTK_TYPE_VIEWPORT)

+

+static void

+ev_password_view_finalize (GObject *object)

+{

+ EvPasswordView *password_view = EV_PASSWORD_VIEW (object);

+

+ if (password_view->priv->password) {

+ g_free (password_view->priv->password);

+ password_view->priv->password = NULL;

+ }

+

+ password_view->priv->parent_window = NULL;

+

+ if (password_view->priv->uri_file) {

+ g_object_unref (password_view->priv->uri_file);

+ password_view->priv->uri_file = NULL;

+ }

+

+ G_OBJECT_CLASS (ev_password_view_parent_class)->finalize (object);

+}

+

+static void

+ev_password_view_class_init (EvPasswordViewClass *class)

+{

+ GObjectClass *g_object_class;

+ GtkWidgetClass *widget_class;

+

+ g_object_class = G_OBJECT_CLASS (class);

+ widget_class = GTK_WIDGET_CLASS (class);

+

+ password_view_signals[UNLOCK] =

+ g_signal_new ("unlock",

+ G_TYPE_FROM_CLASS (g_object_class),

+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,

+ G_STRUCT_OFFSET (EvPasswordViewClass, unlock),

+ NULL, NULL,

+ g_cclosure_marshal_VOID__VOID,

+ G_TYPE_NONE, 0);

+

+ g_type_class_add_private (g_object_class, sizeof (EvPasswordViewPrivate));

+

+ g_object_class->finalize = ev_password_view_finalize;

+}

+

+static void

+ev_password_view_clicked_cb (GtkWidget *button,

+ EvPasswordView *password_view)

+{

+ ev_password_view_ask_password (password_view);

+}

+

+static void

+ev_password_view_init (EvPasswordView *password_view)

+{

+ GtkWidget *align;

+ GtkWidget *vbox;

+ GtkWidget *hbox;

+ GtkWidget *image;

+ GtkWidget *button;

+ GtkWidget *label;

+ gchar *markup;

+

+ password_view->priv = EV_PASSWORD_VIEW_GET_PRIVATE (password_view);

+

+ password_view->priv->password_save = G_PASSWORD_SAVE_NEVER;

+

+ gtk_widget_push_composite_child ();

+

+ /* set ourselves up */

+ align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);

+ vbox = gtk_vbox_new (FALSE, 24);

+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 24);

+ gtk_container_add (GTK_CONTAINER (password_view), align);

+ gtk_container_add (GTK_CONTAINER (align), vbox);

+

+ password_view->priv->label =

+ (GtkWidget *) g_object_new (GTK_TYPE_LABEL,

+ "wrap", TRUE,

+ "selectable", TRUE,

+ NULL);

+ gtk_box_pack_start (GTK_BOX (vbox), password_view->priv->label, FALSE, FALSE, 0);

+

+ image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,

+ GTK_ICON_SIZE_DIALOG);

+ gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);

+

+ label = gtk_label_new (NULL);

+ gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

+ markup = g_strdup_printf ("<span size=\"x-large\">%s</span>",

+ _("This document is locked and can only be read by entering the correct password."));

+ gtk_label_set_markup (GTK_LABEL (label), markup);

+ g_free (markup);

+

+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);

+

+ hbox = gtk_hbox_new (FALSE, 0);

+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

+

+ button = gtk_button_new_with_mnemonic (_("_Unlock Document"));

+ g_signal_connect (button, "clicked", G_CALLBACK (ev_password_view_clicked_cb), password_view);

+ gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);

+

+ gtk_widget_show_all (align);

+ gtk_widget_pop_composite_child ();

+}

+

+/* Public functions */

+void

+ev_password_view_set_uri (EvPasswordView *password_view,

+ const char *uri)

+{

+ gchar *markup, *file_name;

+ GFile *file;

+

+ g_return_if_fail (EV_IS_PASSWORD_VIEW (password_view));

+ g_return_if_fail (uri != NULL);

+

+ file = g_file_new_for_uri (uri);

+ if (password_view->priv->uri_file &&

+ g_file_equal (file, password_view->priv->uri_file)) {

+ g_object_unref (file);

+ return;

+ }

+ if (password_view->priv->uri_file)

+ g_object_unref (password_view->priv->uri_file);

+ password_view->priv->uri_file = file;

+

+ file_name = g_file_get_basename (password_view->priv->uri_file);

+ markup = g_markup_printf_escaped ("<span size=\"x-large\" weight=\"bold\">%s</span>",

+ file_name);

+ g_free (file_name);

+

+ gtk_label_set_markup (GTK_LABEL (password_view->priv->label), markup);

+ g_free (markup);

+}

+

+static void

+ev_password_dialog_got_response (GtkDialog *dialog,

+ gint response_id,

+ EvPasswordView *password_view)

+{

+ gtk_widget_set_sensitive (GTK_WIDGET (password_view), TRUE);

+

+ if (response_id == GTK_RESPONSE_OK) {

+ g_free (password_view->priv->password);

+ password_view->priv->password =

+ g_strdup (gtk_entry_get_text (GTK_ENTRY (password_view->priv->password_entry)));

+

+ g_signal_emit (password_view, password_view_signals[UNLOCK], 0);

+ }

+

+ gtk_widget_destroy (GTK_WIDGET (dialog));

+}

+

+static void

+ev_password_dialog_remember_button_toggled (GtkToggleButton *button,

+ EvPasswordView *password_view)

+{

+ if (gtk_toggle_button_get_active (button)) {

+ gpointer data;

+

+ data = g_object_get_data (G_OBJECT (button), "password-save");

+ password_view->priv->password_save = GPOINTER_TO_INT (data);

+ }

+}

+

+static void

+ev_password_dialog_entry_changed_cb (GtkEditable *editable,

+ GtkDialog *dialog)

+{

+ const char *text;

+

+ text = gtk_entry_get_text (GTK_ENTRY (editable));

+

+ gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK,

+ (text != NULL && *text != '\0'));

+}

+

+static void

+ev_password_dialog_entry_activated_cb (GtkEntry *entry,

+ GtkDialog *dialog)

+{

+ gtk_dialog_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);

+}

+

+void

+ev_password_view_ask_password (EvPasswordView *password_view)

+{

+ GtkDialog *dialog;

+ GtkWidget *content_area, *action_area;

+ GtkWidget *entry_container;

+ GtkWidget *hbox, *main_vbox, *vbox, *icon;

+ GtkWidget *table;

+ GtkWidget *label;

+ gchar *format, *markup, *file_name;

+

+ gtk_widget_set_sensitive (GTK_WIDGET (password_view), FALSE);

+

+ dialog = GTK_DIALOG (gtk_dialog_new ());

+ content_area = gtk_dialog_get_content_area (dialog);

+ action_area = gtk_dialog_get_action_area (dialog);

+

+ /* Set the dialog up with HIG properties */

+ gtk_dialog_set_has_separator (dialog, FALSE);

+ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);

+ gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */

+ gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);

+ gtk_box_set_spacing (GTK_BOX (action_area), 6);

+

+ gtk_window_set_title (GTK_WINDOW (dialog), _("Enter password"));

+ gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);

+ gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION);

+ gtk_window_set_transient_for (GTK_WINDOW (dialog), password_view->priv->parent_window);

+ gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);

+

+ gtk_dialog_add_buttons (dialog,

+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,

+ _("_Unlock Document"), GTK_RESPONSE_OK,

+ NULL);

+ gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK);

+ gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),

+ GTK_RESPONSE_OK, FALSE);

+ gtk_dialog_set_alternative_button_order (dialog,

+ GTK_RESPONSE_OK,

+ GTK_RESPONSE_CANCEL,

+ -1);

+

+ /* Build contents */

+ hbox = gtk_hbox_new (FALSE, 12);

+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);

+ gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);

+ gtk_widget_show (hbox);

+

+ icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,

+ GTK_ICON_SIZE_DIALOG);

+

+ gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0);

+ gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);

+ gtk_widget_show (icon);

+

+ main_vbox = gtk_vbox_new (FALSE, 18);

+ gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0);

+ gtk_widget_show (main_vbox);

+

+ label = gtk_label_new (NULL);

+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);

+ gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

+ file_name = g_file_get_basename (password_view->priv->uri_file);

+ format = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s",

+ _("Password required"),

+ _("The document “%s” is locked and requires a password before it can be opened."));

+ markup = g_markup_printf_escaped (format, file_name);

+ gtk_label_set_markup (GTK_LABEL (label), markup);

+ g_free (format);

+ g_free (markup);

+ g_free (file_name);

+ gtk_box_pack_start (GTK_BOX (main_vbox), label,

+ FALSE, FALSE, 0);

+ gtk_widget_show (label);

+

+ vbox = gtk_vbox_new (FALSE, 6);

+ gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);

+ gtk_widget_show (vbox);

+

+ /* The table that holds the entries */

+ entry_container = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);

+

+ gtk_alignment_set_padding (GTK_ALIGNMENT (entry_container),

+ 0, 0, 0, 0);

+

+ gtk_box_pack_start (GTK_BOX (vbox), entry_container,

+ FALSE, FALSE, 0);

+ gtk_widget_show (entry_container);

+

+ table = gtk_table_new (1, 2, FALSE);

+ gtk_table_set_col_spacings (GTK_TABLE (table), 12);

+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);

+ gtk_container_add (GTK_CONTAINER (entry_container), table);

+ gtk_widget_show (table);

+

+ label = gtk_label_new_with_mnemonic (_("_Password:"));

+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);

+

+ password_view->priv->password_entry = gtk_entry_new ();

+ gtk_entry_set_visibility (GTK_ENTRY (password_view->priv->password_entry), FALSE);

+ g_signal_connect (password_view->priv->password_entry, "changed",

+ G_CALLBACK (ev_password_dialog_entry_changed_cb),

+ dialog);

+ g_signal_connect (password_view->priv->password_entry, "activate",

+ G_CALLBACK (ev_password_dialog_entry_activated_cb),

+ dialog);

+ gtk_table_attach (GTK_TABLE (table), label,

+ 0, 1, 0, 1,

+ GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

+ gtk_widget_show (label);

+

+ gtk_table_attach_defaults (GTK_TABLE (table), password_view->priv->password_entry,

+ 1, 2, 0, 1);

+ gtk_widget_show (password_view->priv->password_entry);

+

+ gtk_label_set_mnemonic_widget (GTK_LABEL (label),

+ password_view->priv->password_entry);

+

+ if (ev_keyring_is_available ()) {

+ GtkWidget *choice;

+ GtkWidget *remember_box;

+ GSList *group;

+

+ remember_box = gtk_vbox_new (FALSE, 6);

+ gtk_box_pack_start (GTK_BOX (vbox), remember_box,

+ FALSE, FALSE, 0);

+ gtk_widget_show (remember_box);

+

+ choice = gtk_radio_button_new_with_mnemonic (NULL, _("Forget password _immediately"));

+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),

+ password_view->priv->password_save == G_PASSWORD_SAVE_NEVER);

+ g_object_set_data (G_OBJECT (choice), "password-save",

+ GINT_TO_POINTER (G_PASSWORD_SAVE_NEVER));

+ g_signal_connect (choice, "toggled",

+ G_CALLBACK (ev_password_dialog_remember_button_toggled),

+ password_view);

+ gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);

+ gtk_widget_show (choice);

+

+ group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));

+ choice = gtk_radio_button_new_with_mnemonic (group, _("Remember password until you _log out"));

+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),

+ password_view->priv->password_save == G_PASSWORD_SAVE_FOR_SESSION);

+ g_object_set_data (G_OBJECT (choice), "password-save",

+ GINT_TO_POINTER (G_PASSWORD_SAVE_FOR_SESSION));

+ g_signal_connect (choice, "toggled",

+ G_CALLBACK (ev_password_dialog_remember_button_toggled),

+ password_view);

+ gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);

+ gtk_widget_show (choice);

+

+ group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (choice));

+ choice = gtk_radio_button_new_with_mnemonic (group, _("Remember _forever"));

+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (choice),

+ password_view->priv->password_save == G_PASSWORD_SAVE_PERMANENTLY);

+ g_object_set_data (G_OBJECT (choice), "password-save",

+ GINT_TO_POINTER (G_PASSWORD_SAVE_PERMANENTLY));

+ g_signal_connect (choice, "toggled",

+ G_CALLBACK (ev_password_dialog_remember_button_toggled),

+ password_view);

+ gtk_box_pack_start (GTK_BOX (remember_box), choice, FALSE, FALSE, 0);

+ gtk_widget_show (choice);

+ }

+

+ g_signal_connect (dialog, "response",

+ G_CALLBACK (ev_password_dialog_got_response),

+ password_view);

+

+ gtk_widget_show (GTK_WIDGET (dialog));

+}

+

+const gchar *

+ev_password_view_get_password (EvPasswordView *password_view)

+{

+ return password_view->priv->password;

+}

+

+GPasswordSave

+ev_password_view_get_password_save_flags (EvPasswordView *password_view)

+{

+ return password_view->priv->password_save;

+}

+

+GtkWidget *

+ev_password_view_new (GtkWindow *parent)

+{

+ EvPasswordView *retval;

+

+ retval = EV_PASSWORD_VIEW (g_object_new (EV_TYPE_PASSWORD_VIEW, NULL));

+

+ retval->priv->parent_window = parent;

+

+ return GTK_WIDGET (retval);

+}

+

+/* this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2005 Red Hat, Inc

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef __EV_PASSWORD_VIEW_H__

+#define __EV_PASSWORD_VIEW_H__

+

+#include <gtk/gtk.h>

+#include <gio/gio.h>

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_PASSWORD_VIEW (ev_password_view_get_type ())

+#define EV_PASSWORD_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EV_TYPE_PASSWORD_VIEW, EvPasswordView))

+#define EV_IS_PASSWORD_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EV_TYPE_PASSWORD_VIEW))

+

+typedef struct _EvPasswordView EvPasswordView;

+typedef struct _EvPasswordViewClass EvPasswordViewClass;

+typedef struct _EvPasswordViewPrivate EvPasswordViewPrivate;

+

+struct _EvPasswordView {

+ GtkViewport parent_instance;

+

+ EvPasswordViewPrivate *priv;

+};

+

+struct _EvPasswordViewClass {

+ GtkViewportClass parent_class;

+

+ /* signals */

+ void (*unlock) (EvPasswordView *self);

+};

+

+GType ev_password_view_get_type (void) G_GNUC_CONST;

+GtkWidget *ev_password_view_new (GtkWindow *parent);

+void ev_password_view_set_uri (EvPasswordView *password_view,

+ const char *uri);

+void ev_password_view_ask_password (EvPasswordView *password_view);

+const gchar *ev_password_view_get_password (EvPasswordView *password_view);

+GPasswordSave ev_password_view_get_password_save_flags (EvPasswordView *password_view);

+

+G_END_DECLS

+

+#endif /* __EV_PASSWORD_VIEW_H__ */

+/* ev-progress-message-area.c

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#include <config.h>

+

+#include <gtk/gtk.h>

+

+#include "ev-progress-message-area.h"

+

+#define EV_PROGRESS_MESSAGE_AREA_GET_PRIVATE(obj) \

+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EV_TYPE_PROGRESS_MESSAGE_AREA, EvProgressMessageAreaPrivate))

+

+struct _EvProgressMessageAreaPrivate {

+ GtkWidget *label;

+ GtkWidget *progress_bar;

+};

+

+enum {

+ PROP_0,

+ PROP_STATUS,

+ PROP_FRACTION

+};

+

+static void ev_progress_message_area_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec);

+static void ev_progress_message_area_get_property (GObject *object,

+ guint prop_id,

+ GValue *value,

+ GParamSpec *pspec);

+

+G_DEFINE_TYPE (EvProgressMessageArea, ev_progress_message_area, EV_TYPE_MESSAGE_AREA)

+

+static void

+ev_progress_message_area_class_init (EvProgressMessageAreaClass *class)

+{

+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);

+

+ gobject_class->set_property = ev_progress_message_area_set_property;

+ gobject_class->get_property = ev_progress_message_area_get_property;

+

+ g_object_class_install_property (gobject_class,

+ PROP_STATUS,

+ g_param_spec_string ("status",

+ "Status",

+ "The status text of the progress area",

+ NULL,

+ G_PARAM_READWRITE));

+ g_object_class_install_property (gobject_class,

+ PROP_FRACTION,

+ g_param_spec_double ("fraction",

+ "Fraction",

+ "The fraction of total work that has been completed",

+ 0.0, 1.0, 0.0,

+ G_PARAM_READWRITE));

+

+ g_type_class_add_private (gobject_class, sizeof (EvProgressMessageAreaPrivate));

+}

+

+static void

+ev_progress_message_area_init (EvProgressMessageArea *area)

+{

+ GtkWidget *contents;

+ GtkWidget *vbox;

+

+ area->priv = EV_PROGRESS_MESSAGE_AREA_GET_PRIVATE (area);

+

+ contents = _ev_message_area_get_main_box (EV_MESSAGE_AREA (area));

+

+ vbox = gtk_vbox_new (FALSE, 6);

+

+ area->priv->label = gtk_label_new (NULL);

+ gtk_label_set_use_markup (GTK_LABEL (area->priv->label), TRUE);

+ gtk_label_set_ellipsize (GTK_LABEL (area->priv->label),

+ PANGO_ELLIPSIZE_END);

+ gtk_misc_set_alignment (GTK_MISC (area->priv->label), 0.0, 0.5);

+ gtk_box_pack_start (GTK_BOX (vbox), area->priv->label, TRUE, TRUE, 0);

+ gtk_widget_show (area->priv->label);

+

+ area->priv->progress_bar = gtk_progress_bar_new ();

+ gtk_widget_set_size_request (area->priv->progress_bar, -1, 15);

+ gtk_box_pack_start (GTK_BOX (vbox), area->priv->progress_bar, TRUE, FALSE, 0);

+ gtk_widget_show (area->priv->progress_bar);

+

+ gtk_box_pack_start (GTK_BOX (contents), vbox, TRUE, TRUE, 0);

+ gtk_widget_show (vbox);

+}

+

+static void

+ev_progress_message_area_set_property (GObject *object,

+ guint prop_id,

+ const GValue *value,

+ GParamSpec *pspec)

+{

+ EvProgressMessageArea *area = EV_PROGRESS_MESSAGE_AREA (object);

+

+ switch (prop_id) {

+ case PROP_STATUS:

+ ev_progress_message_area_set_status (area, g_value_get_string (value));

+ break;

+ case PROP_FRACTION:

+ ev_progress_message_area_set_fraction (area, g_value_get_double (value));

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ }

+}

+

+static void

+ev_progress_message_area_get_property (GObject *object,

+ guint prop_id,

+ GValue *value,

+ GParamSpec *pspec)

+{

+ EvProgressMessageArea *area = EV_PROGRESS_MESSAGE_AREA (object);

+

+ switch (prop_id) {

+ case PROP_STATUS:

+ g_value_set_string (value, gtk_label_get_label (GTK_LABEL (area->priv->label)));

+ break;

+ case PROP_FRACTION: {

+ gdouble fraction;

+

+ fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (area->priv->progress_bar));

+ g_value_set_double (value, fraction);

+ }

+ break;

+ default:

+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

+ }

+}

+

+GtkWidget *

+ev_progress_message_area_new (const gchar *stock_id,

+ const gchar *text,

+ const gchar *first_button_text,

+ ...)

+{

+ GtkWidget *widget;

+

+ widget = g_object_new (EV_TYPE_PROGRESS_MESSAGE_AREA,

+ "message-type", GTK_MESSAGE_OTHER,

+ "text", text,

+ NULL);

+ if (first_button_text) {

+ va_list args;

+

+ va_start (args, first_button_text);

+ _ev_message_area_add_buttons_valist (EV_MESSAGE_AREA (widget),

+ first_button_text,

+ args);

+ va_end (args);

+ }

+

+ ev_message_area_set_image_from_stock (EV_MESSAGE_AREA (widget), stock_id);

+

+ return widget;

+}

+

+void

+ev_progress_message_area_set_status (EvProgressMessageArea *area,

+ const gchar *str)

+{

+ g_return_if_fail (EV_IS_PROGRESS_MESSAGE_AREA (area));

+

+ gtk_label_set_text (GTK_LABEL (area->priv->label), str);

+

+ g_object_notify (G_OBJECT (area), "status");

+}

+

+void

+ev_progress_message_area_set_fraction (EvProgressMessageArea *area,

+ gdouble fraction)

+{

+ g_return_if_fail (EV_IS_PROGRESS_MESSAGE_AREA (area));

+

+ gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (area->priv->progress_bar),

+ fraction);

+ g_object_notify (G_OBJECT (area), "fraction");

+}

+/* ev-progress-message-area.h

+ * this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2008 Carlos Garcia Campos <[email protected]>

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef EV_PROGRESS_MESSAGE_AREA_H

+#define EV_PROGRESS_MESSAGE_AREA_H

+

+#include <gtk/gtk.h>

+

+#include "ev-message-area.h"

+

+G_BEGIN_DECLS

+

+#define EV_TYPE_PROGRESS_MESSAGE_AREA (ev_progress_message_area_get_type ())

+#define EV_PROGRESS_MESSAGE_AREA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EV_TYPE_PROGRESS_MESSAGE_AREA, EvProgressMessageArea))

+#define EV_PROGRESS_MESSAGE_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EV_TYPE_PROGRESS_MESSAGE_AREA, EvProgressMessageAreaClass))

+#define EV_IS_PROGRESS_MESSAGE_AREA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EV_TYPE_PROGRESS_MESSAGE_AREA))

+#define EV_IS_PROGRESS_MESSAGE_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EV_TYPE_PROGRESS_MESSAGE_AREA))

+#define EV_PROGRESS_MESSAGE_AREA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EV_TYPE_PROGRESS_MESSAGE_AREA, EvProgressMessageAreaClass))

+

+typedef struct _EvProgressMessageArea EvProgressMessageArea;

+typedef struct _EvProgressMessageAreaClass EvProgressMessageAreaClass;

+typedef struct _EvProgressMessageAreaPrivate EvProgressMessageAreaPrivate;

+

+struct _EvProgressMessageArea {

+ EvMessageArea parent_instance;

+

+ /*< private >*/

+ EvProgressMessageAreaPrivate *priv;

+};

+

+struct _EvProgressMessageAreaClass {

+ EvMessageAreaClass parent_class;

+};

+

+GType ev_progress_message_area_get_type (void) G_GNUC_CONST;

+GtkWidget *ev_progress_message_area_new (const gchar *stock_id,

+ const gchar *text,

+ const gchar *first_button_text,

+ ...);

+void ev_progress_message_area_set_status (EvProgressMessageArea *area,

+ const gchar *str);

+void ev_progress_message_area_set_fraction (EvProgressMessageArea *area,

+ gdouble fraction);

+

+G_END_DECLS

+

+#endif /* EV_PROGRESS_MESSAGE_AREA_H */

+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */

+/* this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2005 Red Hat, Inc

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+

+#include "ev-document-fonts.h"

+#include "ev-properties-dialog.h"

+#include "ev-properties-fonts.h"

+#include "ev-properties-view.h"

+#include "ev-properties-license.h"

+

+struct _EvPropertiesDialog {

+ GtkDialog base_instance;

+

+ EvDocument *document;

+ GtkWidget *notebook;

+ GtkWidget *general_page;

+ GtkWidget *fonts_page;

+ GtkWidget *license_page;

+};

+

+struct _EvPropertiesDialogClass {

+ GtkDialogClass base_class;

+};

+

+G_DEFINE_TYPE (EvPropertiesDialog, ev_properties_dialog, GTK_TYPE_DIALOG)

+

+static void

+ev_properties_dialog_class_init (EvPropertiesDialogClass *properties_class)

+{

+}

+

+static void

+ev_properties_dialog_init (EvPropertiesDialog *properties)

+{

+ GtkBox *content_area;

+

+ content_area = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (properties)));

+

+ gtk_window_set_title (GTK_WINDOW (properties), _("Properties"));

+ gtk_window_set_destroy_with_parent (GTK_WINDOW (properties), TRUE);

+ gtk_dialog_set_has_separator (GTK_DIALOG (properties), FALSE);

+ gtk_container_set_border_width (GTK_CONTAINER (properties), 5);

+ gtk_box_set_spacing (content_area, 2);

+

+ gtk_dialog_add_button (GTK_DIALOG (properties), GTK_STOCK_CLOSE,

+ GTK_RESPONSE_CANCEL);

+ gtk_dialog_set_default_response (GTK_DIALOG (properties),

+ GTK_RESPONSE_CANCEL);

+

+ properties->notebook = gtk_notebook_new ();

+ gtk_container_set_border_width (GTK_CONTAINER (properties->notebook), 5);

+ gtk_box_pack_start (content_area, properties->notebook, TRUE, TRUE, 0);

+ gtk_widget_show (properties->notebook);

+

+ g_signal_connect (properties, "response",

+ G_CALLBACK (gtk_widget_destroy), NULL);

+}

+

+void

+ev_properties_dialog_set_document (EvPropertiesDialog *properties,

+ const gchar *uri,

+ EvDocument *document)

+{

+ GtkWidget *label;

+ const EvDocumentInfo *info;

+

+ properties->document = document;

+

+ info = ev_document_get_info (document);

+

+ if (properties->general_page == NULL) {

+ label = gtk_label_new (_("General"));

+ properties->general_page = ev_properties_view_new (uri);

+ gtk_notebook_append_page (GTK_NOTEBOOK (properties->notebook),

+ properties->general_page, label);

+ gtk_widget_show (properties->general_page);

+ }

+ ev_properties_view_set_info (EV_PROPERTIES_VIEW (properties->general_page), info);

+

+ if (EV_IS_DOCUMENT_FONTS (document)) {

+ if (properties->fonts_page == NULL) {

+ label = gtk_label_new (_("Fonts"));

+ properties->fonts_page = ev_properties_fonts_new ();

+ gtk_notebook_append_page (GTK_NOTEBOOK (properties->notebook),

+ properties->fonts_page, label);

+ gtk_widget_show (properties->fonts_page);

+ }

+

+ ev_properties_fonts_set_document

+ (EV_PROPERTIES_FONTS (properties->fonts_page), document);

+ }

+

+ if (info->fields_mask & EV_DOCUMENT_INFO_LICENSE && info->license) {

+ if (properties->license_page == NULL) {

+ label = gtk_label_new (_("Document License"));

+ properties->license_page = ev_properties_license_new ();

+ gtk_notebook_append_page (GTK_NOTEBOOK (properties->notebook),

+ properties->license_page, label);

+ gtk_widget_show (properties->license_page);

+ }

+

+ ev_properties_license_set_license

+ (EV_PROPERTIES_LICENSE (properties->license_page), info->license);

+ }

+}

+

+GtkWidget *

+ev_properties_dialog_new ()

+{

+ EvPropertiesDialog *properties;

+

+ properties = g_object_new (EV_TYPE_PROPERTIES_DIALOG, NULL);

+

+ return GTK_WIDGET (properties);

+}

+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */

+/* this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2005 Red Hat, Inc

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifndef __EV_PROPERTIES_DIALOG_H__

+#define __EV_PROPERTIES_DIALOG_H__

+

+#include "ev-document.h"

+

+G_BEGIN_DECLS

+

+typedef struct _EvPropertiesDialog EvPropertiesDialog;

+typedef struct _EvPropertiesDialogClass EvPropertiesDialogClass;

+typedef struct _EvPropertiesDialogPrivate EvPropertiesDialogPrivate;

+

+#define EV_TYPE_PROPERTIES_DIALOG (ev_properties_dialog_get_type())

+#define EV_PROPERTIES_DIALOG(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EV_TYPE_PROPERTIES_DIALOG, EvPropertiesDialog))

+#define EV_PROPERTIES_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EV_TYPE_PROPERTIES_DIALOG, EvPropertiesDialogClass))

+#define EV_IS_PROPERTIES_DIALOG(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EV_TYPE_PROPERTIES_DIALOG))

+#define EV_IS_PROPERTIES_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), EV_TYPE_PROPERTIES_DIALOG))

+#define EV_PROPERTIES_DIALOG_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS((object), EV_TYPE_PROPERTIES_DIALOG, EvPropertiesDialogClass))

+

+GType ev_properties_dialog_get_type (void);

+GtkWidget *ev_properties_dialog_new (void);

+void ev_properties_dialog_set_document (EvPropertiesDialog *properties,

+ const gchar *uri,

+ EvDocument *document);

+

+G_END_DECLS

+

+#endif /* __EV_PROPERTIES_DIALOG_H__ */

+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; c-indent-level: 8 -*- */

+/* this file is part of evince, a mate document viewer

+ *

+ * Copyright (C) 2005 Red Hat, Inc

+ *

+ * Evince is free software; you can redistribute it and/or modify it

+ * under the terms of the GNU General Public License as published by

+ * the Free Software Foundation; either version 2 of the License, or

+ * (at your option) any later version.

+ *

+ * Evince is distributed in the hope that it will be useful, but

+ * WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

+ */

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#include <glib/gi18n.h>

+#include <gtk/gtk.h>

+

+#include "ev-document-fonts.h"

+#include "ev-job-scheduler.h"

+#include "ev-jobs.h"

+#include "ev-properties-fonts.h"

+

+struct _EvPropertiesFonts {

+ GtkVBox base_instance;

+

+ GtkWidget *fonts_treeview;

+ GtkWidget *fonts_progress_label;

+ EvJob *fonts_job;

+

+ EvDocument *document;

+};

+

+struct _EvPropertiesFontsClass {

+ GtkVBoxClass base_class;

+};

+

+static void

+job_fonts_finished_cb (EvJob *job, EvPropertiesFonts *properties);

+

+G_DEFINE_TYPE (EvPropertiesFonts, ev_properties_fonts, GTK_TYPE_VBOX)

+

+static void

+ev_properties_fonts_dispose (GObject *object)

+{

+ EvPropertiesFonts *properties = EV_PROPERTIES_FONTS (object);

+

+ if (properties->fonts_job) {

+ g_signal_handlers_disconnect_by_func (properties->fonts_job,

+ job_fonts_finished_cb,

+ properties);

+ ev_job_cancel (properties->fonts_job);

+

+ g_object_unref (properties->fonts_job);

+ properties->fonts_job = NULL;

+ }