summaryrefslogtreecommitdiff
path: root/src/page.vala
diff options
context:
space:
mode:
authorAlessio Treglia <alessio@debian.org>2011-08-27 10:54:21 +0200
committerAlessio Treglia <alessio@debian.org>2011-08-27 10:54:21 +0200
commit87ebc2af1f0417b3bc38a233e28ff673eff4fa51 (patch)
tree747dd400400bf7593642d0ab321a4e37df2ee188 /src/page.vala
parent0898b615a2ea01bd65aa1d560350b48bd036b5b6 (diff)
Imported Upstream version 3.1.5upstream/3.1.5
Diffstat (limited to 'src/page.vala')
-rw-r--r--src/page.vala735
1 files changed, 735 insertions, 0 deletions
diff --git a/src/page.vala b/src/page.vala
new file mode 100644
index 0000000..ef7ddb6
--- /dev/null
+++ b/src/page.vala
@@ -0,0 +1,735 @@
+/*
+ * 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 enum ScanDirection
+{
+ TOP_TO_BOTTOM,
+ LEFT_TO_RIGHT,
+ BOTTOM_TO_TOP,
+ RIGHT_TO_LEFT
+}
+
+public class Page
+{
+ /* Resolution of page */
+ private int dpi;
+
+ /* Number of rows in this page or -1 if currently unknown */
+ private int expected_rows;
+
+ /* Bit depth */
+ private int depth;
+
+ /* Color profile */
+ private string? color_profile;
+
+ /* Scanned image data */
+ private int width;
+ private int n_rows;
+ private int rowstride;
+ private int n_channels;
+ private uchar[] pixels;
+
+ /* Page is getting data */
+ private bool scanning;
+
+ /* true if have some page data */
+ private bool has_data_;
+
+ /* Expected next scan row */
+ private int scan_line;
+
+ /* Rotation of scanned data */
+ private ScanDirection scan_direction = ScanDirection.TOP_TO_BOTTOM;
+
+ /* Crop */
+ private bool has_crop_;
+ private string? crop_name;
+ private int crop_x;
+ private int crop_y;
+ private int crop_width;
+ private int crop_height;
+
+ public signal void pixels_changed ();
+ public signal void size_changed ();
+ public signal void scan_line_changed ();
+ public signal void scan_direction_changed ();
+ public signal void crop_changed ();
+
+ public Page (int width, int height, int dpi, ScanDirection scan_direction)
+ {
+ if (scan_direction == ScanDirection.TOP_TO_BOTTOM || scan_direction == ScanDirection.BOTTOM_TO_TOP)
+ {
+ this.width = width;
+ n_rows = height;
+ }
+ else
+ {
+ this.width = height;
+ n_rows = width;
+ }
+ this.dpi = dpi;
+ this.scan_direction = scan_direction;
+ }
+
+ public void set_page_info (ScanPageInfo info)
+ {
+ expected_rows = info.height;
+ dpi = (int) info.dpi;
+
+ /* Create a white page */
+ width = info.width;
+ n_rows = info.height;
+ /* Variable height, try 50% of the width for now */
+ if (n_rows < 0)
+ n_rows = width / 2;
+ depth = info.depth;
+ n_channels = info.n_channels;
+ rowstride = (width * depth * n_channels + 7) / 8;
+ pixels.resize (n_rows * rowstride);
+ return_if_fail (pixels != null);
+
+ /* Fill with white */
+ if (depth == 1)
+ Memory.set (pixels, 0x00, n_rows * rowstride);
+ else
+ Memory.set (pixels, 0xFF, n_rows * rowstride);
+
+ size_changed ();
+ pixels_changed ();
+ }
+
+ public void start ()
+ {
+ scanning = true;
+ scan_line_changed ();
+ }
+
+ public bool is_scanning ()
+ {
+ return scanning;
+ }
+
+ public bool has_data ()
+ {
+ return has_data_;
+ }
+
+ public bool is_color ()
+ {
+ return n_channels > 1;
+ }
+
+ public int get_scan_line ()
+ {
+ return scan_line;
+ }
+
+ private void parse_line (ScanLine line, int n, out bool size_changed)
+ {
+ int line_number;
+
+ line_number = line.number + n;
+
+ /* Extend image if necessary */
+ size_changed = false;
+ while (line_number >= get_scan_height ())
+ {
+ int rows;
+
+ /* Extend image */
+ rows = n_rows;
+ n_rows = rows + width / 2;
+ debug ("Extending image from %d lines to %d lines", rows, n_rows);
+ pixels.resize (n_rows * rowstride);
+
+ size_changed = true;
+ }
+
+ /* Copy in new row */
+ var offset = line_number * rowstride;
+ var line_offset = n * line.data_length;
+ for (var i = 0; i < line.data_length; i++)
+ pixels[offset+i] = line.data[line_offset+i];
+
+ scan_line = line_number;
+ }
+
+ public void parse_scan_line (ScanLine line)
+ {
+ bool size_has_changed = false;
+ for (var i = 0; i < line.n_lines; i++)
+ parse_line (line, i, out size_has_changed);
+
+ has_data_ = true;
+
+ if (size_has_changed)
+ size_changed ();
+ scan_line_changed ();
+ pixels_changed ();
+ }
+
+ public void finish ()
+ {
+ bool size_has_changed = false;
+
+ /* Trim page */
+ if (expected_rows < 0 &&
+ scan_line != get_scan_height ())
+ {
+ int rows;
+
+ rows = n_rows;
+ n_rows = scan_line;
+ pixels.resize (n_rows * rowstride);
+ debug ("Trimming page from %d lines to %d lines", rows, n_rows);
+
+ size_has_changed = true;
+ }
+ scanning = false;
+
+ if (size_has_changed)
+ size_changed ();
+ scan_line_changed ();
+ }
+
+ public ScanDirection get_scan_direction ()
+ {
+ return scan_direction;
+ }
+
+ private void set_scan_direction (ScanDirection direction)
+ {
+ int left_steps, t;
+ bool size_has_changed = false;
+ int width, height;
+
+ if (scan_direction == direction)
+ return;
+
+ /* Work out how many times it has been rotated to the left */
+ left_steps = direction - scan_direction;
+ if (left_steps < 0)
+ left_steps += 4;
+ if (left_steps != 2)
+ size_has_changed = true;
+
+ width = get_width ();
+ height = get_height ();
+
+ /* Rotate crop */
+ if (has_crop_)
+ {
+ switch (left_steps)
+ {
+ /* 90 degrees counter-clockwise */
+ case 1:
+ t = crop_x;
+ crop_x = crop_y;
+ crop_y = width - (t + crop_width);
+ t = crop_width;
+ crop_width = crop_height;
+ crop_height = t;
+ break;
+ /* 180 degrees */
+ case 2:
+ crop_x = width - (crop_x + crop_width);
+ crop_y = width - (crop_y + crop_height);
+ break;
+ /* 90 degrees clockwise */
+ case 3:
+ t = crop_y;
+ crop_y = crop_x;
+ crop_x = height - (t + crop_height);
+ t = crop_width;
+ crop_width = crop_height;
+ crop_height = t;
+ break;
+ }
+ }
+
+ scan_direction = direction;
+ if (size_has_changed)
+ size_changed ();
+ scan_direction_changed ();
+ if (has_crop_)
+ crop_changed ();
+ }
+
+ public void rotate_left ()
+ {
+ var direction = scan_direction;
+ switch (direction)
+ {
+ case ScanDirection.TOP_TO_BOTTOM:
+ direction = ScanDirection.LEFT_TO_RIGHT;
+ break;
+ case ScanDirection.LEFT_TO_RIGHT:
+ direction = ScanDirection.BOTTOM_TO_TOP;
+ break;
+ case ScanDirection.BOTTOM_TO_TOP:
+ direction = ScanDirection.RIGHT_TO_LEFT;
+ break;
+ case ScanDirection.RIGHT_TO_LEFT:
+ direction = ScanDirection.TOP_TO_BOTTOM;
+ break;
+ }
+ set_scan_direction (direction);
+ }
+
+ public void rotate_right ()
+ {
+ var direction = scan_direction;
+ switch (direction)
+ {
+ case ScanDirection.TOP_TO_BOTTOM:
+ direction = ScanDirection.RIGHT_TO_LEFT;
+ break;
+ case ScanDirection.LEFT_TO_RIGHT:
+ direction = ScanDirection.TOP_TO_BOTTOM;
+ break;
+ case ScanDirection.BOTTOM_TO_TOP:
+ direction = ScanDirection.LEFT_TO_RIGHT;
+ break;
+ case ScanDirection.RIGHT_TO_LEFT:
+ direction = ScanDirection.BOTTOM_TO_TOP;
+ break;
+ }
+ set_scan_direction (direction);
+ }
+
+ public int get_dpi ()
+ {
+ return dpi;
+ }
+
+ public bool is_landscape ()
+ {
+ return get_width () > get_height ();
+ }
+
+ public int get_width ()
+ {
+ if (scan_direction == ScanDirection.TOP_TO_BOTTOM || scan_direction == ScanDirection.BOTTOM_TO_TOP)
+ return width;
+ else
+ return n_rows;
+ }
+
+ public int get_height ()
+ {
+ if (scan_direction == ScanDirection.TOP_TO_BOTTOM || scan_direction == ScanDirection.BOTTOM_TO_TOP)
+ return n_rows;
+ else
+ return width;
+ }
+
+ public int get_depth ()
+ {
+ return depth;
+ }
+
+ public int get_n_channels ()
+ {
+ return n_channels;
+ }
+
+ public int get_rowstride ()
+ {
+ return rowstride;
+ }
+
+ public int get_scan_width ()
+ {
+ return width;
+ }
+
+ public int get_scan_height ()
+ {
+ return n_rows;
+ }
+
+ public void set_color_profile (string? color_profile)
+ {
+ this.color_profile = color_profile;
+ }
+
+ public string get_color_profile ()
+ {
+ return color_profile;
+ }
+
+ public void set_no_crop ()
+ {
+ if (!has_crop_)
+ return;
+ has_crop_ = false;
+ crop_changed ();
+ }
+
+ public void set_custom_crop (int width, int height)
+ {
+ //int pw, ph;
+
+ return_if_fail (width >= 1);
+ return_if_fail (height >= 1);
+
+ if (crop_name == null && has_crop_ && crop_width == width && crop_height == height)
+ return;
+ crop_name = null;
+ has_crop_ = true;
+
+ crop_width = width;
+ crop_height = height;
+
+ /*pw = get_width ();
+ ph = get_height ();
+ if (crop_width < pw)
+ crop_x = (pw - crop_width) / 2;
+ else
+ crop_x = 0;
+ if (crop_height < ph)
+ crop_y = (ph - crop_height) / 2;
+ else
+ crop_y = 0;*/
+
+ crop_changed ();
+ }
+
+ public void set_named_crop (string name)
+ {
+ double width, height;
+ switch (name)
+ {
+ case "A4":
+ width = 8.3;
+ height = 11.7;
+ break;
+ case "A5":
+ width = 5.8;
+ height = 8.3;
+ break;
+ case "A6":
+ width = 4.1;
+ height = 5.8;
+ break;
+ case "letter":
+ width = 8.5;
+ height = 11;
+ break;
+ case "legal":
+ width = 8.5;
+ height = 14;
+ break;
+ case "4x6":
+ width = 4;
+ height = 6;
+ break;
+ default:
+ warning ("Unknown paper size '%s'", name);
+ return;
+ }
+
+ crop_name = name;
+ has_crop_ = true;
+
+ var pw = get_width ();
+ var ph = get_height ();
+
+ /* Rotate to match original aspect */
+ if (pw > ph)
+ {
+ double t;
+ t = width;
+ width = height;
+ height = t;
+ }
+
+ /* Custom crop, make slightly smaller than original */
+ crop_width = (int) (width * dpi + 0.5);
+ crop_height = (int) (height * dpi + 0.5);
+
+ if (crop_width < pw)
+ crop_x = (pw - crop_width) / 2;
+ else
+ crop_x = 0;
+ if (crop_height < ph)
+ crop_y = (ph - crop_height) / 2;
+ else
+ crop_y = 0;
+ crop_changed ();
+ }
+
+ public void move_crop (int x, int y)
+ {
+ return_if_fail (x >= 0);
+ return_if_fail (y >= 0);
+ return_if_fail (x < get_width ());
+ return_if_fail (y < get_height ());
+
+ crop_x = x;
+ crop_y = y;
+ crop_changed ();
+ }
+
+ public void rotate_crop ()
+ {
+ int t;
+
+ if (!has_crop_)
+ return;
+
+ t = crop_width;
+ crop_width = crop_height;
+ crop_height = t;
+
+ /* Clip custom crops */
+ if (crop_name == null)
+ {
+ int w, h;
+
+ w = get_width ();
+ h = get_height ();
+
+ if (crop_x + crop_width > w)
+ crop_x = w - crop_width;
+ if (crop_x < 0)
+ {
+ crop_x = 0;
+ crop_width = w;
+ }
+ if (crop_y + crop_height > h)
+ crop_y = h - crop_height;
+ if (crop_y < 0)
+ {
+ crop_y = 0;
+ crop_height = h;
+ }
+ }
+
+ crop_changed ();
+ }
+
+ public bool has_crop ()
+ {
+ return has_crop_;
+ }
+
+ public void get_crop (out int x, out int y, out int width, out int height)
+ {
+ x = crop_x;
+ y = crop_y;
+ width = crop_width;
+ height = crop_height;
+ }
+
+ public string get_named_crop ()
+ {
+ return crop_name;
+ }
+
+ public unowned uchar[] get_pixels ()
+ {
+ return pixels;
+ }
+
+ // FIXME: Copied from page-view, should be shared code
+ private uchar get_sample (uchar[] pixels, int offset, int x, int depth, int n_channels, int channel)
+ {
+ // FIXME
+ return 0xFF;
+ }
+
+ // FIXME: Copied from page-view, should be shared code
+ private void get_pixel (int x, int y, uchar[] pixel, int offset)
+ {
+ switch (get_scan_direction ())
+ {
+ case ScanDirection.TOP_TO_BOTTOM:
+ break;
+ case ScanDirection.BOTTOM_TO_TOP:
+ x = get_scan_width () - x - 1;
+ y = get_scan_height () - y - 1;
+ break;
+ case ScanDirection.LEFT_TO_RIGHT:
+ var t = x;
+ x = get_scan_width () - y - 1;
+ y = t;
+ break;
+ case ScanDirection.RIGHT_TO_LEFT:
+ var t = x;
+ x = y;
+ y = get_scan_height () - t - 1;
+ break;
+ }
+
+ var depth = get_depth ();
+ var n_channels = get_n_channels ();
+ var line_offset = get_rowstride () * y;
+
+ /* Optimise for 8 bit images */
+ if (depth == 8 && n_channels == 3)
+ {
+ var o = line_offset + x * n_channels;
+ pixel[offset+0] = pixels[o];
+ pixel[offset+1] = pixels[o+1];
+ pixel[offset+2] = pixels[o+2];
+ return;
+ }
+ else if (depth == 8 && n_channels == 1)
+ {
+ var p = pixels[line_offset + x];
+ pixel[offset+0] = pixel[offset+1] = pixel[offset+2] = p;
+ return;
+ }
+
+ /* Optimise for bitmaps */
+ else if (depth == 1 && n_channels == 1)
+ {
+ var p = pixels[line_offset + (x / 8)];
+ pixel[offset+0] = pixel[offset+1] = pixel[offset+2] = (p & (0x80 >> (x % 8))) != 0 ? 0x00 : 0xFF;
+ return;
+ }
+
+ /* Optimise for 2 bit images */
+ else if (depth == 2 && n_channels == 1)
+ {
+ int block_shift[4] = { 6, 4, 2, 0 };
+
+ var p = pixels[line_offset + (x / 4)];
+ var sample = (p >> block_shift[x % 4]) & 0x3;
+ sample = sample * 255 / 3;
+
+ pixel[offset+0] = pixel[offset+1] = pixel[offset+2] = (uchar) sample;
+ return;
+ }
+
+ /* Use slow method */
+ pixel[offset+0] = get_sample (pixels, line_offset, x, depth, n_channels, 0);
+ pixel[offset+1] = get_sample (pixels, line_offset, x, depth, n_channels, 1);
+ pixel[offset+2] = get_sample (pixels, line_offset, x, depth, n_channels, 2);
+ }
+
+ public Gdk.Pixbuf get_image (bool apply_crop)
+ {
+ int l, r, t, b;
+ if (apply_crop && has_crop_)
+ {
+ l = crop_x;
+ r = l + crop_width;
+ t = crop_y;
+ b = t + crop_height;
+
+ if (l < 0)
+ l = 0;
+ if (r > get_width ())
+ r = get_width ();
+ if (t < 0)
+ t = 0;
+ if (b > get_height ())
+ b = get_height ();
+ }
+ else
+ {
+ l = 0;
+ r = get_width ();
+ t = 0;
+ b = get_height ();
+ }
+
+ var image = new Gdk.Pixbuf (Gdk.Colorspace.RGB, false, 8, r - l, b - t);
+ unowned uint8[] image_pixels = image.get_pixels ();
+ for (var y = t; y < b; y++)
+ {
+ var offset = image.get_rowstride () * (y - t);
+ for (var x = l; x < r; x++)
+ get_pixel (x, y, image_pixels, offset + (x - l) * 3);
+ }
+
+ return image;
+ }
+
+ private string? get_icc_data_encoded (string icc_profile_filename)
+ {
+ /* Get binary data */
+ string contents;
+ try
+ {
+ FileUtils.get_contents (icc_profile_filename, out contents);
+ }
+ catch (Error e)
+ {
+ warning ("failed to get icc profile data: %s", e.message);
+ return null;
+ }
+
+ /* Encode into base64 */
+ return Base64.encode ((uchar[]) contents.to_utf8 ());
+ }
+
+ public void save (string type, File file) throws Error
+ {
+ var stream = file.replace (null, false, FileCreateFlags.NONE, null);
+ var writer = new PixbufWriter (stream);
+ var image = get_image (true);
+
+ string? icc_profile_data = null;
+ if (color_profile != null)
+ icc_profile_data = get_icc_data_encoded (color_profile);
+
+ if (strcmp (type, "jpeg") == 0)
+ {
+ /* ICC profile is awaiting review in gtk2+ bugzilla */
+ string[] keys = { "quality", /* "icc-profile", */ null };
+ string[] values = { "90", /* icc_profile_data, */ null };
+ writer.save (image, "jpeg", keys, values);
+ }
+ else if (strcmp (type, "png") == 0)
+ {
+ string[] keys = { "icc-profile", null };
+ string[] values = { icc_profile_data, null };
+ if (icc_profile_data == null)
+ keys[0] = null;
+ writer.save (image, "png", keys, values);
+ }
+ else if (strcmp (type, "tiff") == 0)
+ {
+ string[] keys = { "compression", "icc-profile", null };
+ string[] values = { "8" /* Deflate compression */, icc_profile_data, null };
+ if (icc_profile_data == null)
+ keys[1] = null;
+ writer.save (image, "tiff", keys, values);
+ }
+ else
+ ; // FIXME: Throw Error
+ }
+}
+
+public class PixbufWriter
+{
+ public FileOutputStream stream;
+
+ public PixbufWriter (FileOutputStream stream)
+ {
+ this.stream = stream;
+ }
+
+ public void save (Gdk.Pixbuf image, string type, string[] option_keys, string[] option_values) throws Error
+ {
+ image.save_to_callbackv (write_pixbuf_data, type, option_keys, option_values);
+ }
+
+ private bool write_pixbuf_data (uint8[] buf) throws Error
+ {
+ stream.write_all (buf, null, null);
+ return true;
+ }
+}