diff options
Diffstat (limited to 'src/ui.vala')
| -rw-r--r-- | src/ui.vala | 1458 |
1 files changed, 1458 insertions, 0 deletions
diff --git a/src/ui.vala b/src/ui.vala new file mode 100644 index 0000000..4287d13 --- /dev/null +++ b/src/ui.vala @@ -0,0 +1,1458 @@ +/* + * Copyright (C) 2009-2011 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. + */ + +public class SimpleScan +{ + private const int DEFAULT_TEXT_DPI = 150; + private const int DEFAULT_PHOTO_DPI = 300; + + private Settings settings; + + private Gtk.Builder builder; + + private Gtk.Window window; + private Gtk.VBox main_vbox; + private Gtk.InfoBar info_bar; + private Gtk.Image info_bar_image; + private Gtk.Label info_bar_label; + private Gtk.Button info_bar_close_button; + private Gtk.Button info_bar_change_scanner_button; + private Gtk.MenuItem page_move_left_menuitem; + private Gtk.MenuItem page_move_right_menuitem; + private Gtk.MenuItem page_delete_menuitem; + private Gtk.MenuItem crop_rotate_menuitem; + private Gtk.MenuItem save_menuitem; + private Gtk.MenuItem save_as_menuitem; + private Gtk.ToolButton save_toolbutton; + private Gtk.MenuItem stop_menuitem; + private Gtk.ToolButton stop_toolbutton; + + private Gtk.RadioMenuItem text_toolbar_menuitem; + private Gtk.RadioMenuItem text_menu_menuitem; + private Gtk.RadioMenuItem photo_toolbar_menuitem; + private Gtk.RadioMenuItem photo_menu_menuitem; + + private Gtk.Dialog authorize_dialog; + private Gtk.Label authorize_label; + private Gtk.Entry username_entry; + private Gtk.Entry password_entry; + + private Gtk.Dialog preferences_dialog; + private Gtk.ComboBox device_combo; + private Gtk.ComboBox text_dpi_combo; + private Gtk.ComboBox photo_dpi_combo; + private Gtk.ComboBox page_side_combo; + private Gtk.ComboBox paper_size_combo; + private Gtk.ListStore device_model; + private Gtk.ListStore text_dpi_model; + private Gtk.ListStore photo_dpi_model; + private Gtk.ListStore page_side_model; + private Gtk.ListStore paper_size_model; + private bool setting_devices; + private bool user_selected_device; + + private Gtk.FileChooserDialog? save_dialog; + + private bool have_error; + private string error_title; + private string error_text; + private bool error_change_scanner_hint; + + private Book book; + private string? book_uri = null; + + private BookView book_view; + private bool updating_page_menu; + private int default_page_width; + private int default_page_height; + private int default_page_dpi; + private ScanDirection default_page_scan_direction; + + private string document_hint = "photo"; + + private string default_file_name = _("Scanned Document.pdf"); + private bool scanning = false; + + private int window_width; + private int window_height; + private bool window_is_maximized; + + public signal void start_scan (string? device, ScanOptions options); + public signal void stop_scan (); + public signal void email (string profile); + public signal void quit (); + + public SimpleScan () + { + book = new Book (); + book.page_removed.connect (page_removed_cb); + book.page_added.connect (page_added_cb); + + settings = new Settings ("org.gnome.SimpleScan"); + + load (); + } + + private bool find_scan_device (string device, out Gtk.TreeIter iter) + { + bool have_iter = false; + + if (device_model.get_iter_first (out iter)) + { + do + { + string d; + device_model.get (iter, 0, out d, -1); + if (d == device) + have_iter = true; + } while (!have_iter && device_model.iter_next (ref iter)); + } + + return have_iter; + } + + private void show_error_dialog (string error_title, string error_text) + { + var dialog = new Gtk.MessageDialog (window, + Gtk.DialogFlags.MODAL, + Gtk.MessageType.WARNING, + Gtk.ButtonsType.NONE, + "%s", error_title); + dialog.add_button (Gtk.Stock.CLOSE, 0); + dialog.format_secondary_text ("%s", error_text); + dialog.destroy (); + } + + public void set_default_file_name (string default_file_name) + { + this.default_file_name = default_file_name; + } + + public void authorize (string resource, out string username, out string password) + { + /* Label in authorization dialog. '%s' is replaced with the name of the resource requesting authorization */ + var description = _("Username and password required to access '%s'").printf (resource); + + username_entry.set_text (""); + password_entry.set_text (""); + authorize_label.set_text (description); + + authorize_dialog.show (); + authorize_dialog.run (); + authorize_dialog.hide (); + + username = username_entry.get_text (); + password = password_entry.get_text (); + } + + [CCode (cname = "G_MODULE_EXPORT device_combo_changed_cb", instance_pos = -1)] + public void device_combo_changed_cb (Gtk.Widget widget) + { + if (setting_devices) + return; + user_selected_device = true; + } + + private void update_info_bar () + { + Gtk.MessageType type; + string title, text, image_id; + bool show_close_button = false; + bool show_change_scanner_button = false; + + if (have_error) + { + type = Gtk.MessageType.ERROR; + image_id = Gtk.Stock.DIALOG_ERROR; + title = error_title; + text = error_text; + show_close_button = true; + show_change_scanner_button = error_change_scanner_hint; + } + else if (device_model.iter_n_children (null) == 0) + { + type = Gtk.MessageType.WARNING; + image_id = Gtk.Stock.DIALOG_WARNING; + /* Warning displayed when no scanners are detected */ + title = _("No scanners detected"); + /* Hint to user on why there are no scanners detected */ + text = _("Please check your scanner is connected and powered on"); + } + else + { + info_bar.hide (); + return; + } + + info_bar.set_message_type (type); + info_bar_image.set_from_stock (image_id, Gtk.IconSize.DIALOG); + var message = "<big><b>%s</b></big>\n\n%s".printf (title, text); + info_bar_label.set_markup (message); + info_bar_close_button.set_visible (show_close_button); + info_bar_change_scanner_button.set_visible (show_change_scanner_button); + info_bar.show (); + } + + public void set_scan_devices (List<ScanDevice> devices) + { + bool have_selection = false; + int index; + Gtk.TreeIter iter; + + setting_devices = true; + + /* If the user hasn't chosen a scanner choose the best available one */ + if (user_selected_device) + have_selection = device_combo.get_active () >= 0; + + /* Add new devices */ + index = 0; + foreach (var device in devices) + { + int n_delete = -1; + + /* Find if already exists */ + if (device_model.iter_nth_child (out iter, null, index)) + { + int i = 0; + do + { + string name; + bool matched; + + device_model.get (iter, 0, out name, -1); + matched = name == device.name; + + if (matched) + { + n_delete = i; + break; + } + i++; + } while (device_model.iter_next (ref iter)); + } + + /* If exists, remove elements up to this one */ + if (n_delete >= 0) + { + int i; + + /* Update label */ + device_model.set (iter, 1, device.label, -1); + + for (i = 0; i < n_delete; i++) + { + device_model.iter_nth_child (out iter, null, index); + device_model.remove (iter); + } + } + else + { + device_model.insert (out iter, index); + device_model.set (iter, 0, device.name, 1, device.label, -1); + } + index++; + } + + /* Remove any remaining devices */ + while (device_model.iter_nth_child (out iter, null, index)) + device_model.remove (iter); + + /* Select the first available device */ + if (!have_selection && devices != null) + device_combo.set_active (0); + + setting_devices = false; + + update_info_bar (); + } + + private string? get_selected_device () + { + Gtk.TreeIter iter; + + if (device_combo.get_active_iter (out iter)) + { + string device; + device_model.get (iter, 0, out device, -1); + return device; + } + + return null; + } + + public void set_selected_device (string device) + { + Gtk.TreeIter iter; + if (!find_scan_device (device, out iter)) + return; + + device_combo.set_active_iter (iter); + user_selected_device = true; + } + + private void add_default_page () + { + var page = book.append_page (default_page_width, + default_page_height, + default_page_dpi, + default_page_scan_direction); + book_view.select_page (page); + } + + private void on_file_type_changed (Gtk.TreeSelection selection) + { + Gtk.TreeModel model; + Gtk.TreeIter iter; + if (!selection.get_selected (out model, out iter)) + return; + + string extension; + model.get (iter, 1, out extension, -1); + var path = save_dialog.get_filename (); + var filename = Path.get_basename (path); + + /* Replace extension */ + var extension_index = filename.last_index_of_char ('.'); + if (extension_index >= 0) + filename = filename.slice (0, extension_index); + filename = filename + extension; + save_dialog.set_current_name (filename); + } + + private string choose_file_location () + { + /* Get directory to save to */ + string? directory = null; + directory = settings.get_string ("save-directory"); + + if (directory == null || directory == "") + directory = Environment.get_user_special_dir (UserDirectory.DOCUMENTS); + + save_dialog = new Gtk.FileChooserDialog (/* Save dialog: Dialog title */ + _("Save As..."), + window, + Gtk.FileChooserAction.SAVE, + Gtk.Stock.CANCEL, Gtk.ResponseType.CANCEL, + Gtk.Stock.SAVE, Gtk.ResponseType.ACCEPT, + null); + save_dialog.set_do_overwrite_confirmation (true); + save_dialog.set_local_only (false); + save_dialog.set_current_folder (directory); + save_dialog.set_current_name (default_file_name); + + /* Filter to only show images by default */ + var filter = new Gtk.FileFilter (); + filter.set_name (/* Save dialog: Filter name to show only image files */ + _("Image Files")); + filter.add_pixbuf_formats (); + filter.add_mime_type ("application/pdf"); + save_dialog.add_filter (filter); + filter = new Gtk.FileFilter (); + filter.set_name (/* Save dialog: Filter name to show all files */ + _("All Files")); + filter.add_pattern ("*"); + save_dialog.add_filter (filter); + + var expander = new Gtk.Expander.with_mnemonic (/* */ + _("Select File _Type")); + expander.set_spacing (5); + save_dialog.set_extra_widget (expander); + + string extension = ""; + var index = default_file_name.last_index_of_char ('.'); + if (index >= 0) + extension = default_file_name.slice (0, index); + + var file_type_store = new Gtk.ListStore (2, typeof (string), typeof (string)); + Gtk.TreeIter iter; + file_type_store.append (out iter); + file_type_store.set (iter, + /* Save dialog: Label for saving in PDF format */ + 0, _("PDF (multi-page document)"), + 1, ".pdf", + -1); + file_type_store.append (out iter); + file_type_store.set (iter, + /* Save dialog: Label for saving in JPEG format */ + 0, _("JPEG (compressed)"), + 1, ".jpg", + -1); + file_type_store.append (out iter); + file_type_store.set (iter, + /* Save dialog: Label for saving in PNG format */ + 0, _("PNG (lossless)"), + 1, ".png", + -1); + + var file_type_view = new Gtk.TreeView.with_model (file_type_store); + file_type_view.set_headers_visible (false); + file_type_view.set_rules_hint (true); + var column = new Gtk.TreeViewColumn.with_attributes ("", + new Gtk.CellRendererText (), + "text", 0, null); + file_type_view.append_column (column); + expander.add (file_type_view); + + if (file_type_store.get_iter_first (out iter)) + { + do + { + string e; + file_type_store.get (iter, 1, out e, -1); + if (extension == e) + file_type_view.get_selection ().select_iter (iter); + } while (file_type_store.iter_next (ref iter)); + } + file_type_view.get_selection ().changed.connect (on_file_type_changed); + + expander.show_all (); + + var response = save_dialog.run (); + + string? uri = null; + if (response == Gtk.ResponseType.ACCEPT) + uri = save_dialog.get_uri (); + + settings.set_string ("save-directory", save_dialog.get_current_folder ()); + + save_dialog.destroy (); + save_dialog = null; + + return uri; + } + + private bool save_document (bool force_choose_location) + { + string? uri; + if (book_uri != null && !force_choose_location) + uri = book_uri; + else + uri = choose_file_location (); + if (uri == null) + return false; + + var file = File.new_for_uri (uri); + + debug ("Saving to '%s'", uri); + + var uri_lower = uri.down (); + string format = "jpeg"; + if (uri_lower.has_suffix (".pdf")) + format = "pdf"; + else if (uri_lower.has_suffix (".ps")) + format = "ps"; + else if (uri_lower.has_suffix (".png")) + format = "png"; + else if (uri_lower.has_suffix (".tif") || uri_lower.has_suffix (".tiff")) + format = "tiff"; + + try + { + book.save (format, file); + } + catch (Error e) + { + warning ("Error saving file: %s", e.message); + show_error (/* Title of error dialog when save failed */ + _("Failed to save file"), + e.message, + false); + return false; + } + + book_uri = uri; + book.set_needs_saving (false); + return true; + } + + private bool prompt_to_save (string title, string discard_label) + { + if (!book.get_needs_saving ()) + return true; + + var dialog = new Gtk.MessageDialog (window, + Gtk.DialogFlags.MODAL, + Gtk.MessageType.WARNING, + Gtk.ButtonsType.NONE, + "%s", title); + dialog.format_secondary_text ("%s", + /* Text in dialog warning when a document is about to be lost*/ + _("If you don't save, changes will be permanently lost.")); + dialog.add_button (discard_label, Gtk.ResponseType.NO); + dialog.add_button (Gtk.Stock.CANCEL, Gtk.ResponseType.CANCEL); + dialog.add_button (Gtk.Stock.SAVE, Gtk.ResponseType.YES); + + var response = dialog.run (); + dialog.destroy (); + + switch (response) + { + case Gtk.ResponseType.YES: + if (save_document (false)) + return true; + else + return false; + case Gtk.ResponseType.CANCEL: + return false; + case Gtk.ResponseType.NO: + default: + return true; + } + } + + private void clear_document () + { + book.clear (); + add_default_page (); + book_uri = null; + book.set_needs_saving (false); + save_as_menuitem.set_sensitive (false); + } + + [CCode (cname = "G_MODULE_EXPORT new_button_clicked_cb", instance_pos = -1)] + public void new_button_clicked_cb (Gtk.Widget widget) + { + if (!prompt_to_save (/* Text in dialog warning when a document is about to be lost */ + _("Save current document?"), + /* Button in dialog to create new document and discard unsaved document */ + _("Discard Changes"))) + return; + + clear_document (); + } + + private void set_document_hint (string document_hint) + { + this.document_hint = document_hint; + + if (document_hint == "text") + { + text_toolbar_menuitem.set_active (true); + text_menu_menuitem.set_active (true); + } + else if (document_hint == "photo") + { + photo_toolbar_menuitem.set_active (true); + photo_menu_menuitem.set_active (true); + } + } + + [CCode (cname = "G_MODULE_EXPORT text_menuitem_toggled_cb", instance_pos = -1)] + public void text_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_document_hint ("text"); + } + + [CCode (cname = "G_MODULE_EXPORT photo_menuitem_toggled_cb", instance_pos = -1)] + public void photo_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_document_hint ("photo"); + } + + private void set_page_side (ScanType page_side) + { + Gtk.TreeIter iter; + + if (page_side_model.get_iter_first (out iter)) + { + do + { + int s; + page_side_model.get (iter, 0, out s, -1); + if (s == page_side) + { + page_side_combo.set_active_iter (iter); + return; + } + } while (page_side_model.iter_next (ref iter)); + } + } + + private void set_paper_size (int width, int height) + { + Gtk.TreeIter iter; + bool have_iter; + + for (have_iter = paper_size_model.get_iter_first (out iter); + have_iter; + have_iter = paper_size_model.iter_next (ref iter)) + { + int w, h; + paper_size_model.get (iter, 0, out w, 1, out h, -1); + if (w == width && h == height) + break; + } + + if (!have_iter) + have_iter = paper_size_model.get_iter_first (out iter); + if (have_iter) + paper_size_combo.set_active_iter (iter); + } + + private int get_text_dpi () + { + Gtk.TreeIter iter; + int dpi = DEFAULT_TEXT_DPI; + + if (text_dpi_combo.get_active_iter (out iter)) + text_dpi_model.get (iter, 0, out dpi, -1); + + return dpi; + } + + private int get_photo_dpi () + { + Gtk.TreeIter iter; + int dpi = DEFAULT_PHOTO_DPI; + + if (photo_dpi_combo.get_active_iter (out iter)) + photo_dpi_model.get (iter, 0, out dpi, -1); + + return dpi; + } + + private ScanType get_page_side () + { + Gtk.TreeIter iter; + int page_side = ScanType.ADF_BOTH; + + if (page_side_combo.get_active_iter (out iter)) + page_side_model.get (iter, 0, out page_side, -1); + + return (ScanType) page_side; + } + + private bool get_paper_size (out int width, out int height) + { + Gtk.TreeIter iter; + + if (paper_size_combo.get_active_iter (out iter)) + { + paper_size_model.get (iter, 0, ref width, 1, ref height, -1); + return true; + } + + return false; + } + + private ScanOptions get_scan_options () + { + var options = new ScanOptions (); + if (document_hint == "text") + { + options.scan_mode = ScanMode.GRAY; + options.dpi = get_text_dpi (); + options.depth = 2; + } + else + { + options.scan_mode = ScanMode.COLOR; + options.dpi = get_photo_dpi (); + options.depth = 8; + } + get_paper_size (out options.paper_width, out options.paper_height); + + return options; + } + + [CCode (cname = "G_MODULE_EXPORT scan_button_clicked_cb", instance_pos = -1)] + public void scan_button_clicked_cb (Gtk.Widget widget) + { + var options = get_scan_options (); + options.type = ScanType.SINGLE; + start_scan (get_selected_device (), options); + } + + [CCode (cname = "G_MODULE_EXPORT stop_scan_button_clicked_cb", instance_pos = -1)] + public void stop_scan_button_clicked_cb (Gtk.Widget widget) + { + stop_scan (); + } + + [CCode (cname = "G_MODULE_EXPORT continuous_scan_button_clicked_cb", instance_pos = -1)] + public void continuous_scan_button_clicked_cb (Gtk.Widget widget) + { + if (scanning) + stop_scan (); + else + { + var options = get_scan_options (); + options.type = get_page_side (); + start_scan (get_selected_device (), options); + } + } + + [CCode (cname = "G_MODULE_EXPORT preferences_button_clicked_cb", instance_pos = -1)] + public void preferences_button_clicked_cb (Gtk.Widget widget) + { + preferences_dialog.present (); + } + + [CCode (cname = "G_MODULE_EXPORT preferences_dialog_delete_event_cb", instance_pos = -1)] + public bool preferences_dialog_delete_event_cb (Gtk.Widget widget) + { + return true; + } + + [CCode (cname = "G_MODULE_EXPORT preferences_dialog_response_cb", instance_pos = -1)] + public void preferences_dialog_response_cb (Gtk.Widget widget, int response_id) + { + preferences_dialog.hide (); + } + + private void update_page_menu () + { + var page = book_view.get_selected (); + if (page == null) + { + page_move_left_menuitem.set_sensitive (false); + page_move_right_menuitem.set_sensitive (false); + } + else + { + var index = book.get_page_index (page); + page_move_left_menuitem.set_sensitive (index > 0); + page_move_right_menuitem.set_sensitive (index < book.get_n_pages () - 1); + } + } + + private void page_selected_cb (BookView view, Page? page) + { + if (page == null) + return; + + updating_page_menu = true; + + update_page_menu (); + + string? name = null; + if (page.has_crop ()) + { + // FIXME: Make more generic, move into page-size.c and reuse + var crop_name = page.get_named_crop (); + if (crop_name != null) + { + if (crop_name == "A4") + name = "a4_menuitem"; + else if (crop_name == "A5") + name = "a5_menuitem"; + else if (crop_name == "A6") + name = "a6_menuitem"; + else if (crop_name == "letter") + name = "letter_menuitem"; + else if (crop_name == "legal") + name = "legal_menuitem"; + else if (crop_name == "4x6") + name = "4x6_menuitem"; + } + else + name = "custom_crop_menuitem"; + } + else + name = "no_crop_menuitem"; + + var menuitem = (Gtk.RadioMenuItem) builder.get_object (name); + menuitem.set_active (true); + var toolbutton = (Gtk.ToggleToolButton) builder.get_object ("crop_toolbutton"); + toolbutton.set_active (page.has_crop ()); + + updating_page_menu = false; + } + + // FIXME: Duplicated from simple-scan.vala + private string? get_temporary_filename (string prefix, string extension) + { + /* 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 */ + + var filename = "%sXXXXXX.%s".printf (prefix, extension); + string path; + try + { + var fd = FileUtils.open_tmp (filename, out path); + Posix.close (fd); + } + catch (Error e) + { + warning ("Error saving email attachment: %s", e.message); + return null; + } + + return path; + } + + private void show_page_cb (BookView view, Page page) + { + var path = get_temporary_filename ("scanned-page", "tiff"); + if (path == null) + return; + var file = File.new_for_path (path); + + try + { + page.save ("tiff", file); + } + catch (Error e) + { + show_error_dialog (/* Error message display when unable to save image for preview */ + _("Unable to save image for preview"), + e.message); + return; + } + + try + { + Gtk.show_uri (window.get_screen (), file.get_uri (), Gtk.get_current_event_time ()); + } + catch (Error e) + { + show_error_dialog (/* Error message display when unable to preview image */ + _("Unable to open image preview application"), + e.message); + } + } + + private void show_page_menu_cb (BookView view) + { + var menu = (Gtk.Menu) builder.get_object ("page_menu"); + menu.popup (null, null, null, 3, Gtk.get_current_event_time()); + } + + [CCode (cname = "G_MODULE_EXPORT rotate_left_button_clicked_cb", instance_pos = -1)] + public void rotate_left_button_clicked_cb (Gtk.Widget widget) + { + if (updating_page_menu) + return; + var page = book_view.get_selected (); + if (page != null) + page.rotate_left (); + } + + [CCode (cname = "G_MODULE_EXPORT rotate_right_button_clicked_cb", instance_pos = -1)] + public void rotate_right_button_clicked_cb (Gtk.Widget widget) + { + if (updating_page_menu) + return; + var page = book_view.get_selected (); + if (page != null) + page.rotate_right (); + } + + private void set_crop (string? crop_name) + { + crop_rotate_menuitem.set_sensitive (crop_name != null); + + if (updating_page_menu) + return; + + var page = book_view.get_selected (); + if (page == null) + return; + + if (crop_name == null) + { + page.set_no_crop (); + return; + } + else if (crop_name == "custom") + { + var width = page.get_width (); + var height = page.get_height (); + var crop_width = (int) (width * 0.8 + 0.5); + var crop_height = (int) (height * 0.8 + 0.5); + page.set_custom_crop (crop_width, crop_height); + page.move_crop ((width - crop_width) / 2, (height - crop_height) / 2); + } + else + page.set_named_crop (crop_name); + } + + [CCode (cname = "G_MODULE_EXPORT no_crop_menuitem_toggled_cb", instance_pos = -1)] + public void no_crop_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop (null); + } + + [CCode (cname = "G_MODULE_EXPORT custom_crop_menuitem_toggled_cb", instance_pos = -1)] + public void custom_crop_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop ("custom"); + } + + [CCode (cname = "G_MODULE_EXPORT crop_toolbutton_toggled_cb", instance_pos = -1)] + public void crop_toolbutton_toggled_cb (Gtk.ToggleToolButton widget) + { + if (updating_page_menu) + return; + + Gtk.RadioMenuItem menuitem; + if (widget.get_active ()) + menuitem = (Gtk.RadioMenuItem) builder.get_object ("custom_crop_menuitem"); + else + menuitem = (Gtk.RadioMenuItem) builder.get_object ("no_crop_menuitem"); + menuitem.set_active (true); + } + + [CCode (cname = "G_MODULE_EXPORT four_by_six_menuitem_toggled_cb", instance_pos = -1)] + public void four_by_six_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop ("4x6"); + } + + [CCode (cname = "G_MODULE_EXPORT legal_menuitem_toggled_cb", instance_pos = -1)] + public void legal_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop ("legal"); + } + + [CCode (cname = "G_MODULE_EXPORT letter_menuitem_toggled_cb", instance_pos = -1)] + public void letter_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop ("letter"); + } + + [CCode (cname = "G_MODULE_EXPORT a6_menuitem_toggled_cb", instance_pos = -1)] + public void a6_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop ("A6"); + } + + [CCode (cname = "G_MODULE_EXPORT a5_menuitem_toggled_cb", instance_pos = -1)] + public void a5_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop ("A5"); + } + + [CCode (cname = "G_MODULE_EXPORT a4_menuitem_toggled_cb", instance_pos = -1)] + public void a4_menuitem_toggled_cb (Gtk.CheckMenuItem widget) + { + if (widget.get_active ()) + set_crop ("A4"); + } + + [CCode (cname = "G_MODULE_EXPORT crop_rotate_menuitem_activate_cb", instance_pos = -1)] + public void crop_rotate_menuitem_activate_cb (Gtk.Widget widget) + { + var page = book_view.get_selected (); + if (page == null) + return; + page.rotate_crop (); + } + + [CCode (cname = "G_MODULE_EXPORT page_move_left_menuitem_activate_cb", instance_pos = -1)] + public void page_move_left_menuitem_activate_cb (Gtk.Widget widget) + { + var page = book_view.get_selected (); + var index = book.get_page_index (page); + if (index > 0) + book.move_page (page, index - 1); + + update_page_menu (); + } + + [CCode (cname = "G_MODULE_EXPORT page_move_right_menuitem_activate_cb", instance_pos = -1)] + public void page_move_right_menuitem_activate_cb (Gtk.Widget widget) + { + var page = book_view.get_selected (); + var index = book.get_page_index (page); + if (index < book.get_n_pages () - 1) + book.move_page (page, book.get_page_index (page) + 1); + + update_page_menu (); + } + + [CCode (cname = "G_MODULE_EXPORT page_delete_menuitem_activate_cb", instance_pos = -1)] + public void page_delete_menuitem_activate_cb (Gtk.Widget widget) + { + book_view.get_book ().delete_page (book_view.get_selected ()); + } + + [CCode (cname = "G_MODULE_EXPORT save_file_button_clicked_cb", instance_pos = -1)] + public void save_file_button_clicked_cb (Gtk.Widget widget) + { + save_document (false); + } + + [CCode (cname = "G_MODULE_EXPORT save_as_file_button_clicked_cb", instance_pos = -1)] + public void save_as_file_button_clicked_cb (Gtk.Widget widget) + { + save_document (true); + } + + private void draw_page (Gtk.PrintOperation operation, + Gtk.PrintContext print_context, + int page_number) + { + var context = print_context.get_cairo_context (); + var page = book.get_page (page_number); + + /* Rotate to same aspect */ + bool is_landscape = false; + if (print_context.get_width () > print_context.get_height ()) + is_landscape = true; + if (page.is_landscape () != is_landscape) + { + context.translate (print_context.get_width (), 0); + context.rotate (Math.PI_2); + } + + context.scale (print_context.get_dpi_x () / page.get_dpi (), + print_context.get_dpi_y () / page.get_dpi ()); + + var image = page.get_image (true); + Gdk.cairo_set_source_pixbuf (context, image, 0, 0); + context.paint (); + } + + [CCode (cname = "G_MODULE_EXPORT email_button_clicked_cb", instance_pos = -1)] + public void email_button_clicked_cb (Gtk.Widget widget) + { + email (document_hint); + } + + [CCode (cname = "G_MODULE_EXPORT print_button_clicked_cb", instance_pos = -1)] + public void print_button_clicked_cb (Gtk.Widget widget) + { + var print = new Gtk.PrintOperation (); + print.set_n_pages ((int) book.get_n_pages ()); + print.draw_page.connect (draw_page); + + try + { + print.run (Gtk.PrintOperationAction.PRINT_DIALOG, window); + } + catch (Error e) + { + warning ("Error printing: %s", e.message); + } + } + + [CCode (cname = "G_MODULE_EXPORT help_contents_menuitem_activate_cb", instance_pos = -1)] + public void help_contents_menuitem_activate_cb (Gtk.Widget widget) + { + try + { + Gtk.show_uri (window.get_screen (), "ghelp:simple-scan", Gtk.get_current_event_time ()); + } + catch (Error e) + { + show_error_dialog (/* Error message displayed when unable to launch help browser */ + _("Unable to open help file"), + e.message); + } + } + + [CCode (cname = "G_MODULE_EXPORT about_menuitem_activate_cb", instance_pos = -1)] + public void about_menuitem_activate_cb (Gtk.Widget widget) + { + string[] authors = { "Robert Ancell <robert.ancell@canonical.com>" }; + + /* The license this software is under (GPL3+) */ + string license = _("This program is free software: you can redistribute it and/or modify\nit under the terms of the GNU General Public License as published by\nthe Free Software Foundation, either version 3 of the License, or\n(at your option) any later version.\n\nThis program is distributed in the hope that it will be useful,\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\nGNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License\nalong with this program. If not, see <http://www.gnu.org/licenses/>."); + + /* Title of about dialog */ + string title = _("About Simple Scan"); + + /* Description of program */ + string description = _("Simple document scanning tool"); + + Gtk.show_about_dialog (window, + "title", title, + "program-name", "Simple Scan", + "version", Config.VERSION, + "comments", description, + "logo-icon-name", "scanner", + "authors", authors, + "translator-credits", _("translator-credits"), + "website", "https://launchpad.net/simple-scan", + "copyright", "Copyright © 2009-2011 Canonical Ltd.", + "license", license, + "wrap-license", true, + null); + } + + private bool on_quit () + { + if (!prompt_to_save (/* Text in dialog warning when a document is about to be lost */ + _("Save document before quitting?"), + /* Button in dialog to quit and discard unsaved document */ + _("Quit without Saving"))) + return false; + + var device = get_selected_device (); + int paper_width = 0, paper_height = 0; + get_paper_size (out paper_width, out paper_height); + + if (device != null) + settings.set_string ("selected-device", device); + settings.set_string ("document-type", document_hint); + settings.set_int ("text-dpi", get_text_dpi ()); + settings.set_int ("photo-dpi", get_photo_dpi ()); + settings.set_enum ("page-side", get_page_side ()); + settings.set_int ("paper-width", paper_width); + settings.set_int ("paper-height", paper_height); + settings.set_int ("window-width", window_width); + settings.set_int ("window-height", window_height); + settings.set_boolean ("window-is-maximized", window_is_maximized); + settings.set_enum ("scan-direction", default_page_scan_direction); + settings.set_int ("page-width", default_page_width); + settings.set_int ("page-height", default_page_height); + settings.set_int ("page-dpi", default_page_dpi); + + quit (); + + return true; + } + + [CCode (cname = "G_MODULE_EXPORT quit_menuitem_activate_cb", instance_pos = -1)] + public void quit_menuitem_activate_cb (Gtk.Widget widget) + { + on_quit (); + } + + [CCode (cname = "G_MODULE_EXPORT simple_scan_window_configure_event_cb", instance_pos = -1)] + public bool simple_scan_window_configure_event_cb (Gtk.Widget widget, Gdk.EventConfigure event) + { + if (!window_is_maximized) + { + window_width = event.width; + window_height = event.height; + } + + return false; + } + + private void info_bar_response_cb (Gtk.InfoBar widget, int response_id) + { + if (response_id == 1) + { + device_combo.grab_focus (); + preferences_dialog.present (); + } + else + { + have_error = false; + error_title = null; + error_text = null; + update_info_bar (); + } + } + + [CCode (cname = "G_MODULE_EXPORT simple_scan_window_window_state_event_cb", instance_pos = -1)] + public bool simple_scan_window_window_state_event_cb (Gtk.Widget widget, Gdk.EventWindowState event) + { + if ((event.changed_mask & Gdk.WindowState.MAXIMIZED) != 0) + window_is_maximized = (event.new_window_state & Gdk.WindowState.MAXIMIZED) != 0; + return false; + } + + [CCode (cname = "G_MODULE_EXPORT window_delete_event_cb", instance_pos = -1)] + public bool window_delete_event_cb (Gtk.Widget widget, Gdk.Event event) + { + return !on_quit (); + } + + private void page_size_changed_cb (Page page) + { + default_page_width = page.get_width (); + default_page_height = page.get_height (); + default_page_dpi = page.get_dpi (); + } + + private void page_scan_direction_changed_cb (Page page) + { + default_page_scan_direction = page.get_scan_direction (); + } + + private void page_added_cb (Book book, Page page) + { + default_page_width = page.get_width (); + default_page_height = page.get_height (); + default_page_dpi = page.get_dpi (); + default_page_scan_direction = page.get_scan_direction (); + page.size_changed.connect (page_size_changed_cb); + page.scan_direction_changed.connect (page_scan_direction_changed_cb); + + update_page_menu (); + } + + private void page_removed_cb (Book book, Page page) + { + /* If this is the last page add a new blank one */ + if (book.get_n_pages () == 1) + add_default_page (); + + update_page_menu (); + } + + private void set_dpi_combo (Gtk.ComboBox combo, int default_dpi, int current_dpi) + { + var renderer = new Gtk.CellRendererText (); + combo.pack_start (renderer, true); + combo.add_attribute (renderer, "text", 1); + + var model = (Gtk.ListStore) combo.get_model (); + int[] scan_resolutions = {75, 150, 300, 600, 1200, 2400}; + foreach (var dpi in scan_resolutions) + { + string label; + if (dpi == default_dpi) + /* Preferences dialog: Label for default resolution in resolution list */ + label = _("%d dpi (default)").printf (dpi); + else if (dpi == 75) + /* Preferences dialog: Label for minimum resolution in resolution list */ + label = _("%d dpi (draft)").printf (dpi); + else if (dpi == 1200) + /* Preferences dialog: Label for maximum resolution in resolution list */ + label = _("%d dpi (high resolution)").printf (dpi); + else + /* Preferences dialog: Label for resolution value in resolution list (dpi = dots per inch) */ + label = _("%d dpi").printf (dpi); + + Gtk.TreeIter iter; + model.append (out iter); + model.set (iter, 0, dpi, 1, label, -1); + + if (dpi == current_dpi) + combo.set_active_iter (iter); + } + } + + private void needs_saving_cb (Book book) + { + save_menuitem.set_sensitive (book.get_needs_saving ()); + save_toolbutton.set_sensitive (book.get_needs_saving ()); + if (book.get_needs_saving ()) + save_as_menuitem.set_sensitive (true); + } + + private void load () + { + Gtk.IconTheme.get_default ().append_search_path (Config.ICON_DIR); + + Gtk.Window.set_default_icon_name ("scanner"); + + builder = new Gtk.Builder (); + var filename = Path.build_filename (Config.UI_DIR, "simple-scan.ui", null); + try + { + builder.add_from_file (filename); + } + catch (Error e) + { + critical ("Unable to load UI %s: %s\n", filename, e.message); + show_error_dialog (/* Title of dialog when cannot load required files */ + _("Files missing"), + /* Description in dialog when cannot load required files */ + _("Please check your installation")); + Posix.exit (Posix.EXIT_FAILURE); + } + builder.connect_signals (this); + + window = (Gtk.Window) builder.get_object ("simple_scan_window"); + main_vbox = (Gtk.VBox) builder.get_object ("main_vbox"); + page_move_left_menuitem = (Gtk.MenuItem) builder.get_object ("page_move_left_menuitem"); + page_move_right_menuitem = (Gtk.MenuItem) builder.get_object ("page_move_right_menuitem"); + page_delete_menuitem = (Gtk.MenuItem) builder.get_object ("page_delete_menuitem"); + crop_rotate_menuitem = (Gtk.MenuItem) builder.get_object ("crop_rotate_menuitem"); + save_menuitem = (Gtk.MenuItem) builder.get_object ("save_menuitem"); + save_as_menuitem = (Gtk.MenuItem) builder.get_object ("save_as_menuitem"); + save_toolbutton = (Gtk.ToolButton) builder.get_object ("save_toolbutton"); + stop_menuitem = (Gtk.MenuItem) builder.get_object ("stop_scan_menuitem"); + stop_toolbutton = (Gtk.ToolButton) builder.get_object ("stop_toolbutton"); + + text_toolbar_menuitem = (Gtk.RadioMenuItem) builder.get_object ("text_toolbutton_menuitem"); + text_menu_menuitem = (Gtk.RadioMenuItem) builder.get_object ("text_menuitem"); + photo_toolbar_menuitem = (Gtk.RadioMenuItem) builder.get_object ("photo_toolbutton_menuitem"); + photo_menu_menuitem = (Gtk.RadioMenuItem) builder.get_object ("photo_menuitem"); + + authorize_dialog = (Gtk.Dialog) builder.get_object ("authorize_dialog"); + authorize_label = (Gtk.Label) builder.get_object ("authorize_label"); + username_entry = (Gtk.Entry) builder.get_object ("username_entry"); + password_entry = (Gtk.Entry) builder.get_object ("password_entry"); + + preferences_dialog = (Gtk.Dialog) builder.get_object ("preferences_dialog"); + device_combo = (Gtk.ComboBox) builder.get_object ("device_combo"); + device_model = (Gtk.ListStore) device_combo.get_model (); + text_dpi_combo = (Gtk.ComboBox) builder.get_object ("text_dpi_combo"); + text_dpi_model = (Gtk.ListStore) text_dpi_combo.get_model (); + photo_dpi_combo = (Gtk.ComboBox) builder.get_object ("photo_dpi_combo"); + photo_dpi_model = (Gtk.ListStore) photo_dpi_combo.get_model (); + page_side_combo = (Gtk.ComboBox) builder.get_object ("page_side_combo"); + page_side_model = (Gtk.ListStore) page_side_combo.get_model (); + paper_size_combo = (Gtk.ComboBox) builder.get_object ("paper_size_combo"); + paper_size_model = (Gtk.ListStore) paper_size_combo.get_model (); + + /* Add InfoBar (not supported in Glade) */ + info_bar = new Gtk.InfoBar (); + info_bar.response.connect (info_bar_response_cb); + main_vbox.pack_start (info_bar, false, true, 0); + var hbox = new Gtk.HBox (false, 12); + var content_area = (Gtk.Container) info_bar.get_content_area (); + content_area.add (hbox); + hbox.show (); + + info_bar_image = new Gtk.Image.from_stock (Gtk.Stock.DIALOG_WARNING, Gtk.IconSize.DIALOG); + hbox.pack_start (info_bar_image, false, true, 0); + info_bar_image.show (); + + info_bar_label = new Gtk.Label (null); + info_bar_label.set_alignment (0.0f, 0.5f); + hbox.pack_start (info_bar_label, true, true, 0); + info_bar_label.show (); + + info_bar_close_button = (Gtk.Button) info_bar.add_button (Gtk.Stock.CLOSE, Gtk.ResponseType.CLOSE); + info_bar_change_scanner_button = (Gtk.Button) info_bar.add_button (/* Button in error infobar to open preferences dialog and change scanner */ + _("Change _Scanner"), 1); + + Gtk.TreeIter iter; + paper_size_model.append (out iter); + paper_size_model.set (iter, 0, 0, 1, 0, 2, + /* Combo box value for automatic paper size */ + _("Automatic"), -1); + paper_size_model.append (out iter); + paper_size_model.set (iter, 0, 1050, 1, 1480, 2, "A6", -1); + paper_size_model.append (out iter); + paper_size_model.set (iter, 0, 1480, 1, 2100, 2, "A5", -1); + paper_size_model.append (out iter); + paper_size_model.set (iter, 0, 2100, 1, 2970, 2, "A4", -1); + paper_size_model.append (out iter); + paper_size_model.set (iter, 0, 2159, 1, 2794, 2, "Letter", -1); + paper_size_model.append (out iter); + paper_size_model.set (iter, 0, 2159, 1, 3556, 2, "Legal", -1); + paper_size_model.append (out iter); + paper_size_model.set (iter, 0, 1016, 1, 1524, 2, "4×6", -1); + + var dpi = settings.get_int ("text-dpi"); + if (dpi <= 0) + dpi = DEFAULT_TEXT_DPI; + set_dpi_combo (text_dpi_combo, DEFAULT_TEXT_DPI, dpi); + dpi = settings.get_int ("photo-dpi"); + if (dpi <= 0) + dpi = DEFAULT_PHOTO_DPI; + set_dpi_combo (photo_dpi_combo, DEFAULT_PHOTO_DPI, dpi); + + var renderer = new Gtk.CellRendererText (); + device_combo.pack_start (renderer, true); + device_combo.add_attribute (renderer, "text", 1); + + renderer = new Gtk.CellRendererText (); + page_side_combo.pack_start (renderer, true); + page_side_combo.add_attribute (renderer, "text", 1); + set_page_side ((ScanType) settings.get_enum ("page-side")); + + renderer = new Gtk.CellRendererText (); + paper_size_combo.pack_start (renderer, true); + paper_size_combo.add_attribute (renderer, "text", 2); + var paper_width = settings.get_int ("paper-width"); + var paper_height = settings.get_int ("paper-height"); + set_paper_size (paper_width, paper_height); + + var device = settings.get_string ("selected-device"); + if (device != null) + { + if (find_scan_device (device, out iter)) + device_combo.set_active_iter (iter); + } + + var document_type = settings.get_string ("document-type"); + if (document_type != null) + set_document_hint (document_type); + + book_view = new BookView (book); + book_view.set_border_width (18); + main_vbox.pack_end (book_view, true, true, 0); + book_view.page_selected.connect (page_selected_cb); + book_view.show_page.connect (show_page_cb); + book_view.show_menu.connect (show_page_menu_cb); + book_view.show (); + + /* Find default page details */ + default_page_scan_direction = (ScanDirection) settings.get_enum ("scan-direction"); + default_page_width = settings.get_int ("page-width"); + if (default_page_width <= 0) + default_page_width = 595; + default_page_height = settings.get_int ("page-height"); + if (default_page_height <= 0) + default_page_height = 842; + default_page_dpi = settings.get_int ("page-dpi"); + if (default_page_dpi <= 0) + default_page_dpi = 72; + + /* Restore window size */ + window_width = settings.get_int ("window-width"); + if (window_width <= 0) + window_width = 600; + window_height = settings.get_int ("window-height"); + if (window_height <= 0) + window_height = 400; + debug ("Restoring window to %dx%d pixels", window_width, window_height); + window.set_default_size (window_width, window_height); + window_is_maximized = settings.get_boolean ("window-is-maximized"); + if (window_is_maximized) + { + debug ("Restoring window to maximized"); + window.maximize (); + } + + if (book.get_n_pages () == 0) + add_default_page (); + book.set_needs_saving (false); + book.needs_saving_changed.connect (needs_saving_cb); + } + + public Book get_book () + { + return book; + } + + public void set_selected_page (Page page) + { + book_view.select_page (page); + } + + public Page get_selected_page () + { + return book_view.get_selected (); + } + + public void set_scanning (bool scanning) + { + this.scanning = scanning; + page_delete_menuitem.set_sensitive (!scanning); + stop_menuitem.set_sensitive (scanning); + stop_toolbutton.set_sensitive (scanning); + } + + public void show_error (string error_title, string error_text, bool change_scanner_hint) + { + have_error = true; + this.error_title = error_title; + this.error_text = error_text; + error_change_scanner_hint = change_scanner_hint; + update_info_bar (); + } + + public void start () + { + window.show (); + } +} |