Imported Upstream version 0.18.1upstream/0.18.1

1 files changed, 1156 insertions, 0 deletions

diff --git a/src/Printing.vala b/src/Printing.vala
new file mode 100644
index 0000000..8e37997
--- /dev/null
+++ b/src/Printing.vala
@@ -0,0 +1,1156 @@
+/* Copyright 2010-2014 Yorba Foundation
+ *
+ * This software is licensed under the GNU LGPL (version 2.1 or later).
+ * See the COPYING file in this distribution.
+ */
+
+public enum ContentLayout {
+    STANDARD_SIZE,
+    CUSTOM_SIZE,
+    IMAGE_PER_PAGE
+}
+
+public class PrintSettings {
+    public const int MIN_CONTENT_PPI = 72;    /* 72 ppi is the pixel resolution of a 14" VGA
+                                                 display -- it's standard for historical reasons */
+    public const int MAX_CONTENT_PPI = 1200;  /* 1200 ppi is appropriate for a 3600 dpi imagesetter
+                                                 used to produce photographic plates for commercial
+                                                 printing -- it's the highest pixel resolution
+                                                 commonly used */
+    private ContentLayout content_layout;
+    private Measurement content_width;
+    private Measurement content_height;
+    private int content_ppi;
+    private int image_per_page_selection;
+    private int size_selection;
+    private bool match_aspect_ratio;
+    private bool print_titles;
+    private string print_titles_font;
+
+    public PrintSettings() {
+        Config.Facade config = Config.Facade.get_instance();
+
+        MeasurementUnit units = (MeasurementUnit) config.get_printing_content_units();
+        
+        content_width = Measurement(config.get_printing_content_width(), units);
+        content_height = Measurement(config.get_printing_content_height(), units);
+        size_selection = config.get_printing_size_selection();
+        content_layout = (ContentLayout) config.get_printing_content_layout();
+        match_aspect_ratio = config.get_printing_match_aspect_ratio();
+        print_titles = config.get_printing_print_titles();
+        print_titles_font = config.get_printing_titles_font();
+        image_per_page_selection = config.get_printing_images_per_page();
+        content_ppi = config.get_printing_content_ppi();
+    }
+
+    public void save() {
+        Config.Facade config = Config.Facade.get_instance();
+
+        config.set_printing_content_units(content_width.unit);
+        config.set_printing_content_width(content_width.value);
+        config.set_printing_content_height(content_height.value);
+        config.set_printing_size_selection(size_selection);
+        config.set_printing_content_layout(content_layout);
+        config.set_printing_match_aspect_ratio(match_aspect_ratio);
+        config.set_printing_print_titles(print_titles);
+        config.set_printing_titles_font(print_titles_font);
+        config.set_printing_images_per_page(image_per_page_selection);
+        config.set_printing_content_ppi(content_ppi);
+    }
+
+
+    public Measurement get_content_width() {
+        switch (get_content_layout()) {
+            case ContentLayout.STANDARD_SIZE:
+            case ContentLayout.IMAGE_PER_PAGE:
+                return (PrintManager.get_instance().get_standard_sizes()[
+                    get_size_selection()]).width;
+
+            case ContentLayout.CUSTOM_SIZE:
+                return content_width;
+
+            default:
+                error("unknown ContentLayout enumeration value");
+        }
+    }
+
+    public Measurement get_content_height() {
+        switch (get_content_layout()) {
+            case ContentLayout.STANDARD_SIZE:
+            case ContentLayout.IMAGE_PER_PAGE:
+                return (PrintManager.get_instance().get_standard_sizes()[
+                    get_size_selection()]).height;
+
+            case ContentLayout.CUSTOM_SIZE:
+                return content_height;
+
+            default:
+                error("unknown ContentLayout enumeration value");
+        }
+    }
+
+    public Measurement get_minimum_content_dimension() {
+        return Measurement(0.5, MeasurementUnit.INCHES);
+    }
+
+    public Measurement get_maximum_content_dimension() {
+        return Measurement(30, MeasurementUnit.INCHES);
+    }
+
+    public bool is_match_aspect_ratio_enabled() {
+        return match_aspect_ratio;
+    }
+
+    public bool is_print_titles_enabled() {
+        return print_titles;
+    }
+
+    public int get_content_ppi() {
+        return content_ppi;
+    }
+
+    public int get_image_per_page_selection() {
+        return image_per_page_selection;
+    }
+
+    public int get_size_selection() {
+        return size_selection;
+    }
+
+    public ContentLayout get_content_layout() {
+        return content_layout;
+    }
+
+    public void set_content_layout(ContentLayout content_layout) {
+        this.content_layout = content_layout;
+    }
+
+    public void set_content_width(Measurement content_width) {
+        this.content_width = content_width;
+    }
+
+    public void set_content_height(Measurement content_height) {
+        this.content_height = content_height;
+    }
+
+    public void set_content_ppi(int content_ppi) {
+        this.content_ppi = content_ppi;
+    }
+
+    public void set_image_per_page_selection(int image_per_page_selection) {
+        this.image_per_page_selection = image_per_page_selection;
+    }
+
+    public void set_size_selection(int size_selection) {
+        this.size_selection = size_selection;
+    }
+
+    public void set_match_aspect_ratio_enabled(bool enable_state) {
+        this.match_aspect_ratio = enable_state;
+    }
+
+    public void set_print_titles_enabled(bool print_titles) {
+        this.print_titles = print_titles;
+    }
+
+    public void set_print_titles_font(string fontname) {
+        this.print_titles_font = fontname;
+    }
+
+    public string get_print_titles_font() {
+        return this.print_titles_font;
+    }
+}
+
+/* we define our own measurement enum instead of using the Gtk.Unit enum
+   provided by Gtk+ 2.0 because Gtk.Unit doesn't define a CENTIMETERS
+   constant (thout it does define an MM for millimeters). This is
+   unfortunate, because in metric countries people like to think about
+   paper sizes for printing in CM not MM. so, to avoid having to
+   multiply and divide everything by 10 (which is error prone) to convert
+   from CM to MM and vice-versa whenever we read or write measurements, we
+   eschew Gtk.Unit and substitute our own */
+public enum MeasurementUnit {
+    INCHES,
+    CENTIMETERS
+}
+
+public struct Measurement {
+    private const double CENTIMETERS_PER_INCH = 2.54;
+    private const double INCHES_PER_CENTIMETER = (1.0 / 2.54);
+
+    public double value;
+    public MeasurementUnit unit;
+
+    public Measurement(double value, MeasurementUnit unit) {
+        this.value = value;
+        this.unit = unit;
+    }
+
+    public Measurement convert_to(MeasurementUnit to_unit) {
+        if (unit == to_unit)
+            return this;
+
+        if (to_unit == MeasurementUnit.INCHES) {
+            return Measurement(value * INCHES_PER_CENTIMETER, MeasurementUnit.INCHES);
+        } else if (to_unit == MeasurementUnit.CENTIMETERS) {
+            return Measurement(value * CENTIMETERS_PER_INCH, MeasurementUnit.CENTIMETERS);
+        } else {
+            error("unrecognized unit");
+        }
+    }
+
+    public bool is_less_than(Measurement rhs) {
+        Measurement converted_rhs = (unit == rhs.unit) ? rhs : rhs.convert_to(unit);
+        return (value < converted_rhs.value);
+    }
+
+    public bool is_greater_than(Measurement rhs) {
+        Measurement converted_rhs = (unit == rhs.unit) ? rhs : rhs.convert_to(unit);
+        return (value > converted_rhs.value);
+    }
+}
+
+private enum PrintLayout {
+    ENTIRE_PAGE,
+    TWO_PER_PAGE,
+    FOUR_PER_PAGE,
+    SIX_PER_PAGE,
+    EIGHT_PER_PAGE,
+    SIXTEEN_PER_PAGE,
+    THIRTY_TWO_PER_PAGE;
+    
+    public static PrintLayout[] get_all() {
+        return {
+            ENTIRE_PAGE,
+            TWO_PER_PAGE,
+            FOUR_PER_PAGE,
+            SIX_PER_PAGE,
+            EIGHT_PER_PAGE,
+            SIXTEEN_PER_PAGE,
+            THIRTY_TWO_PER_PAGE
+        };
+    }
+    
+    public int get_per_page() {
+        int[] per_page = { 1, 2, 4, 6, 8, 16, 32 };
+        
+        return per_page[this];
+    }
+    
+    public int get_x() {
+        int[] x = { 1, 1, 2, 2, 2, 4, 4 };
+        
+        return x[this];
+     }
+    
+    public int get_y() {
+        int[] y = { 1, 2, 2, 3, 4, 4, 8 };
+        
+        return y[this];
+    }
+    
+    public string to_string() {
+        string[] labels = {
+            _("Fill the entire page"),
+            _("2 images per page"),
+            _("4 images per page"),
+            _("6 images per page"),
+            _("8 images per page"),
+            _("16 images per page"),
+            _("32 images per page")
+        };
+        
+        return labels[this];
+    }
+}
+
+public class CustomPrintTab : Gtk.Fixed {
+    private const int INCHES_COMBO_CHOICE = 0;
+    private const int CENTIMETERS_COMBO_CHOICE = 1;
+
+    private Gtk.Box custom_image_settings_pane = null;
+    private Gtk.RadioButton standard_size_radio = null;
+    private Gtk.RadioButton custom_size_radio = null;
+    private Gtk.RadioButton image_per_page_radio = null;
+    private Gtk.ComboBox image_per_page_combo = null;
+    private Gtk.ComboBox standard_sizes_combo = null;
+    private Gtk.ComboBoxText units_combo = null;
+    private Gtk.Entry custom_width_entry = null;
+    private Gtk.Entry custom_height_entry = null;
+    private Gtk.Entry ppi_entry;
+    private Gtk.CheckButton aspect_ratio_check = null;
+    private Gtk.CheckButton title_print_check = null;
+    private Gtk.FontButton title_print_font = null;
+    private Measurement local_content_width = Measurement(5.0, MeasurementUnit.INCHES);
+    private Measurement local_content_height = Measurement(5.0, MeasurementUnit.INCHES);
+    private int local_content_ppi;
+    private bool is_text_insertion_in_progress = false;
+    private PrintJob source_job;
+
+    public CustomPrintTab(PrintJob source_job) {
+        this.source_job = source_job;
+        Gtk.Builder builder = AppWindow.create_builder();
+
+        // an enclosing box for every widget on this tab...
+        custom_image_settings_pane = builder.get_object("box_ImgSettingsPane") as Gtk.Box;
+
+        standard_size_radio = builder.get_object("radio_UseStandardSize") as Gtk.RadioButton;
+        standard_size_radio.clicked.connect(on_radio_group_click);
+        
+        custom_size_radio = builder.get_object("radio_UseCustomSize") as Gtk.RadioButton;
+        custom_size_radio.clicked.connect(on_radio_group_click);
+
+        image_per_page_radio = builder.get_object("radio_Autosize") as Gtk.RadioButton;
+        image_per_page_radio.clicked.connect(on_radio_group_click);
+
+        image_per_page_combo = builder.get_object("combo_Autosize") as Gtk.ComboBox;
+        Gtk.CellRendererText image_per_page_combo_text_renderer =
+            new Gtk.CellRendererText();
+        image_per_page_combo.pack_start(image_per_page_combo_text_renderer, true);
+        image_per_page_combo.add_attribute(image_per_page_combo_text_renderer,
+            "text", 0);
+        Gtk.ListStore image_per_page_combo_store = new Gtk.ListStore(2, typeof(string),
+            typeof(string));
+        foreach (PrintLayout layout in PrintLayout.get_all()) {
+            Gtk.TreeIter iter;
+            image_per_page_combo_store.append(out iter);
+            image_per_page_combo_store.set_value(iter, 0, layout.to_string());
+        }
+        image_per_page_combo.set_model(image_per_page_combo_store);
+
+        StandardPrintSize[] standard_sizes = PrintManager.get_instance().get_standard_sizes();
+        standard_sizes_combo = builder.get_object("combo_StdSizes") as Gtk.ComboBox;
+        Gtk.CellRendererText standard_sizes_combo_text_renderer =
+            new Gtk.CellRendererText();
+        standard_sizes_combo.pack_start(standard_sizes_combo_text_renderer, true);
+        standard_sizes_combo.add_attribute(standard_sizes_combo_text_renderer,
+            "text", 0);
+        standard_sizes_combo.set_row_separator_func(standard_sizes_combo_separator_func);
+        Gtk.ListStore standard_sizes_combo_store = new Gtk.ListStore(1, typeof(string),
+            typeof(string));
+        foreach (StandardPrintSize size in standard_sizes) {
+            Gtk.TreeIter iter;
+            standard_sizes_combo_store.append(out iter);
+            standard_sizes_combo_store.set_value(iter, 0, size.name);
+        }
+        standard_sizes_combo.set_model(standard_sizes_combo_store);
+
+        custom_width_entry = builder.get_object("entry_CustomWidth") as Gtk.Entry;
+        custom_width_entry.insert_text.connect(on_entry_insert_text);
+        custom_width_entry.focus_out_event.connect(on_width_entry_focus_out);
+
+        custom_height_entry = builder.get_object("entry_CustomHeight") as Gtk.Entry;
+        custom_height_entry.insert_text.connect(on_entry_insert_text);
+        custom_height_entry.focus_out_event.connect(on_height_entry_focus_out);
+
+        units_combo = builder.get_object("combo_Units") as Gtk.ComboBoxText;
+        units_combo.append_text(_("in."));
+        units_combo.append_text(_("cm"));
+        units_combo.set_active(0);
+        units_combo.changed.connect(on_units_combo_changed);
+
+        aspect_ratio_check = builder.get_object("check_MatchAspectRatio") as Gtk.CheckButton;
+        title_print_check = builder.get_object("check_PrintImageTitle") as Gtk.CheckButton;
+        title_print_font = builder.get_object("fntbn_TitleFont") as Gtk.FontButton;
+
+        ppi_entry = builder.get_object("entry_PixelsPerInch") as Gtk.Entry;
+        ppi_entry.insert_text.connect(on_ppi_entry_insert_text);
+        ppi_entry.focus_out_event.connect(on_ppi_entry_focus_out);
+
+        this.add(custom_image_settings_pane);
+
+        sync_state_from_job(source_job);
+
+        show_all();
+
+        /* connect this signal after state is sync'd */
+        aspect_ratio_check.clicked.connect(on_aspect_ratio_check_clicked);
+    }
+
+    private void on_aspect_ratio_check_clicked() {
+        if (aspect_ratio_check.get_active()) {
+            local_content_width =
+                Measurement(local_content_height.value * source_job.get_source_aspect_ratio(),
+                local_content_height.unit);
+            custom_width_entry.set_text(format_measurement(local_content_width));
+        }
+    }
+
+    private bool on_width_entry_focus_out(Gdk.EventFocus event) {
+        if (custom_width_entry.get_text() == (format_measurement_as(local_content_width,
+            get_user_unit_choice())))
+            return false;
+
+        Measurement new_width = get_width_entry_value();
+        Measurement min_width = source_job.get_local_settings().get_minimum_content_dimension();
+        Measurement max_width = source_job.get_local_settings().get_maximum_content_dimension();
+
+        if (new_width.is_less_than(min_width) || new_width.is_greater_than(max_width)) {
+            custom_width_entry.set_text(format_measurement(local_content_width));
+            return false;
+        }
+
+        if (is_match_aspect_ratio_enabled()) {
+            Measurement new_height =
+                Measurement(new_width.value / source_job.get_source_aspect_ratio(),
+                new_width.unit);
+            local_content_height = new_height;
+            custom_height_entry.set_text(format_measurement(new_height));
+        }
+
+        local_content_width = new_width;
+        custom_width_entry.set_text(format_measurement(new_width));
+        return false;
+    }
+
+    private string format_measurement(Measurement measurement) {
+        return "%.2f".printf(measurement.value);
+    }
+
+    private string format_measurement_as(Measurement measurement, MeasurementUnit to_unit) {
+        Measurement converted_measurement = (measurement.unit == to_unit) ? measurement :
+            measurement.convert_to(to_unit);
+        return format_measurement(converted_measurement);
+    }
+
+    private bool on_ppi_entry_focus_out(Gdk.EventFocus event) {
+        set_content_ppi(int.parse(ppi_entry.get_text()));
+        return false;
+    }
+
+    private void on_ppi_entry_insert_text(Gtk.Editable editable, string text, int length,
+        ref int position) {
+        Gtk.Entry sender = (Gtk.Entry) editable;
+        
+        if (is_text_insertion_in_progress)
+            return;
+
+        is_text_insertion_in_progress = true;
+        
+        if (length == -1)
+            length = (int) text.length;
+
+        string new_text = "";
+        for (int ctr = 0; ctr < length; ctr++) {
+            if (text[ctr].isdigit())
+                new_text += ((char) text[ctr]).to_string();
+        }
+
+        if (new_text.length > 0)
+            sender.insert_text(new_text, (int) new_text.length, ref position);
+
+        Signal.stop_emission_by_name(sender, "insert-text");
+
+        is_text_insertion_in_progress = false;
+    }
+
+    private bool on_height_entry_focus_out(Gdk.EventFocus event) {
+        if (custom_height_entry.get_text() == (format_measurement_as(local_content_height,
+            get_user_unit_choice())))
+            return false;
+
+        Measurement new_height = get_height_entry_value();
+        Measurement min_height = source_job.get_local_settings().get_minimum_content_dimension();
+        Measurement max_height = source_job.get_local_settings().get_maximum_content_dimension();
+
+        if (new_height.is_less_than(min_height) || new_height.is_greater_than(max_height)) {
+            custom_height_entry.set_text(format_measurement(local_content_height));
+            return false;
+        }
+
+        if (is_match_aspect_ratio_enabled()) {
+            Measurement new_width =
+                Measurement(new_height.value * source_job.get_source_aspect_ratio(),
+                new_height.unit);
+            local_content_width = new_width;
+            custom_width_entry.set_text(format_measurement(new_width));
+        }
+
+        local_content_height = new_height;
+        custom_height_entry.set_text(format_measurement(new_height));
+        return false;
+    }
+
+    private MeasurementUnit get_user_unit_choice() {
+        if (units_combo.get_active() == INCHES_COMBO_CHOICE) {
+            return MeasurementUnit.INCHES;
+        } else if (units_combo.get_active() == CENTIMETERS_COMBO_CHOICE) {
+            return MeasurementUnit.CENTIMETERS;
+        } else {
+            error("unknown unit combo box choice");
+        }
+    }
+
+    private void set_user_unit_choice(MeasurementUnit unit) {
+        if (unit == MeasurementUnit.INCHES) {
+            units_combo.set_active(INCHES_COMBO_CHOICE);
+        } else if (unit == MeasurementUnit.CENTIMETERS) {
+            units_combo.set_active(CENTIMETERS_COMBO_CHOICE);
+        } else {
+            error("unknown MeasurementUnit enumeration");
+        }
+    }
+
+    private Measurement get_width_entry_value() {
+        return Measurement(double.parse(custom_width_entry.get_text()), get_user_unit_choice());
+    }
+
+    private Measurement get_height_entry_value() {
+        return Measurement(double.parse(custom_height_entry.get_text()), get_user_unit_choice());
+    }
+
+    private void on_entry_insert_text(Gtk.Editable editable, string text, int length,
+        ref int position) {
+        
+        Gtk.Entry sender = (Gtk.Entry) editable;
+        
+        if (is_text_insertion_in_progress)
+            return;
+
+        is_text_insertion_in_progress = true;
+        
+        if (length == -1)
+            length = (int) text.length;
+
+        string decimal_point = Intl.localeconv().decimal_point;
+        bool contains_decimal_point = sender.get_text().contains(decimal_point);
+
+        string new_text = "";
+        for (int ctr = 0; ctr < length; ctr++) {
+            if (text[ctr].isdigit()) {
+                new_text += ((char) text[ctr]).to_string();
+            } else if ((!contains_decimal_point) && (text[ctr] == decimal_point[0])) {
+                new_text += ((char) text[ctr]).to_string();
+            }
+        }
+
+        if (new_text.length > 0)
+            sender.insert_text(new_text, (int) new_text.length, ref position);
+
+        Signal.stop_emission_by_name(sender, "insert-text");
+
+        is_text_insertion_in_progress = false;
+    }
+
+    private void sync_state_from_job(PrintJob job) {
+        assert(job.get_local_settings().get_content_width().unit ==
+            job.get_local_settings().get_content_height().unit);
+        
+        Measurement constrained_width = job.get_local_settings().get_content_width();
+        if (job.get_local_settings().is_match_aspect_ratio_enabled())
+            constrained_width = Measurement(job.get_local_settings().get_content_height().value *
+                job.get_source_aspect_ratio(), job.get_local_settings().get_content_height().unit);
+        set_content_width(constrained_width);
+        set_content_height(job.get_local_settings().get_content_height());
+        set_content_layout(job.get_local_settings().get_content_layout());
+        set_content_ppi(job.get_local_settings().get_content_ppi());
+        set_image_per_page_selection(job.get_local_settings().get_image_per_page_selection());
+        set_size_selection(job.get_local_settings().get_size_selection());
+        set_match_aspect_ratio_enabled(job.get_local_settings().is_match_aspect_ratio_enabled());
+        set_print_titles_enabled(job.get_local_settings().is_print_titles_enabled());
+        set_print_titles_font(job.get_local_settings().get_print_titles_font());
+    }
+
+    private void on_radio_group_click(Gtk.Button b) {
+        Gtk.RadioButton sender = (Gtk.RadioButton) b;
+        
+        if (sender == standard_size_radio) {
+            set_content_layout_control_state(ContentLayout.STANDARD_SIZE);
+            standard_sizes_combo.grab_focus();
+        } else if (sender == custom_size_radio) {
+            set_content_layout_control_state(ContentLayout.CUSTOM_SIZE);
+            custom_height_entry.grab_focus();
+        } else if (sender == image_per_page_radio) {
+            set_content_layout_control_state(ContentLayout.IMAGE_PER_PAGE);
+        }
+    }
+
+    private void on_units_combo_changed() {
+        custom_height_entry.set_text(format_measurement_as(local_content_height,
+            get_user_unit_choice()));
+        custom_width_entry.set_text(format_measurement_as(local_content_width,
+            get_user_unit_choice()));
+    }
+
+    private void set_content_layout_control_state(ContentLayout layout) {
+        switch (layout) {
+            case ContentLayout.STANDARD_SIZE:
+                standard_sizes_combo.set_sensitive(true);
+                units_combo.set_sensitive(false);
+                custom_width_entry.set_sensitive(false);
+                custom_height_entry.set_sensitive(false);
+                aspect_ratio_check.set_sensitive(false);
+                image_per_page_combo.set_sensitive(false);
+            break;
+
+            case ContentLayout.CUSTOM_SIZE:
+                standard_sizes_combo.set_sensitive(false);
+                units_combo.set_sensitive(true);
+                custom_width_entry.set_sensitive(true);
+                custom_height_entry.set_sensitive(true);
+                aspect_ratio_check.set_sensitive(true);
+                image_per_page_combo.set_sensitive(false);
+            break;
+
+            case ContentLayout.IMAGE_PER_PAGE:
+                standard_sizes_combo.set_sensitive(false);
+                units_combo.set_sensitive(false);
+                custom_width_entry.set_sensitive(false);
+                custom_height_entry.set_sensitive(false);
+                aspect_ratio_check.set_sensitive(false);
+                image_per_page_combo.set_sensitive(true);
+            break;
+
+            default:
+                error("unknown ContentLayout enumeration value");
+        }
+    }
+
+    private static bool standard_sizes_combo_separator_func(Gtk.TreeModel model,
+        Gtk.TreeIter iter) {
+        Value val;
+        model.get_value(iter, 0, out val);
+
+        return (val.dup_string() == "-");
+    }
+
+    private void set_content_layout(ContentLayout content_layout) {
+        set_content_layout_control_state(content_layout);
+        switch (content_layout) {
+            case ContentLayout.STANDARD_SIZE:
+                standard_size_radio.set_active(true);
+            break;
+
+            case ContentLayout.CUSTOM_SIZE:
+                custom_size_radio.set_active(true);
+            break;
+
+            case ContentLayout.IMAGE_PER_PAGE:
+                image_per_page_radio.set_active(true);
+            break;
+
+            default:
+                error("unknown ContentLayout enumeration value");
+        }
+    }
+
+    private ContentLayout get_content_layout() {
+        if (standard_size_radio.get_active())
+            return ContentLayout.STANDARD_SIZE;
+        if (custom_size_radio.get_active())
+            return ContentLayout.CUSTOM_SIZE;
+        if (image_per_page_radio.get_active())
+            return ContentLayout.IMAGE_PER_PAGE;
+
+        error("inconsistent content layout radio button group state");
+    }
+
+    private void set_content_width(Measurement content_width) {
+        if (content_width.unit != local_content_height.unit) {
+            set_user_unit_choice(content_width.unit);
+            local_content_height = local_content_height.convert_to(content_width.unit);
+            custom_height_entry.set_text(format_measurement(local_content_height));
+        }
+        local_content_width = content_width;
+        custom_width_entry.set_text(format_measurement(content_width));
+    }
+
+    private Measurement get_content_width() {
+        return local_content_width;
+    }
+
+    private void set_content_height(Measurement content_height) {
+        if (content_height.unit != local_content_width.unit) {
+            set_user_unit_choice(content_height.unit);
+            local_content_width = local_content_width.convert_to(content_height.unit);
+            custom_width_entry.set_text(format_measurement(local_content_width));
+        }
+        local_content_height = content_height;
+        custom_height_entry.set_text(format_measurement(content_height));
+    }
+
+    private Measurement get_content_height() {
+        return local_content_height;
+    }
+
+    private void set_content_ppi(int content_ppi) {
+        local_content_ppi = content_ppi.clamp(PrintSettings.MIN_CONTENT_PPI,
+            PrintSettings.MAX_CONTENT_PPI);
+
+        ppi_entry.set_text("%d".printf(local_content_ppi));
+    }
+
+    private int get_content_ppi() {
+        return local_content_ppi;
+    }
+
+    private void set_image_per_page_selection(int image_per_page) {
+        image_per_page_combo.set_active(image_per_page);
+    }
+
+    private int get_image_per_page_selection() {
+        return image_per_page_combo.get_active();
+    }
+
+    private void set_size_selection(int size_selection) {
+        standard_sizes_combo.set_active(size_selection);
+    }
+
+    private int get_size_selection() {
+        return standard_sizes_combo.get_active();
+    }
+
+    private void set_match_aspect_ratio_enabled(bool enable_state) {
+        aspect_ratio_check.set_active(enable_state);
+    }
+
+    private void set_print_titles_enabled(bool print_titles) {
+        title_print_check.set_active(print_titles);
+    }
+
+    private void set_print_titles_font(string fontname) {
+        title_print_font.set_font_name(fontname);
+    }
+
+
+    private bool is_match_aspect_ratio_enabled() {
+        return aspect_ratio_check.get_active();
+    }
+
+    private bool is_print_titles_enabled() {
+        return title_print_check.get_active();
+    }
+
+    private string get_print_titles_font() {
+        return title_print_font.get_font_name();
+    }
+
+    public PrintJob get_source_job() {
+        return source_job;
+    }
+
+    public PrintSettings get_local_settings() {
+        PrintSettings result = new PrintSettings();
+
+        result.set_content_width(get_content_width());
+        result.set_content_height(get_content_height());
+        result.set_content_layout(get_content_layout());
+        result.set_content_ppi(get_content_ppi());
+        result.set_image_per_page_selection(get_image_per_page_selection());
+        result.set_size_selection(get_size_selection());
+        result.set_match_aspect_ratio_enabled(is_match_aspect_ratio_enabled());
+        result.set_print_titles_enabled(is_print_titles_enabled());
+        result.set_print_titles_font(get_print_titles_font());
+
+        return result;
+    }
+}
+
+public class PrintJob : Gtk.PrintOperation {
+    private PrintSettings settings;
+    private Gee.ArrayList<Photo> photos = new Gee.ArrayList<Photo>();
+    
+    public PrintJob(Gee.Collection<Photo> to_print) {
+        this.settings = PrintManager.get_instance().get_global_settings();
+        photos.add_all(to_print);
+        
+        set_embed_page_setup (true);
+        double photo_aspect_ratio =  photos[0].get_dimensions().get_aspect_ratio();
+        if (photo_aspect_ratio < 1.0)
+            photo_aspect_ratio = 1.0 / photo_aspect_ratio;
+    }
+
+    public Gee.List<Photo> get_photos() {
+        return photos;
+    }
+
+    public Photo get_source_photo() {
+        return photos[0];
+    }
+
+    public double get_source_aspect_ratio() {
+        double aspect_ratio = photos[0].get_dimensions().get_aspect_ratio();
+        return (aspect_ratio < 1.0) ? (1.0 / aspect_ratio) : aspect_ratio;
+    }
+
+    public PrintSettings get_local_settings() {
+        return settings;
+    }
+
+    public void set_local_settings(PrintSettings settings) {
+        this.settings = settings;
+    }
+}
+
+public class StandardPrintSize {
+    public StandardPrintSize(string name, Measurement width, Measurement height) {
+        this.name = name;
+        this.width = width;
+        this.height = height;
+    }
+
+    public string name;
+    public Measurement width;
+    public Measurement height;
+}
+
+public class PrintManager {
+    private const double IMAGE_DISTANCE = 0.24;
+    
+    private static PrintManager instance = null;
+    
+    private PrintSettings settings;
+    private Gtk.PageSetup user_page_setup;
+    private CustomPrintTab custom_tab;
+    private ProgressDialog? progress_dialog = null;
+    private Cancellable? cancellable = null;
+    
+    private PrintManager() {
+        user_page_setup = new Gtk.PageSetup();
+        settings = new PrintSettings();
+    }
+
+    public StandardPrintSize[] get_standard_sizes() {
+        StandardPrintSize[] result = new StandardPrintSize[0];
+
+        result += new StandardPrintSize(_("Wallet (2 x 3 in.)"),
+            Measurement(3, MeasurementUnit.INCHES),
+            Measurement(2, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(_("Notecard (3 x 5 in.)"),
+            Measurement(5, MeasurementUnit.INCHES),
+            Measurement(3, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(_("4 x 6 in."),
+            Measurement(6, MeasurementUnit.INCHES),
+            Measurement(4, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(_("5 x 7 in."),
+            Measurement(7, MeasurementUnit.INCHES),
+            Measurement(5, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(_("8 x 10 in."),
+            Measurement(10, MeasurementUnit.INCHES),
+            Measurement(8, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(_("11 x 14 in."),
+            Measurement(14, MeasurementUnit.INCHES),
+            Measurement(11, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(_("16 x 20 in."),
+            Measurement(20, MeasurementUnit.INCHES),
+            Measurement(16, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(("-"),
+            Measurement(0, MeasurementUnit.INCHES),
+            Measurement(0, MeasurementUnit.INCHES));
+        result += new StandardPrintSize(_("Metric Wallet (9 x 13 cm)"),
+            Measurement(13, MeasurementUnit.CENTIMETERS),
+            Measurement(9, MeasurementUnit.CENTIMETERS));
+        result += new StandardPrintSize(_("Postcard (10 x 15 cm)"),
+            Measurement(15, MeasurementUnit.CENTIMETERS),
+            Measurement(10, MeasurementUnit.CENTIMETERS));
+        result += new StandardPrintSize(_("13 x 18 cm"),
+            Measurement(18, MeasurementUnit.CENTIMETERS),
+            Measurement(13, MeasurementUnit.CENTIMETERS));
+        result += new StandardPrintSize(_("18 x 24 cm"),
+            Measurement(24, MeasurementUnit.CENTIMETERS),
+            Measurement(18, MeasurementUnit.CENTIMETERS));
+        result += new StandardPrintSize(_("20 x 30 cm"),
+            Measurement(30, MeasurementUnit.CENTIMETERS),
+            Measurement(20, MeasurementUnit.CENTIMETERS));
+        result += new StandardPrintSize(_("24 x 40 cm"),
+            Measurement(40, MeasurementUnit.CENTIMETERS),
+            Measurement(24, MeasurementUnit.CENTIMETERS));
+        result += new StandardPrintSize(_("30 x 40 cm"),
+            Measurement(40, MeasurementUnit.CENTIMETERS),
+            Measurement(30, MeasurementUnit.CENTIMETERS));
+
+        return result;
+    }
+
+    public static PrintManager get_instance() {
+        if (instance == null)
+            instance = new PrintManager();
+
+        return instance;
+    }
+
+    public void spool_photo(Gee.Collection<Photo> to_print) {
+        PrintJob job = new PrintJob(to_print);
+        job.set_custom_tab_label(_("Image Settings"));
+        job.set_unit(Gtk.Unit.INCH);
+        job.set_n_pages(1);
+        job.set_job_name(job.get_source_photo().get_name());
+        job.set_default_page_setup(user_page_setup);
+        job.begin_print.connect(on_begin_print);
+        job.draw_page.connect(on_draw_page);
+        job.create_custom_widget.connect(on_create_custom_widget);
+        job.status_changed.connect(on_status_changed);
+        
+        AppWindow.get_instance().set_busy_cursor();
+        
+        cancellable = new Cancellable();
+        progress_dialog = new ProgressDialog(AppWindow.get_instance(), _("Printing..."), cancellable);
+        
+        string? err_msg = null;
+        try {
+            Gtk.PrintOperationResult result = job.run(Gtk.PrintOperationAction.PRINT_DIALOG,
+                AppWindow.get_instance());
+            if (result == Gtk.PrintOperationResult.APPLY)
+                user_page_setup = job.get_default_page_setup();
+        } catch (Error e) {
+            job.cancel();
+            err_msg = e.message;
+        }
+        
+        progress_dialog.close();
+        progress_dialog = null;
+        cancellable = null;
+        
+        AppWindow.get_instance().set_normal_cursor();
+        
+        if (err_msg != null)
+            AppWindow.error_message(_("Unable to print photo:\n\n%s").printf(err_msg));
+    }
+
+    private void on_begin_print(Gtk.PrintOperation emitting_object, Gtk.PrintContext job_context) {
+        debug("on_begin_print");
+        
+        PrintJob job = (PrintJob) emitting_object;
+        
+        // cancel() can only be called from "begin-print", "paginate", or "draw-page"
+        if (cancellable != null && cancellable.is_cancelled()) {
+            job.cancel();
+            
+            return;
+        }
+        
+        Gee.List<Photo> photos = job.get_photos();
+        if (job.get_local_settings().get_content_layout() == ContentLayout.IMAGE_PER_PAGE){
+            PrintLayout layout = (PrintLayout) job.get_local_settings().get_image_per_page_selection();
+            job.set_n_pages((int) Math.ceil((double) photos.size / (double) layout.get_per_page()));
+        } else {
+            job.set_n_pages(photos.size);
+        }
+        
+        spin_event_loop();
+    }
+    
+    private void on_status_changed(Gtk.PrintOperation job) {
+        debug("on_status_changed: %s", job.get_status_string());
+        
+        if (progress_dialog != null) {
+            progress_dialog.set_status(job.get_status_string());
+            spin_event_loop();
+        }
+    }
+    
+    private void on_draw_page(Gtk.PrintOperation emitting_object, Gtk.PrintContext job_context,
+        int page_num) {
+        debug("on_draw_page");
+        
+        PrintJob job = (PrintJob) emitting_object;
+        
+        // cancel() can only be called from "begin-print", "paginate", or "draw-page"
+        if (cancellable != null && cancellable.is_cancelled()) {
+            job.cancel();
+            
+            return;
+        }
+        
+        spin_event_loop();
+        
+        Gtk.PageSetup page_setup = job_context.get_page_setup();
+        double page_width = page_setup.get_page_width(Gtk.Unit.INCH);
+        double page_height = page_setup.get_page_height(Gtk.Unit.INCH);
+
+        double dpi = job.get_local_settings().get_content_ppi();
+        double inv_dpi = 1.0 / dpi;
+        Cairo.Context dc = job_context.get_cairo_context();
+        dc.scale(inv_dpi, inv_dpi);
+        Gee.List<Photo> photos = job.get_photos();
+        
+        ContentLayout content_layout = job.get_local_settings().get_content_layout();
+        switch (content_layout) {
+            case ContentLayout.STANDARD_SIZE:
+            case ContentLayout.CUSTOM_SIZE:
+                double canvas_width, canvas_height;
+                if (content_layout == ContentLayout.STANDARD_SIZE) {
+                    canvas_width = get_standard_sizes()[job.get_local_settings().get_size_selection()].width.convert_to(
+                        MeasurementUnit.INCHES).value;
+                    canvas_height = get_standard_sizes()[job.get_local_settings().get_size_selection()].height.convert_to(
+                        MeasurementUnit.INCHES).value;
+                } else {
+                    assert(content_layout == ContentLayout.CUSTOM_SIZE);
+                    canvas_width = job.get_local_settings().get_content_width().convert_to(
+                        MeasurementUnit.INCHES).value;
+                    canvas_height = job.get_local_settings().get_content_height().convert_to(
+                        MeasurementUnit.INCHES).value;
+                }
+                
+                if (page_num < photos.size) {
+                    Dimensions photo_dimensions = photos[page_num].get_dimensions();
+                    double photo_aspect_ratio = photo_dimensions.get_aspect_ratio();
+                    double canvas_aspect_ratio = ((double) canvas_width) / canvas_height;
+                    if (Math.floor(canvas_aspect_ratio) != Math.floor(photo_aspect_ratio)) {
+                        double canvas_tmp = canvas_width;
+                        canvas_width = canvas_height;
+                        canvas_height = canvas_tmp;
+                    }
+                    
+                    double dx = (page_width - canvas_width) / 2.0;
+                    double dy = (page_height - canvas_height) / 2.0;
+                    fit_image_to_canvas(photos[page_num], dx, dy, canvas_width, canvas_height, true,
+                        job, job_context);
+                    if (job.get_local_settings().is_print_titles_enabled()) {
+                        add_title_to_canvas(page_width / 2, page_height, photos[page_num].get_name(),
+                            job, job_context);
+                    }
+                }
+                
+                if (progress_dialog != null)
+                    progress_dialog.monitor(page_num, photos.size);
+            break;
+            
+            case ContentLayout.IMAGE_PER_PAGE:
+                PrintLayout layout = (PrintLayout) job.get_local_settings().get_image_per_page_selection();
+                int nx = layout.get_x();
+                int ny = layout.get_y();
+                int start = page_num * layout.get_per_page();
+                double canvas_width = (double) (page_width - IMAGE_DISTANCE * (nx - 1)) / nx;
+                double canvas_height = (double) (page_height - IMAGE_DISTANCE * (ny - 1)) / ny;
+                for (int y = 0; y < ny; y++){
+                    for (int x = 0; x < nx; x++){
+                        int i = start + y * nx + x;
+                        if (i < photos.size) {
+                            double dx = x * (canvas_width) + x * IMAGE_DISTANCE;
+                            double dy = y * (canvas_height) + y * IMAGE_DISTANCE;
+                            fit_image_to_canvas(photos[i], dx, dy, canvas_width, canvas_height, false,
+                                job, job_context);
+                            if (job.get_local_settings().is_print_titles_enabled()) {
+                                add_title_to_canvas(dx + canvas_width / 2, dy + canvas_height, 
+                                    photos[i].get_name(), job, job_context);
+                            }
+                        }
+                        
+                        if (progress_dialog != null)
+                            progress_dialog.monitor(i, photos.size);
+                    }
+                }
+            break;
+            
+            default:
+                error("unknown or unsupported layout mode");
+        }
+    }
+
+    private unowned Object on_create_custom_widget(Gtk.PrintOperation emitting_object) {
+        custom_tab = new CustomPrintTab((PrintJob) emitting_object);
+        ((PrintJob) emitting_object).custom_widget_apply.connect(on_custom_widget_apply);
+        return custom_tab;
+    }
+
+    private void on_custom_widget_apply(Gtk.Widget custom_widget) {
+        CustomPrintTab tab = (CustomPrintTab) custom_widget;
+        tab.get_source_job().set_local_settings(tab.get_local_settings());
+        set_global_settings(tab.get_local_settings());
+    }
+
+    private void fit_image_to_canvas(Photo photo, double x, double y, double canvas_width, double canvas_height, bool crop, PrintJob job, Gtk.PrintContext job_context) {
+        Cairo.Context dc = job_context.get_cairo_context();
+        Dimensions photo_dimensions = photo.get_dimensions();
+        double photo_aspect_ratio = photo_dimensions.get_aspect_ratio();
+        double canvas_aspect_ratio = ((double) canvas_width) / canvas_height;
+
+        double target_width = 0.0;
+        double target_height = 0.0;
+        double dpi = job.get_local_settings().get_content_ppi();
+
+        if (!crop) {
+            if (canvas_aspect_ratio < photo_aspect_ratio) {
+                target_width = canvas_width;
+                target_height = target_width * (1.0 / photo_aspect_ratio);
+            } else {
+                target_height = canvas_height;
+                target_width = target_height * photo_aspect_ratio;
+            }
+            x += (canvas_width - target_width) / 2.0;
+            y += (canvas_height - target_height) / 2.0;
+        }
+        
+        double x_offset = dpi * x;
+        double y_offset = dpi * y;
+        dc.save();
+        dc.translate(x_offset, y_offset);
+
+        int w = (int) (dpi * canvas_width);
+        int h = (int) (dpi * canvas_height);
+        Dimensions viewport = Dimensions(w, h);
+
+        try {
+            if (crop && !are_approximately_equal(canvas_aspect_ratio, photo_aspect_ratio)) {
+                Scaling pixbuf_scaling = Scaling.to_fill_viewport(viewport);
+                Gdk.Pixbuf photo_pixbuf = photo.get_pixbuf(pixbuf_scaling);
+                Dimensions scaled_photo_dimensions = Dimensions.for_pixbuf(photo_pixbuf);
+                int shave_vertical = 0;
+                int shave_horizontal = 0;
+                if (canvas_aspect_ratio < photo_aspect_ratio) {
+                    shave_vertical = (int) ((scaled_photo_dimensions.width - (scaled_photo_dimensions.height * canvas_aspect_ratio)) / 2.0);
+                } else {
+                    shave_horizontal = (int) ((scaled_photo_dimensions.height - (scaled_photo_dimensions.width * (1.0 / canvas_aspect_ratio))) / 2.0);
+                }
+                Gdk.Pixbuf shaved_pixbuf = new Gdk.Pixbuf.subpixbuf(photo_pixbuf, shave_vertical,shave_horizontal, scaled_photo_dimensions.width - (2 * shave_vertical), scaled_photo_dimensions.height - (2 * shave_horizontal));
+
+                photo_pixbuf = pixbuf_scaling.perform_on_pixbuf(shaved_pixbuf, Gdk.InterpType.HYPER, true);
+                Gdk.cairo_set_source_pixbuf(dc, photo_pixbuf, 0.0, 0.0);
+            } else {
+                Scaling pixbuf_scaling = Scaling.for_viewport(viewport, true);
+                Gdk.Pixbuf photo_pixbuf = photo.get_pixbuf(pixbuf_scaling);
+                photo_pixbuf = pixbuf_scaling.perform_on_pixbuf(photo_pixbuf, Gdk.InterpType.HYPER, true);
+                Gdk.cairo_set_source_pixbuf(dc, photo_pixbuf, 0.0, 0.0);
+            }
+            dc.paint();
+
+        } catch (Error e) {
+            job.cancel();
+            AppWindow.error_message(_("Unable to print photo:\n\n%s").printf(e.message));
+        }
+        dc.restore();
+    }
+    
+    private void add_title_to_canvas(double x, double y, string title, PrintJob job, Gtk.PrintContext job_context) {
+        Cairo.Context dc = job_context.get_cairo_context();
+        double dpi = job.get_local_settings().get_content_ppi();
+        var title_font_description = Pango.FontDescription.from_string(job.get_local_settings().get_print_titles_font());
+        var title_layout = Pango.cairo_create_layout(dc);
+        Pango.Context context = title_layout.get_context();
+        Pango.cairo_context_set_resolution (context, dpi);
+        title_layout.set_font_description(title_font_description);
+        title_layout.set_text(title, -1);
+        int title_width, title_height;
+        title_layout.get_pixel_size(out title_width, out title_height);
+        double tx = dpi * x - title_width / 2;
+        double ty = dpi * y - title_height;
+
+        // Transparent title text background
+        dc.rectangle(tx - 10, ty + 2, title_width + 20, title_height);
+        dc.set_source_rgba(1, 1, 1, 1);
+        dc.set_line_width(2);
+        dc.stroke_preserve();
+        dc.set_source_rgba(1, 1, 1, 0.5);
+        dc.fill();
+        dc.set_source_rgba(0, 0, 0, 1);
+
+        dc.move_to(tx, ty + 2);
+        Pango.cairo_show_layout(dc, title_layout);
+    }
+    
+    private bool are_approximately_equal(double val1, double val2) {
+        double accept_err = 0.005;
+        return (Math.fabs(val1 - val2) <= accept_err);
+    }
+
+    public PrintSettings get_global_settings() {
+        return settings;
+    }
+
+    public void set_global_settings(PrintSettings settings) {
+        this.settings = settings;
+        settings.save();
+    }
+}