diff options
Diffstat (limited to 'src/ui.c')
| -rw-r--r-- | src/ui.c | 1648 |
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); +} |