summaryrefslogtreecommitdiff
path: root/src/ui.c
diff options
context:
space:
mode:
authorAlessio Treglia <quadrispro@ubuntu.com>2010-04-09 13:10:42 +0200
committerAlessio Treglia <quadrispro@ubuntu.com>2010-04-09 13:10:42 +0200
commitcf7d885d901b0abdccaad5cc3305a080744eaf5b (patch)
treebf56ba367a8a872dc562fcf8cce9af6aebae67af /src/ui.c
Imported Upstream version 0.9.10upstream/0.9.10
Diffstat (limited to 'src/ui.c')
-rw-r--r--src/ui.c1648
1 files changed, 1648 insertions, 0 deletions
diff --git a/src/ui.c b/src/ui.c
new file mode 100644
index 0000000..92e83c7
--- /dev/null
+++ b/src/ui.c
@@ -0,0 +1,1648 @@
+/*
+ * Copyright (C) 2009 Canonical Ltd.
+ * Author: Robert Ancell <robert.ancell@canonical.com>
+ *
+ * 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 3 of the License, or (at your option) any later
+ * version. See http://www.gnu.org/copyleft/gpl.html the full text of the
+ * license.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <gconf/gconf-client.h>
+#include <math.h>
+#include <unistd.h> // TEMP: Needed for close() in get_temporary_filename()
+
+#include "ui.h"
+#include "book-view.h"
+
+
+#define DEFAULT_TEXT_DPI 150
+#define DEFAULT_PHOTO_DPI 300
+
+
+enum {
+ START_SCAN,
+ STOP_SCAN,
+ SAVE,
+ EMAIL,
+ QUIT,
+ LAST_SIGNAL
+};
+static guint signals[LAST_SIGNAL] = { 0, };
+
+
+struct SimpleScanPrivate
+{
+ GConfClient *client;
+
+ GtkBuilder *builder;
+
+ GtkWidget *window;
+ GtkWidget *preview_box, *preview_area, *preview_scroll;
+ GtkWidget *page_delete_menuitem, *crop_rotate_menuitem;
+ GtkWidget *stop_menuitem, *stop_toolbutton;
+
+ GtkWidget *text_toolbar_menuitem, *text_menu_menuitem;
+ GtkWidget *photo_toolbar_menuitem, *photo_menu_menuitem;
+
+ GtkWidget *authorize_dialog;
+ GtkWidget *authorize_label;
+ GtkWidget *username_entry, *password_entry;
+
+ GtkWidget *preferences_dialog;
+ GtkWidget *device_combo, *text_dpi_combo, *photo_dpi_combo, *page_side_combo, *paper_size_combo;
+ GtkTreeModel *device_model, *text_dpi_model, *photo_dpi_model, *page_side_model, *paper_size_model;
+ gboolean setting_devices, user_selected_device;
+
+ Book *book;
+ BookView *book_view;
+ gboolean updating_page_menu;
+ gint default_page_width, default_page_height, default_page_dpi;
+ Orientation default_page_orientation;
+
+ gboolean have_device_list;
+
+ gchar *document_hint;
+
+ gchar *default_file_name;
+ gboolean scanning;
+
+ gint window_width, window_height;
+ gboolean window_is_maximized;
+};
+
+G_DEFINE_TYPE (SimpleScan, ui, G_TYPE_OBJECT);
+
+static struct
+{
+ const gchar *key;
+ Orientation orientation;
+} orientation_keys[] =
+{
+ { "top-to-bottom", TOP_TO_BOTTOM },
+ { "bottom-to-top", BOTTOM_TO_TOP },
+ { "left-to-right", LEFT_TO_RIGHT },
+ { "right-to-left", RIGHT_TO_LEFT },
+ { NULL, 0 }
+};
+
+
+static gboolean
+find_scan_device (SimpleScan *ui, const char *device, GtkTreeIter *iter)
+{
+ gboolean have_iter = FALSE;
+
+ if (gtk_tree_model_get_iter_first (ui->priv->device_model, iter)) {
+ do {
+ gchar *d;
+ gtk_tree_model_get (ui->priv->device_model, iter, 0, &d, -1);
+ if (strcmp (d, device) == 0)
+ have_iter = TRUE;
+ g_free (d);
+ } while (!have_iter && gtk_tree_model_iter_next (ui->priv->device_model, iter));
+ }
+
+ return have_iter;
+}
+
+
+void
+ui_set_default_file_name (SimpleScan *ui, const gchar *default_file_name)
+{
+ g_free (ui->priv->default_file_name);
+ ui->priv->default_file_name = g_strdup (default_file_name);
+}
+
+
+void
+ui_authorize (SimpleScan *ui, const gchar *resource, gchar **username, gchar **password)
+{
+ GString *description;
+
+ description = g_string_new ("");
+ g_string_printf (description,
+ /* Label in authorization dialog. '%s' is replaced with the name of the resource requesting authorization */
+ _("Username and password required to access '%s'"),
+ resource);
+
+ gtk_entry_set_text (GTK_ENTRY (ui->priv->username_entry), *username ? *username : "");
+ gtk_entry_set_text (GTK_ENTRY (ui->priv->password_entry), "");
+ gtk_label_set_text (GTK_LABEL (ui->priv->authorize_label), description->str);
+ g_string_free (description, TRUE);
+
+ gtk_widget_show (ui->priv->authorize_dialog);
+ gtk_dialog_run (GTK_DIALOG (ui->priv->authorize_dialog));
+ gtk_widget_hide (ui->priv->authorize_dialog);
+
+ *username = g_strdup (gtk_entry_get_text (GTK_ENTRY (ui->priv->username_entry)));
+ *password = g_strdup (gtk_entry_get_text (GTK_ENTRY (ui->priv->password_entry)));
+}
+
+
+void device_combo_changed_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+device_combo_changed_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (ui->priv->setting_devices)
+ return;
+ ui->priv->user_selected_device = TRUE;
+}
+
+
+void
+ui_set_scan_devices (SimpleScan *ui, GList *devices)
+{
+ GList *d;
+ gboolean have_selection = FALSE;
+ gint index;
+ GtkTreeIter iter;
+
+ ui->priv->setting_devices = TRUE;
+
+ /* If the user hasn't chosen a scanner choose the best available one */
+ if (ui->priv->user_selected_device)
+ have_selection = gtk_combo_box_get_active (GTK_COMBO_BOX (ui->priv->device_combo)) >= 0;
+
+ /* Add new devices */
+ index = 0;
+ for (d = devices; d; d = d->next) {
+ ScanDevice *device = (ScanDevice *) d->data;
+ gint n_delete = -1;
+
+ /* Find if already exists */
+ if (gtk_tree_model_iter_nth_child (ui->priv->device_model, &iter, NULL, index)) {
+ gint i = 0;
+ do {
+ gchar *name;
+ gboolean matched;
+
+ gtk_tree_model_get (ui->priv->device_model, &iter, 0, &name, -1);
+ matched = strcmp (name, device->name) == 0;
+ g_free (name);
+
+ if (matched) {
+ n_delete = i;
+ break;
+ }
+ i++;
+ } while (gtk_tree_model_iter_next (ui->priv->device_model, &iter));
+ }
+
+ /* If exists, remove elements up to this one */
+ if (n_delete >= 0) {
+ gint i;
+
+ for (i = 0; i < n_delete; i++) {
+ gtk_tree_model_iter_nth_child (ui->priv->device_model, &iter, NULL, index);
+ gtk_list_store_remove (GTK_LIST_STORE (ui->priv->device_model), &iter);
+ }
+ }
+ else {
+ gtk_list_store_insert (GTK_LIST_STORE (ui->priv->device_model), &iter, index);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->device_model), &iter, 0, device->name, 1, device->label, -1);
+ }
+ index++;
+ }
+
+ /* Remove any remaining devices */
+ while (gtk_tree_model_iter_nth_child (ui->priv->device_model, &iter, NULL, index))
+ gtk_list_store_remove (GTK_LIST_STORE (ui->priv->device_model), &iter);
+
+ /* Select the first available device */
+ if (!have_selection && devices != NULL)
+ gtk_combo_box_set_active (GTK_COMBO_BOX (ui->priv->device_combo), 0);
+
+ ui->priv->setting_devices = FALSE;
+
+ if (!ui->priv->have_device_list) {
+ ui->priv->have_device_list = TRUE;
+
+ if (!devices) {
+ ui_show_error (ui,
+ /* Warning displayed when no scanners are detected */
+ _("No scanners detected"),
+ /* Hint to user on why there are no scanners detected */
+ _("Please check your scanner is connected and powered on"),
+ FALSE);
+ }
+ }
+}
+
+
+static gchar *
+get_selected_device (SimpleScan *ui)
+{
+ GtkTreeIter iter;
+
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->device_combo), &iter)) {
+ gchar *device;
+ gtk_tree_model_get (ui->priv->device_model, &iter, 0, &device, -1);
+ return device;
+ }
+
+ return NULL;
+}
+
+
+void
+ui_set_selected_device (SimpleScan *ui, const gchar *device)
+{
+ GtkTreeIter iter;
+
+ /* If doesn't exist add with label set to device name */
+ if (!find_scan_device (ui, device, &iter)) {
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->device_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->device_model), &iter, 0, device, 1, device, -1);
+ }
+
+ gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->device_combo), &iter);
+}
+
+
+static void
+add_default_page (SimpleScan *ui)
+{
+ Page *page;
+
+ page = book_append_page (ui->priv->book,
+ ui->priv->default_page_width,
+ ui->priv->default_page_height,
+ ui->priv->default_page_dpi,
+ ui->priv->default_page_orientation);
+ book_view_select_page (ui->priv->book_view, page);
+}
+
+
+void new_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+new_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ book_clear (ui->priv->book);
+ add_default_page (ui);
+}
+
+
+static void
+set_document_hint (SimpleScan *ui, const gchar *document_hint)
+{
+ g_free (ui->priv->document_hint);
+ ui->priv->document_hint = g_strdup (document_hint);
+
+ if (strcmp (document_hint, "text") == 0) {
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->text_toolbar_menuitem), TRUE);
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->text_menu_menuitem), TRUE);
+ }
+ else if (strcmp (document_hint, "photo") == 0) {
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->photo_toolbar_menuitem), TRUE);
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ui->priv->photo_menu_menuitem), TRUE);
+ }
+}
+
+
+void text_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+text_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_document_hint (ui, "text");
+}
+
+
+void photo_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+photo_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_document_hint (ui, "photo");
+}
+
+
+static void
+set_page_side (SimpleScan *ui, const gchar *document_hint)
+{
+ GtkTreeIter iter;
+
+ if (gtk_tree_model_get_iter_first (ui->priv->page_side_model, &iter)) {
+ do {
+ gchar *d;
+ gboolean have_match;
+
+ gtk_tree_model_get (ui->priv->page_side_model, &iter, 0, &d, -1);
+ have_match = strcmp (d, document_hint) == 0;
+ g_free (d);
+
+ if (have_match) {
+ gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->page_side_combo), &iter);
+ return;
+ }
+ } while (gtk_tree_model_iter_next (ui->priv->page_side_model, &iter));
+ }
+}
+
+
+static void
+set_paper_size (SimpleScan *ui, gint width, gint height)
+{
+ GtkTreeIter iter;
+ gboolean have_iter;
+
+ for (have_iter = gtk_tree_model_get_iter_first (ui->priv->paper_size_model, &iter);
+ have_iter;
+ have_iter = gtk_tree_model_iter_next (ui->priv->paper_size_model, &iter)) {
+ gint w, h;
+
+ gtk_tree_model_get (ui->priv->paper_size_model, &iter, 0, &w, 1, &h, -1);
+ if (w == width && h == height)
+ break;
+ }
+
+ if (!have_iter)
+ have_iter = gtk_tree_model_get_iter_first (ui->priv->paper_size_model, &iter);
+ if (have_iter)
+ gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->paper_size_combo), &iter);
+}
+
+
+static gint
+get_text_dpi (SimpleScan *ui)
+{
+ GtkTreeIter iter;
+ gint dpi = DEFAULT_TEXT_DPI;
+
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->text_dpi_combo), &iter))
+ gtk_tree_model_get (ui->priv->text_dpi_model, &iter, 0, &dpi, -1);
+
+ return dpi;
+}
+
+
+static gint
+get_photo_dpi (SimpleScan *ui)
+{
+ GtkTreeIter iter;
+ gint dpi = DEFAULT_PHOTO_DPI;
+
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->photo_dpi_combo), &iter))
+ gtk_tree_model_get (ui->priv->photo_dpi_model, &iter, 0, &dpi, -1);
+
+ return dpi;
+}
+
+
+static gchar *
+get_page_side (SimpleScan *ui)
+{
+ GtkTreeIter iter;
+ gchar *mode = NULL;
+
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->page_side_combo), &iter))
+ gtk_tree_model_get (ui->priv->page_side_model, &iter, 0, &mode, -1);
+
+ return mode;
+}
+
+
+static gboolean
+get_paper_size (SimpleScan *ui, gint *width, gint *height)
+{
+ GtkTreeIter iter;
+
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (ui->priv->paper_size_combo), &iter)) {
+ gtk_tree_model_get (ui->priv->paper_size_model, &iter, 0, width, 1, height, -1);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+static ScanOptions *
+get_scan_options (SimpleScan *ui)
+{
+ struct {
+ const gchar *name;
+ ScanMode mode;
+ } profiles[] =
+ {
+ { "text", SCAN_MODE_LINEART },
+ { "photo", SCAN_MODE_COLOR },
+ { NULL, SCAN_MODE_COLOR }
+ };
+ gint i;
+ ScanOptions *options;
+
+ /* Find this profile */
+ // FIXME: Move this into scan-profile.c
+ for (i = 0; profiles[i].name && strcmp (profiles[i].name, ui->priv->document_hint) != 0; i++);
+
+ options = g_malloc0 (sizeof (ScanOptions));
+ options->scan_mode = profiles[i].mode;
+ options->depth = 8;
+ if (options->scan_mode == SCAN_MODE_COLOR)
+ options->dpi = get_photo_dpi (ui);
+ else
+ options->dpi = get_text_dpi (ui);
+ get_paper_size (ui, &options->paper_width, &options->paper_height);
+
+ return options;
+}
+
+
+void scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ gchar *device;
+ ScanOptions *options;
+
+ device = get_selected_device (ui);
+
+ options = get_scan_options (ui);
+ options->type = SCAN_SINGLE;
+ g_signal_emit (G_OBJECT (ui), signals[START_SCAN], 0, device, options);
+ g_free (device);
+ g_free (options);
+}
+
+
+void stop_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+stop_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ g_signal_emit (G_OBJECT (ui), signals[STOP_SCAN], 0);
+}
+
+
+void continuous_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+continuous_scan_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (ui->priv->scanning) {
+ g_signal_emit (G_OBJECT (ui), signals[STOP_SCAN], 0);
+ } else {
+ gchar *device, *side;
+ ScanOptions *options;
+
+ device = get_selected_device (ui);
+ options = get_scan_options (ui);
+ side = get_page_side (ui);
+ if (strcmp (side, "front") == 0)
+ options->type = SCAN_ADF_FRONT;
+ else if (strcmp (side, "back") == 0)
+ options->type = SCAN_ADF_BACK;
+ else
+ options->type = SCAN_ADF_BOTH;
+
+ g_signal_emit (G_OBJECT (ui), signals[START_SCAN], 0, device, options);
+ g_free (device);
+ g_free (side);
+ g_free (options);
+ }
+}
+
+
+void preferences_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+preferences_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ gtk_window_present (GTK_WINDOW (ui->priv->preferences_dialog));
+}
+
+
+gboolean preferences_dialog_delete_event_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+gboolean
+preferences_dialog_delete_event_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ return TRUE;
+}
+
+
+void preferences_dialog_response_cb (GtkWidget *widget, gint response_id, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+preferences_dialog_response_cb (GtkWidget *widget, gint response_id, SimpleScan *ui)
+{
+ gtk_widget_hide (ui->priv->preferences_dialog);
+}
+
+
+static void
+page_selected_cb (BookView *view, Page *page, SimpleScan *ui)
+{
+ char *name = NULL;
+
+ if (page == NULL)
+ return;
+
+ ui->priv->updating_page_menu = TRUE;
+
+ if (page_has_crop (page)) {
+ char *crop_name;
+
+ // FIXME: Make more generic, move into page-size.c and reuse
+ crop_name = page_get_named_crop (page);
+ if (crop_name) {
+ if (strcmp (crop_name, "A4") == 0)
+ name = "a4_menuitem";
+ else if (strcmp (crop_name, "A5") == 0)
+ name = "a5_menuitem";
+ else if (strcmp (crop_name, "A6") == 0)
+ name = "a6_menuitem";
+ else if (strcmp (crop_name, "letter") == 0)
+ name = "letter_menuitem";
+ else if (strcmp (crop_name, "legal") == 0)
+ name = "legal_menuitem";
+ else if (strcmp (crop_name, "4x6") == 0)
+ name = "4x6_menuitem";
+ g_free (crop_name);
+ }
+ else
+ name = "custom_crop_menuitem";
+ }
+ else
+ name = "no_crop_menuitem";
+
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (ui->priv->builder, name)), TRUE);
+ gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (gtk_builder_get_object (ui->priv->builder, "crop_toolbutton")), page_has_crop (page));
+
+ ui->priv->updating_page_menu = FALSE;
+}
+
+
+// FIXME: Duplicated from simple-scan.c
+static gchar *
+get_temporary_filename (const gchar *prefix, const gchar *extension)
+{
+ gint fd;
+ gchar *filename, *path;
+ GError *error = NULL;
+
+ /* NOTE: I'm not sure if this is a 100% safe strategy to use g_file_open_tmp(), close and
+ * use the filename but it appears to work in practise */
+
+ filename = g_strdup_printf ("%s-XXXXXX.%s", prefix, extension);
+ fd = g_file_open_tmp (filename, &path, &error);
+ g_free (filename);
+ if (fd < 0) {
+ g_warning ("Error saving page for viewing: %s", error->message);
+ g_clear_error (&error);
+ return NULL;
+ }
+ close (fd);
+
+ return path;
+}
+
+
+static void
+show_page_cb (BookView *view, Page *page, SimpleScan *ui)
+{
+ gchar *path;
+ GFile *file;
+ GdkScreen *screen;
+ GError *error = NULL;
+
+ path = get_temporary_filename ("scanned-page", "tiff");
+ if (!path)
+ return;
+ file = g_file_new_for_path (path);
+ g_free (path);
+
+ screen = gtk_widget_get_screen (GTK_WIDGET (ui->priv->window));
+
+ if (page_save (page, "tiff", file, &error)) {
+ gchar *uri = g_file_get_uri (file);
+ gtk_show_uri (screen, uri, gtk_get_current_event_time (), &error);
+ g_free (uri);
+ }
+
+ g_object_unref (file);
+
+ if (error) {
+ ui_show_error (ui,
+ /* Error message display when unable to preview image */
+ _("Unable to open image preview application"),
+ error->message,
+ FALSE);
+ g_clear_error (&error);
+ }
+}
+
+
+void rotate_left_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+rotate_left_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ Page *page;
+
+ if (ui->priv->updating_page_menu)
+ return;
+ page = book_view_get_selected (ui->priv->book_view);
+ page_rotate_left (page);
+}
+
+
+void rotate_right_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+rotate_right_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ Page *page;
+
+ if (ui->priv->updating_page_menu)
+ return;
+ page = book_view_get_selected (ui->priv->book_view);
+ page_rotate_right (page);
+}
+
+
+static void
+set_crop (SimpleScan *ui, const gchar *crop_name)
+{
+ Page *page;
+
+ gtk_widget_set_sensitive (ui->priv->crop_rotate_menuitem, crop_name != NULL);
+
+ if (ui->priv->updating_page_menu)
+ return;
+
+ page = book_view_get_selected (ui->priv->book_view);
+ if (!page)
+ return;
+
+ if (!crop_name) {
+ page_set_no_crop (page);
+ return;
+ }
+
+ if (strcmp (crop_name, "custom") == 0) {
+ gint width, height, crop_width, crop_height;
+
+ width = page_get_width (page);
+ height = page_get_height (page);
+
+ crop_width = (int) (width * 0.8 + 0.5);
+ crop_height = (int) (height * 0.8 + 0.5);
+ page_set_custom_crop (page, crop_width, crop_height);
+ page_move_crop (page, (width - crop_width) / 2, (height - crop_height) / 2);
+
+ return;
+ }
+
+ page_set_named_crop (page, crop_name);
+}
+
+
+void no_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+no_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, NULL);
+}
+
+
+void custom_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+custom_crop_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, "custom");
+}
+
+void crop_toolbutton_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+crop_toolbutton_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (ui->priv->updating_page_menu)
+ return;
+
+ if (gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (widget)))
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (ui->priv->builder, "custom_crop_menuitem")), TRUE);
+ else
+ gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_builder_get_object (ui->priv->builder, "no_crop_menuitem")), TRUE);
+}
+
+
+void four_by_six_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+four_by_six_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, "4x6");
+}
+
+
+void legal_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+legal_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, "legal");
+}
+
+
+void letter_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+letter_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, "letter");
+}
+
+
+void a6_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+a6_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, "A6");
+}
+
+
+void a5_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+a5_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, "A5");
+}
+
+
+void a4_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+a4_menuitem_toggled_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)))
+ set_crop (ui, "A4");
+}
+
+
+void crop_rotate_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+crop_rotate_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ Page *page;
+
+ page = book_view_get_selected (ui->priv->book_view);
+ if (!page)
+ return;
+
+ page_rotate_crop (page);
+}
+
+
+void page_delete_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+page_delete_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ book_delete_page (book_view_get_book (ui->priv->book_view),
+ book_view_get_selected (ui->priv->book_view));
+}
+
+
+static void
+on_file_type_changed (GtkTreeSelection *selection, GtkWidget *dialog)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gchar *path, *filename, *extension, *new_filename;
+
+ if (!gtk_tree_selection_get_selected (selection, &model, &iter))
+ return;
+
+ gtk_tree_model_get (model, &iter, 1, &extension, -1);
+ path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+ filename = g_path_get_basename (path);
+
+ /* Replace extension */
+ if (g_strrstr (filename, "."))
+ new_filename = g_strdup_printf ("%.*s%s", (int)(g_strrstr (filename, ".") - filename), filename, extension);
+ else
+ new_filename = g_strdup_printf ("%s%s", filename, extension);
+ gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), new_filename);
+
+ g_free (path);
+ g_free (filename);
+ g_free (new_filename);
+ g_free (extension);
+}
+
+
+void save_file_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+save_file_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ GtkWidget *dialog;
+ gint response;
+ GtkFileFilter *filter;
+ GtkWidget *expander, *file_type_view;
+ GtkListStore *file_type_store;
+ GtkTreeIter iter;
+ GtkTreeViewColumn *column;
+ const gchar *extension;
+ gchar *directory;
+ gint i;
+
+ struct
+ {
+ gchar *label, *extension;
+ } file_types[] =
+ {
+ /* Save dialog: Label for saving in PDF format */
+ { _("PDF (multi-page document)"), ".pdf" },
+ /* Save dialog: Label for saving in JPEG format */
+ { _("JPEG (compressed)"), ".jpg" },
+ /* Save dialog: Label for saving in PNG format */
+ { _("PNG (lossless)"), ".png" },
+ { NULL, NULL }
+ };
+
+ /* Get directory to save to */
+ directory = gconf_client_get_string (ui->priv->client, GCONF_DIR "/save_directory", NULL);
+ if (!directory || directory[0] == '\0') {
+ g_free (directory);
+ directory = g_strdup (g_get_user_special_dir (G_USER_DIRECTORY_DOCUMENTS));
+ }
+
+ dialog = gtk_file_chooser_dialog_new (/* Save dialog: Dialog title */
+ _("Save As..."),
+ GTK_WINDOW (ui->priv->window),
+ GTK_FILE_CHOOSER_ACTION_SAVE,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+ NULL);
+ gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
+ gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
+ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), directory);
+ gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), ui->priv->default_file_name);
+ g_free (directory);
+
+ /* Filter to only show images by default */
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name (filter,
+ /* Save dialog: Filter name to show only image files */
+ _("Image Files"));
+ gtk_file_filter_add_pixbuf_formats (filter);
+ gtk_file_filter_add_mime_type (filter, "application/pdf");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
+ filter = gtk_file_filter_new ();
+ gtk_file_filter_set_name (filter,
+ /* Save dialog: Filter name to show all files */
+ _("All Files"));
+ gtk_file_filter_add_pattern (filter, "*");
+ gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
+
+ expander = gtk_expander_new_with_mnemonic (/* */
+ _("Select File _Type"));
+ gtk_expander_set_spacing (GTK_EXPANDER (expander), 5);
+ gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), expander);
+
+ extension = strstr (ui->priv->default_file_name, ".");
+ if (!extension)
+ extension = "";
+
+ file_type_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
+ for (i = 0; file_types[i].label; i++) {
+ gtk_list_store_append (file_type_store, &iter);
+ gtk_list_store_set (file_type_store, &iter, 0, file_types[i].label, 1, file_types[i].extension, -1);
+ }
+
+ file_type_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (file_type_store));
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (file_type_view), FALSE);
+ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (file_type_view), TRUE);
+ column = gtk_tree_view_column_new_with_attributes ("",
+ gtk_cell_renderer_text_new (),
+ "text", 0, NULL);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (file_type_view), column);
+ gtk_container_add (GTK_CONTAINER (expander), file_type_view);
+
+ if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (file_type_store), &iter)) {
+ do {
+ gchar *e;
+ gtk_tree_model_get (GTK_TREE_MODEL (file_type_store), &iter, 1, &e, -1);
+ if (strcmp (extension, e) == 0)
+ gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (file_type_view)), &iter);
+ g_free (e);
+ } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (file_type_store), &iter));
+ }
+ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (file_type_view)),
+ "changed",
+ G_CALLBACK (on_file_type_changed),
+ dialog);
+
+ gtk_widget_show_all (expander);
+
+ response = gtk_dialog_run (GTK_DIALOG (dialog));
+ if (response == GTK_RESPONSE_ACCEPT) {
+ gchar *uri;
+
+ uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
+ g_signal_emit (G_OBJECT (ui), signals[SAVE], 0, uri);
+
+ g_free (uri);
+ }
+
+ gconf_client_set_string (ui->priv->client, GCONF_DIR "/save_directory",
+ gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)),
+ NULL);
+
+ gtk_widget_destroy (dialog);
+}
+
+
+static void
+draw_page (GtkPrintOperation *operation,
+ GtkPrintContext *print_context,
+ gint page_number,
+ SimpleScan *ui)
+{
+ cairo_t *context;
+ Page *page;
+ GdkPixbuf *image;
+ gboolean is_landscape = FALSE;
+
+ context = gtk_print_context_get_cairo_context (print_context);
+
+ page = book_get_page (ui->priv->book, page_number);
+
+ /* Rotate to same aspect */
+ if (gtk_print_context_get_width (print_context) > gtk_print_context_get_height (print_context))
+ is_landscape = TRUE;
+ if (page_is_landscape (page) != is_landscape) {
+ cairo_translate (context, gtk_print_context_get_width (print_context), 0);
+ cairo_rotate (context, M_PI_2);
+ }
+
+ cairo_scale (context,
+ gtk_print_context_get_dpi_x (print_context) / page_get_dpi (page),
+ gtk_print_context_get_dpi_y (print_context) / page_get_dpi (page));
+
+ image = page_get_cropped_image (page);
+ gdk_cairo_set_source_pixbuf (context, image, 0, 0);
+ cairo_paint (context);
+
+ g_object_unref (image);
+}
+
+
+void email_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+email_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ g_signal_emit (G_OBJECT (ui), signals[EMAIL], 0, ui->priv->document_hint);
+}
+
+
+void print_button_clicked_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+print_button_clicked_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ GtkPrintOperation *print;
+ GtkPrintOperationResult result;
+ GError *error = NULL;
+
+ print = gtk_print_operation_new ();
+ gtk_print_operation_set_n_pages (print, book_get_n_pages (ui->priv->book));
+ g_signal_connect (print, "draw-page", G_CALLBACK (draw_page), ui);
+
+ result = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
+ GTK_WINDOW (ui->priv->window), &error);
+
+ g_object_unref (print);
+}
+
+
+void help_contents_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+help_contents_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ GdkScreen *screen;
+ GError *error = NULL;
+
+ screen = gtk_widget_get_screen (GTK_WIDGET (ui->priv->window));
+ gtk_show_uri (screen, "ghelp:simple-scan", gtk_get_current_event_time (), &error);
+
+ if (error)
+ {
+ ui_show_error (ui,
+ /* Error message displayed when unable to launch help browser */
+ _("Unable to open help file"),
+ error->message,
+ FALSE);
+ g_clear_error (&error);
+ }
+}
+
+
+void about_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+about_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ const gchar *authors[] = { "Robert Ancell <robert.ancell@canonical.com>", NULL };
+
+ /* The license this software is under (GPL3+) */
+ const char *license = _("This program is free software: you can redistribute it and/or modify\n"
+ "it under the terms of the GNU General Public License as published by\n"
+ "the Free Software Foundation, either version 3 of the License, or\n"
+ "(at your option) any later version.\n"
+ "\n"
+ "This program is distributed in the hope that it will be useful,\n"
+ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
+ "GNU General Public License for more details.\n"
+ "\n"
+ "You should have received a copy of the GNU General Public License\n"
+ "along with this program. If not, see <http://www.gnu.org/licenses/>.");
+
+ /* Title of about dialog */
+ const char *title = _("About Simple Scan");
+
+ /* Description of program */
+ const char *description = _("Simple document scanning tool");
+
+ gtk_show_about_dialog (GTK_WINDOW (ui->priv->window),
+ "title", title,
+ "program-name", "Simple Scan",
+ "version", VERSION,
+ "comments", description,
+ "logo-icon-name", "scanner",
+ "authors", authors,
+ "translator-credits", _("translator-credits"),
+ "website", "https://launchpad.net/simple-scan",
+ "copyright", "Copyright © 2009 Canonical Ltd.",
+ "license", license,
+ "wrap-license", TRUE,
+ NULL);
+}
+
+
+static void
+quit (SimpleScan *ui)
+{
+ char *device;
+ gint paper_width = 0, paper_height = 0;
+ gint i;
+
+ // FIXME: Warn if document with unsaved changes
+
+ device = get_selected_device (ui);
+ if (device) {
+ gconf_client_set_string(ui->priv->client, GCONF_DIR "/selected_device", device, NULL);
+ g_free (device);
+ }
+
+ gconf_client_set_string (ui->priv->client, GCONF_DIR "/document_type", ui->priv->document_hint, NULL);
+ gconf_client_set_int (ui->priv->client, GCONF_DIR "/text_dpi", get_text_dpi (ui), NULL);
+ gconf_client_set_int (ui->priv->client, GCONF_DIR "/photo_dpi", get_photo_dpi (ui), NULL);
+ gconf_client_set_string (ui->priv->client, GCONF_DIR "/page_side", get_page_side (ui), NULL);
+ get_paper_size (ui, &paper_width, &paper_height);
+ gconf_client_set_int (ui->priv->client, GCONF_DIR "/paper_width", paper_width, NULL);
+ gconf_client_set_int (ui->priv->client, GCONF_DIR "/paper_height", paper_height, NULL);
+
+ gconf_client_set_int(ui->priv->client, GCONF_DIR "/window_width", ui->priv->window_width, NULL);
+ gconf_client_set_int(ui->priv->client, GCONF_DIR "/window_height", ui->priv->window_height, NULL);
+ gconf_client_set_bool(ui->priv->client, GCONF_DIR "/window_is_maximized", ui->priv->window_is_maximized, NULL);
+
+ for (i = 0; orientation_keys[i].key != NULL && orientation_keys[i].orientation != ui->priv->default_page_orientation; i++);
+ if (orientation_keys[i].key != NULL)
+ gconf_client_set_string(ui->priv->client, GCONF_DIR "/scan_direction", orientation_keys[i].key, NULL);
+ gconf_client_set_int (ui->priv->client, GCONF_DIR "/page_width", ui->priv->default_page_width, NULL);
+ gconf_client_set_int (ui->priv->client, GCONF_DIR "/page_height", ui->priv->default_page_height, NULL);
+ gconf_client_set_int (ui->priv->client, GCONF_DIR "/page_dpi", ui->priv->default_page_dpi, NULL);
+
+ g_signal_emit (G_OBJECT (ui), signals[QUIT], 0);
+}
+
+
+void quit_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui);
+G_MODULE_EXPORT
+void
+quit_menuitem_activate_cb (GtkWidget *widget, SimpleScan *ui)
+{
+ quit (ui);
+}
+
+
+gboolean simple_scan_window_configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, SimpleScan *ui);
+G_MODULE_EXPORT
+gboolean
+simple_scan_window_configure_event_cb (GtkWidget *widget, GdkEventConfigure *event, SimpleScan *ui)
+{
+ if (!ui->priv->window_is_maximized) {
+ ui->priv->window_width = event->width;
+ ui->priv->window_height = event->height;
+ }
+
+ return FALSE;
+}
+
+
+gboolean simple_scan_window_window_state_event_cb (GtkWidget *widget, GdkEventWindowState *event, SimpleScan *ui);
+G_MODULE_EXPORT
+gboolean
+simple_scan_window_window_state_event_cb (GtkWidget *widget, GdkEventWindowState *event, SimpleScan *ui)
+{
+ if (event->changed_mask & GDK_WINDOW_STATE_MAXIMIZED)
+ ui->priv->window_is_maximized = (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
+ return FALSE;
+}
+
+
+gboolean window_delete_event_cb (GtkWidget *widget, GdkEvent *event, SimpleScan *ui);
+G_MODULE_EXPORT
+gboolean
+window_delete_event_cb (GtkWidget *widget, GdkEvent *event, SimpleScan *ui)
+{
+ quit (ui);
+ return TRUE;
+}
+
+
+static void
+page_size_changed_cb (Page *page, SimpleScan *ui)
+{
+ ui->priv->default_page_width = page_get_width (page);
+ ui->priv->default_page_height = page_get_height (page);
+ ui->priv->default_page_dpi = page_get_dpi (page);
+}
+
+
+static void
+page_orientation_changed_cb (Page *page, SimpleScan *ui)
+{
+ ui->priv->default_page_orientation = page_get_orientation (page);
+}
+
+
+static void
+page_added_cb (Book *book, Page *page, SimpleScan *ui)
+{
+ ui->priv->default_page_width = page_get_width (page);
+ ui->priv->default_page_height = page_get_height (page);
+ ui->priv->default_page_dpi = page_get_dpi (page);
+ ui->priv->default_page_orientation = page_get_orientation (page);
+ g_signal_connect (page, "size-changed", G_CALLBACK (page_size_changed_cb), ui);
+ g_signal_connect (page, "orientation-changed", G_CALLBACK (page_orientation_changed_cb), ui);
+}
+
+
+static void
+page_removed_cb (Book *book, Page *page, SimpleScan *ui)
+{
+ /* If this is the last page add a new blank one */
+ if (book_get_n_pages (ui->priv->book) == 1)
+ add_default_page (ui);
+}
+
+
+static void
+set_dpi_combo (GtkWidget *combo, gint default_dpi, gint current_dpi)
+{
+ struct
+ {
+ gint dpi;
+ const gchar *label;
+ } scan_resolutions[] =
+ {
+ /* Preferences dialog: Label for minimum resolution in resolution list */
+ { 75, _("%d dpi (draft)") },
+ /* Preferences dialog: Label for resolution value in resolution list (dpi = dots per inch) */
+ { 150, _("%d dpi") },
+ { 300, _("%d dpi") },
+ { 600, _("%d dpi") },
+ /* Preferences dialog: Label for maximum resolution in resolution list */
+ { 1200, _("%d dpi (high resolution)") },
+ { 2400, _("%d dpi") },
+ { -1, NULL }
+ };
+ GtkCellRenderer *renderer;
+ GtkTreeModel *model;
+ gint i;
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", 1);
+
+ model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
+ for (i = 0; scan_resolutions[i].dpi > 0; i++)
+ {
+ GtkTreeIter iter;
+ gchar *label;
+ gint dpi;
+
+ dpi = scan_resolutions[i].dpi;
+
+ if (dpi == default_dpi)
+ label = g_strdup_printf (/* Preferences dialog: Label for default resolution in resolution list */
+ _("%d dpi (default)"), dpi);
+ else
+ label = g_strdup_printf (scan_resolutions[i].label, dpi);
+
+ gtk_list_store_append (GTK_LIST_STORE (model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, dpi, 1, label, -1);
+
+ if (dpi == current_dpi)
+ gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter);
+
+ g_free (label);
+ }
+}
+
+
+static void
+ui_load (SimpleScan *ui)
+{
+ GtkBuilder *builder;
+ GError *error = NULL;
+ GtkCellRenderer *renderer;
+ gchar *device, *document_type, *scan_direction, *page_side;
+ gint dpi, paper_width, paper_height;
+
+ gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), ICON_DIR);
+
+ gtk_window_set_default_icon_name ("scanner");
+
+ builder = ui->priv->builder = gtk_builder_new ();
+ gtk_builder_add_from_file (builder, UI_DIR "simple-scan.ui", &error);
+ if (error) {
+ g_critical ("Unable to load UI: %s\n", error->message);
+ ui_show_error (ui,
+ /* Title of dialog when cannot load required files */
+ _("Files missing"),
+ /* Description in dialog when cannot load required files */
+ _("Please check your installation"),
+ FALSE);
+ exit (1);
+ }
+ gtk_builder_connect_signals (builder, ui);
+
+ ui->priv->window = GTK_WIDGET (gtk_builder_get_object (builder, "simple_scan_window"));
+ ui->priv->preview_box = GTK_WIDGET (gtk_builder_get_object (builder, "preview_vbox"));
+ ui->priv->preview_area = GTK_WIDGET (gtk_builder_get_object (builder, "preview_area"));
+ ui->priv->preview_scroll = GTK_WIDGET (gtk_builder_get_object (builder, "preview_scrollbar"));
+ ui->priv->page_delete_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "page_delete_menuitem"));
+ ui->priv->crop_rotate_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "crop_rotate_menuitem"));
+ ui->priv->stop_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "stop_scan_menuitem"));
+ ui->priv->stop_toolbutton = GTK_WIDGET (gtk_builder_get_object (builder, "stop_toolbutton"));
+
+ ui->priv->text_toolbar_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "text_toolbutton_menuitem"));
+ ui->priv->text_menu_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "text_menuitem"));
+ ui->priv->photo_toolbar_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "photo_toolbutton_menuitem"));
+ ui->priv->photo_menu_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "photo_menuitem"));
+
+ ui->priv->authorize_dialog = GTK_WIDGET (gtk_builder_get_object (builder, "authorize_dialog"));
+ ui->priv->authorize_label = GTK_WIDGET (gtk_builder_get_object (builder, "authorize_label"));
+ ui->priv->username_entry = GTK_WIDGET (gtk_builder_get_object (builder, "username_entry"));
+ ui->priv->password_entry = GTK_WIDGET (gtk_builder_get_object (builder, "password_entry"));
+
+ ui->priv->preferences_dialog = GTK_WIDGET (gtk_builder_get_object (builder, "preferences_dialog"));
+ ui->priv->device_combo = GTK_WIDGET (gtk_builder_get_object (builder, "device_combo"));
+ ui->priv->device_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->device_combo));
+ ui->priv->text_dpi_combo = GTK_WIDGET (gtk_builder_get_object (builder, "text_dpi_combo"));
+ ui->priv->text_dpi_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->text_dpi_combo));
+ ui->priv->photo_dpi_combo = GTK_WIDGET (gtk_builder_get_object (builder, "photo_dpi_combo"));
+ ui->priv->photo_dpi_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->photo_dpi_combo));
+ ui->priv->page_side_combo = GTK_WIDGET (gtk_builder_get_object (builder, "page_side_combo"));
+ ui->priv->page_side_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->page_side_combo));
+ ui->priv->paper_size_combo = GTK_WIDGET (gtk_builder_get_object (builder, "paper_size_combo"));
+ ui->priv->paper_size_model = gtk_combo_box_get_model (GTK_COMBO_BOX (ui->priv->paper_size_combo));
+
+ GtkTreeIter iter;
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 0, 1, 0, 2, "Automatic", -1);
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 2050, 1, 1480, 2, "A6", -1);
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 1480, 1, 2100, 2, "A5", -1);
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 2100, 1, 1970, 2, "A4", -1);
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 2159, 1, 2794, 2, "Letter", -1);
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 2159, 1, 3556, 2, "Legal", -1);
+ gtk_list_store_append (GTK_LIST_STORE (ui->priv->paper_size_model), &iter);
+ gtk_list_store_set (GTK_LIST_STORE (ui->priv->paper_size_model), &iter, 0, 1016, 1, 1524, 2, "4×6", -1);
+
+ dpi = gconf_client_get_int (ui->priv->client, GCONF_DIR "/text_dpi", NULL);
+ if (dpi <= 0)
+ dpi = DEFAULT_TEXT_DPI;
+ set_dpi_combo (ui->priv->text_dpi_combo, DEFAULT_TEXT_DPI, dpi);
+ dpi = gconf_client_get_int (ui->priv->client, GCONF_DIR "/photo_dpi", NULL);
+ if (dpi <= 0)
+ dpi = DEFAULT_PHOTO_DPI;
+ set_dpi_combo (ui->priv->photo_dpi_combo, DEFAULT_PHOTO_DPI, dpi);
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->priv->device_combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (ui->priv->device_combo), renderer, "text", 1);
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->priv->page_side_combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (ui->priv->page_side_combo), renderer, "text", 1);
+ page_side = gconf_client_get_string (ui->priv->client, GCONF_DIR "/page_side", NULL);
+ if (page_side) {
+ set_page_side (ui, page_side);
+ g_free (page_side);
+ }
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ui->priv->paper_size_combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (ui->priv->paper_size_combo), renderer, "text", 2);
+ paper_width = gconf_client_get_int (ui->priv->client, GCONF_DIR "/paper_width", NULL);
+ paper_height = gconf_client_get_int (ui->priv->client, GCONF_DIR "/paper_height", NULL);
+ set_paper_size (ui, paper_width, paper_height);
+
+ device = gconf_client_get_string (ui->priv->client, GCONF_DIR "/selected_device", NULL);
+ if (device) {
+ GtkTreeIter iter;
+ if (find_scan_device (ui, device, &iter))
+ gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ui->priv->device_combo), &iter);
+ g_free (device);
+ }
+
+ document_type = gconf_client_get_string (ui->priv->client, GCONF_DIR "/document_type", NULL);
+ if (document_type) {
+ set_document_hint (ui, document_type);
+ g_free (document_type);
+ }
+
+ ui->priv->book_view = book_view_new ();
+ g_signal_connect (ui->priv->book_view, "page-selected", G_CALLBACK (page_selected_cb), ui);
+ g_signal_connect (ui->priv->book_view, "show-page", G_CALLBACK (show_page_cb), ui);
+ book_view_set_widgets (ui->priv->book_view,
+ ui->priv->preview_box,
+ ui->priv->preview_area,
+ ui->priv->preview_scroll,
+ GTK_WIDGET (gtk_builder_get_object (builder, "page_menu")));
+
+ /* Find default page details */
+ scan_direction = gconf_client_get_string(ui->priv->client, GCONF_DIR "/scan_direction", NULL);
+ ui->priv->default_page_orientation = TOP_TO_BOTTOM;
+ if (scan_direction) {
+ gint i;
+ for (i = 0; orientation_keys[i].key != NULL && strcmp (orientation_keys[i].key, scan_direction) != 0; i++);
+ if (orientation_keys[i].key != NULL)
+ ui->priv->default_page_orientation = orientation_keys[i].orientation;
+ g_free (scan_direction);
+ }
+ ui->priv->default_page_width = gconf_client_get_int (ui->priv->client, GCONF_DIR "/page_width", NULL);
+ if (ui->priv->default_page_width <= 0)
+ ui->priv->default_page_width = 595;
+ ui->priv->default_page_height = gconf_client_get_int (ui->priv->client, GCONF_DIR "/page_height", NULL);
+ if (ui->priv->default_page_height <= 0)
+ ui->priv->default_page_height = 842;
+ ui->priv->default_page_dpi = gconf_client_get_int (ui->priv->client, GCONF_DIR "/page_dpi", NULL);
+ if (ui->priv->default_page_dpi <= 0)
+ ui->priv->default_page_dpi = 72;
+
+ /* Restore window size */
+ ui->priv->window_width = gconf_client_get_int (ui->priv->client, GCONF_DIR "/window_width", NULL);
+ if (ui->priv->window_width <= 0)
+ ui->priv->window_width = 600;
+ ui->priv->window_height = gconf_client_get_int (ui->priv->client, GCONF_DIR "/window_height", NULL);
+ if (ui->priv->window_height <= 0)
+ ui->priv->window_height = 400;
+ g_debug ("Restoring window to %dx%d pixels", ui->priv->window_width, ui->priv->window_height);
+ gtk_window_set_default_size (GTK_WINDOW (ui->priv->window), ui->priv->window_width, ui->priv->window_height);
+ ui->priv->window_is_maximized = gconf_client_get_bool (ui->priv->client, GCONF_DIR "/window_is_maximized", NULL);
+ if (ui->priv->window_is_maximized) {
+ g_debug ("Restoring window to maximized");
+ gtk_window_maximize (GTK_WINDOW (ui->priv->window));
+ }
+
+ if (book_get_n_pages (ui->priv->book) == 0)
+ add_default_page (ui);
+ book_view_set_book (ui->priv->book_view, ui->priv->book);
+}
+
+
+SimpleScan *
+ui_new ()
+{
+ return g_object_new (SIMPLE_SCAN_TYPE, NULL);
+}
+
+
+Book *
+ui_get_book (SimpleScan *ui)
+{
+ return g_object_ref (ui->priv->book);
+}
+
+
+void
+ui_set_selected_page (SimpleScan *ui, Page *page)
+{
+ book_view_select_page (ui->priv->book_view, page);
+}
+
+
+Page *
+ui_get_selected_page (SimpleScan *ui)
+{
+ return book_view_get_selected (ui->priv->book_view);
+}
+
+
+void
+ui_set_scanning (SimpleScan *ui, gboolean scanning)
+{
+ ui->priv->scanning = scanning;
+ gtk_widget_set_sensitive (ui->priv->page_delete_menuitem, !scanning);
+ gtk_widget_set_sensitive (ui->priv->stop_menuitem, scanning);
+ gtk_widget_set_sensitive (ui->priv->stop_toolbutton, scanning);
+}
+
+
+void
+ui_show_error (SimpleScan *ui, const gchar *error_title, const gchar *error_text, gboolean change_scanner_hint)
+{
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new (GTK_WINDOW (ui->priv->window),
+ GTK_DIALOG_MODAL,
+ GTK_MESSAGE_WARNING,
+ GTK_BUTTONS_NONE,
+ "%s", error_title);
+ if (change_scanner_hint)
+ gtk_dialog_add_button (GTK_DIALOG (dialog),
+ /* Button in error dialog to open prefereces dialog and change scanner */
+ _("Change _Scanner"),
+ 1);
+ gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, 0);
+ gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+ "%s", error_text);
+
+ if (gtk_dialog_run (GTK_DIALOG (dialog)) == 1) {
+ gtk_widget_grab_focus (ui->priv->device_combo);
+ gtk_window_present (GTK_WINDOW (ui->priv->preferences_dialog));
+ }
+
+ gtk_widget_destroy (dialog);
+}
+
+
+void
+ui_start (SimpleScan *ui)
+{
+ gtk_widget_show (ui->priv->window);
+}
+
+
+/* Generated with glib-genmarshal */
+static void
+g_cclosure_user_marshal_VOID__STRING_POINTER (GClosure *closure,
+ GValue *return_value G_GNUC_UNUSED,
+ guint n_param_values,
+ const GValue *param_values,
+ gpointer invocation_hint G_GNUC_UNUSED,
+ gpointer marshal_data)
+{
+ typedef void (*GMarshalFunc_VOID__STRING_POINTER) (gpointer data1,
+ gconstpointer arg_1,
+ gconstpointer arg_2,
+ gpointer data2);
+ register GMarshalFunc_VOID__STRING_POINTER callback;
+ register GCClosure *cc = (GCClosure*) closure;
+ register gpointer data1, data2;
+
+ g_return_if_fail (n_param_values == 3);
+
+ if (G_CCLOSURE_SWAP_DATA (closure))
+ {
+ data1 = closure->data;
+ data2 = g_value_peek_pointer (param_values + 0);
+ }
+ else
+ {
+ data1 = g_value_peek_pointer (param_values + 0);
+ data2 = closure->data;
+ }
+ callback = (GMarshalFunc_VOID__STRING_POINTER) (marshal_data ? marshal_data : cc->callback);
+
+ callback (data1,
+ g_value_get_string (param_values + 1),
+ g_value_get_pointer (param_values + 2),
+ data2);
+}
+
+
+static void
+ui_finalize (GObject *object)
+{
+ SimpleScan *ui = SIMPLE_SCAN (object);
+
+ g_object_unref (ui->priv->client);
+ ui->priv->client = NULL;
+ g_object_unref (ui->priv->builder);
+ ui->priv->builder = NULL;
+ g_object_unref (ui->priv->book);
+ ui->priv->book = NULL;
+ g_object_unref (ui->priv->book_view);
+ ui->priv->book_view = NULL;
+
+ G_OBJECT_CLASS (ui_parent_class)->finalize (object);
+}
+
+
+static void
+ui_class_init (SimpleScanClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = ui_finalize;
+
+ signals[START_SCAN] =
+ g_signal_new ("start-scan",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (SimpleScanClass, start_scan),
+ NULL, NULL,
+ g_cclosure_user_marshal_VOID__STRING_POINTER,
+ G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_POINTER);
+ signals[STOP_SCAN] =
+ g_signal_new ("stop-scan",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (SimpleScanClass, stop_scan),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[SAVE] =
+ g_signal_new ("save",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (SimpleScanClass, save),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[EMAIL] =
+ g_signal_new ("email",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (SimpleScanClass, email),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__STRING,
+ G_TYPE_NONE, 1, G_TYPE_STRING);
+ signals[QUIT] =
+ g_signal_new ("quit",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (SimpleScanClass, quit),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ g_type_class_add_private (klass, sizeof (SimpleScanPrivate));
+}
+
+
+static void
+ui_init (SimpleScan *ui)
+{
+ ui->priv = G_TYPE_INSTANCE_GET_PRIVATE (ui, SIMPLE_SCAN_TYPE, SimpleScanPrivate);
+
+ ui->priv->book = book_new ();
+ g_signal_connect (ui->priv->book, "page-removed", G_CALLBACK (page_removed_cb), ui);
+ g_signal_connect (ui->priv->book, "page-added", G_CALLBACK (page_added_cb), ui);
+
+ ui->priv->client = gconf_client_get_default();
+ gconf_client_add_dir(ui->priv->client, GCONF_DIR, GCONF_CLIENT_PRELOAD_NONE, NULL);
+
+ ui->priv->document_hint = g_strdup ("photo");
+ ui->priv->default_file_name = g_strdup (_("Scanned Document.pdf"));
+ ui->priv->scanning = FALSE;
+ ui_load (ui);
+}