summaryrefslogtreecommitdiff
path: root/src/page-view.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-view.vala
parent0898b615a2ea01bd65aa1d560350b48bd036b5b6 (diff)
Imported Upstream version 3.1.5upstream/3.1.5
Diffstat (limited to 'src/page-view.vala')
-rw-r--r--src/page-view.vala1043
1 files changed, 1043 insertions, 0 deletions
diff --git a/src/page-view.vala b/src/page-view.vala
new file mode 100644
index 0000000..97bcaf0
--- /dev/null
+++ b/src/page-view.vala
@@ -0,0 +1,1043 @@
+/*
+ * 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 CropLocation
+{
+ NONE = 0,
+ MIDDLE,
+ TOP,
+ BOTTOM,
+ LEFT,
+ RIGHT,
+ TOP_LEFT,
+ TOP_RIGHT,
+ BOTTOM_LEFT,
+ BOTTOM_RIGHT
+}
+
+public class PageView
+{
+ /* Page being rendered */
+ private Page page;
+
+ /* Image to render at current resolution */
+ private Gdk.Pixbuf? image = null;
+
+ /* Border around image */
+ private bool selected;
+ private int border_width = 1;
+
+ /* True if image needs to be regenerated */
+ private bool update_image = true;
+
+ /* Direction of currently scanned image */
+ private ScanDirection scan_direction;
+
+ /* Next scan line to render */
+ private int scan_line;
+
+ /* Dimensions of image to generate */
+ private int width;
+ private int height;
+
+ /* Location to place this page */
+ private int x_offset;
+ private int y_offset;
+
+ private CropLocation crop_location;
+ private double selected_crop_px;
+ private double selected_crop_py;
+ private int selected_crop_x;
+ private int selected_crop_y;
+ private int selected_crop_w;
+ private int selected_crop_h;
+
+ /* Cursor over this page */
+ private Gdk.CursorType cursor = Gdk.CursorType.ARROW;
+
+ private int animate_n_segments = 7;
+ private int animate_segment;
+ private uint animate_timeout;
+
+ public signal void size_changed ();
+ public signal void changed ();
+
+ public PageView (Page page)
+ {
+ this.page = page;
+ page.pixels_changed.connect (page_pixels_changed_cb);
+ page.size_changed.connect (page_size_changed_cb);
+ page.crop_changed.connect (page_overlay_changed_cb);
+ page.scan_line_changed.connect (page_overlay_changed_cb);
+ page.scan_direction_changed.connect (scan_direction_changed_cb);
+ }
+
+ public Page get_page ()
+ {
+ return page;
+ }
+
+ public void set_selected (bool selected)
+ {
+ if ((this.selected && selected) || (!this.selected && !selected))
+ return;
+ this.selected = selected;
+ changed ();
+ }
+
+ public bool get_selected ()
+ {
+ return selected;
+ }
+
+ public void set_x_offset (int offset)
+ {
+ x_offset = offset;
+ }
+
+ public void set_y_offset (int offset)
+ {
+ y_offset = offset;
+ }
+
+ public int get_x_offset ()
+ {
+ return x_offset;
+ }
+
+ public int get_y_offset ()
+ {
+ return y_offset;
+ }
+
+ private uchar get_sample (uchar[] pixels, int offset, int x, int depth, int sample)
+ {
+ // FIXME
+ return 0xFF;
+ }
+
+ private void get_pixel (Page page, int x, int y, uchar[] pixel)
+ {
+ switch (page.get_scan_direction ())
+ {
+ case ScanDirection.TOP_TO_BOTTOM:
+ break;
+ case ScanDirection.BOTTOM_TO_TOP:
+ x = page.get_scan_width () - x - 1;
+ y = page.get_scan_height () - y - 1;
+ break;
+ case ScanDirection.LEFT_TO_RIGHT:
+ var t = x;
+ x = page.get_scan_width () - y - 1;
+ y = t;
+ break;
+ case ScanDirection.RIGHT_TO_LEFT:
+ var t = x;
+ x = y;
+ y = page.get_scan_height () - t - 1;
+ break;
+ }
+
+ var depth = page.get_depth ();
+ var n_channels = page.get_n_channels ();
+ unowned uchar[] pixels = page.get_pixels ();
+ var offset = page.get_rowstride () * y;
+
+ /* Optimise for 8 bit images */
+ if (depth == 8 && n_channels == 3)
+ {
+ var o = offset + x * n_channels;
+ pixel[0] = pixels[o];
+ pixel[1] = pixels[o+1];
+ pixel[2] = pixels[o+2];
+ return;
+ }
+ else if (depth == 8 && n_channels == 1)
+ {
+ pixel[0] = pixel[1] = pixel[2] = pixels[offset + x];
+ return;
+ }
+
+ /* Optimise for bitmaps */
+ else if (depth == 1 && n_channels == 1)
+ {
+ var o = offset + (x / 8);
+ pixel[0] = pixel[1] = pixel[2] = (pixels[o] & (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 o = offset + (x / 4);
+ var sample = (pixels[o] >> block_shift[x % 4]) & 0x3;
+ sample = sample * 255 / 3;
+
+ pixel[0] = pixel[1] = pixel[2] = (uchar) sample;
+ return;
+ }
+
+ /* Use slow method */
+ pixel[0] = get_sample (pixels, offset, x, depth, x * n_channels);
+ pixel[1] = get_sample (pixels, offset, x, depth, x * n_channels + 1);
+ pixel[2] = get_sample (pixels, offset, x, depth, x * n_channels + 2);
+ }
+
+ private void set_pixel (Page page, double l, double r, double t, double b, uchar[] output, int offset)
+ {
+ /* Decimation:
+ *
+ * Target pixel is defined by (t,l)-(b,r)
+ * It touches 16 pixels in original image
+ * It completely covers 4 pixels in original image (T,L)-(B,R)
+ * Add covered pixels and add weighted partially covered pixels.
+ * Divide by total area.
+ *
+ * l L R r
+ * +-----+-----+-----+-----+
+ * | | | | |
+ * t | +--+-----+-----+---+ |
+ * T +--+--+-----+-----+---+-+
+ * | | | | | | |
+ * | | | | | | |
+ * +--+--+-----+-----+---+-+
+ * | | | | | | |
+ * | | | | | | |
+ * B +--+--+-----+-----+---+-+
+ * | | | | | | |
+ * b | +--+-----+-----+---+ |
+ * +-----+-----+-----+-----+
+ *
+ *
+ * Interpolation:
+ *
+ * l r
+ * +-----+-----+-----+-----+
+ * | | | | |
+ * | | | | |
+ * +-----+-----+-----+-----+
+ * t | | +-+--+ | |
+ * | | | | | | |
+ * +-----+---+-+--+--+-----+
+ * b | | +-+--+ | |
+ * | | | | |
+ * +-----+-----+-----+-----+
+ * | | | | |
+ * | | | | |
+ * +-----+-----+-----+-----+
+ *
+ * Same again, just no completely covered pixels.
+ */
+
+ var L = (int) l;
+ if (L != l)
+ L++;
+ var R = (int) r;
+ var T = (int) t;
+ if (T != t)
+ T++;
+ var B = (int) b;
+
+ var red = 0.0;
+ var green = 0.0;
+ var blue = 0.0;
+
+ /* Target can fit inside one source pixel
+ * +-----+
+ * | |
+ * | +--+| +-----+-----+ +-----+ +-----+ +-----+
+ * +-+--++ or | +-++ | or | +-+ | or | +--+| or | +--+
+ * | +--+| | +-++ | | +-+ | | | || | | |
+ * | | +-----+-----+ +-----+ +-+--++ +--+--+
+ * +-----+
+ */
+ if ((r - l <= 1.0 && (int)r == (int)l) || (b - t <= 1.0 && (int)b == (int)t))
+ {
+ /* Inside */
+ if ((int)l == (int)r || (int)t == (int)b)
+ {
+ uchar p[3];
+ get_pixel (page, (int)l, (int)t, p);
+ output[offset] = p[0];
+ output[offset+1] = p[1];
+ output[offset+2] = p[2];
+ return;
+ }
+
+ /* Stradling horizontal edge */
+ if (L > R)
+ {
+ uchar p[3];
+ get_pixel (page, R, T-1, p);
+ red += p[0] * (r-l)*(T-t);
+ green += p[1] * (r-l)*(T-t);
+ blue += p[2] * (r-l)*(T-t);
+ for (var y = T; y < B; y++)
+ {
+ get_pixel (page, R, y, p);
+ red += p[0] * (r-l);
+ green += p[1] * (r-l);
+ blue += p[2] * (r-l);
+ }
+ get_pixel (page, R, B, p);
+ red += p[0] * (r-l)*(b-B);
+ green += p[1] * (r-l)*(b-B);
+ blue += p[2] * (r-l)*(b-B);
+ }
+ /* Stradling vertical edge */
+ else
+ {
+ uchar p[3];
+ get_pixel (page, L - 1, B, p);
+ red += p[0] * (b-t)*(L-l);
+ green += p[1] * (b-t)*(L-l);
+ blue += p[2] * (b-t)*(L-l);
+ for (var x = L; x < R; x++) {
+ get_pixel (page, x, B, p);
+ red += p[0] * (b-t);
+ green += p[1] * (b-t);
+ blue += p[2] * (b-t);
+ }
+ get_pixel (page, R, B, p);
+ red += p[0] * (b-t)*(r-R);
+ green += p[1] * (b-t)*(r-R);
+ blue += p[2] * (b-t)*(r-R);
+ }
+
+ var scale = 1.0 / ((r - l) * (b - t));
+ output[offset] = (uchar)(red * scale + 0.5);
+ output[offset+1] = (uchar)(green * scale + 0.5);
+ output[offset+2] = (uchar)(blue * scale + 0.5);
+ return;
+ }
+
+ /* Add the middle pixels */
+ for (var x = L; x < R; x++)
+ {
+ for (var y = T; y < B; y++)
+ {
+ uchar p[3];
+ get_pixel (page, x, y, p);
+ red += p[0];
+ green += p[1];
+ blue += p[2];
+ }
+ }
+
+ /* Add the weighted top and bottom pixels */
+ for (var x = L; x < R; x++)
+ {
+ if (t != T)
+ {
+ uchar p[3];
+ get_pixel (page, x, T - 1, p);
+ red += p[0] * (T - t);
+ green += p[1] * (T - t);
+ blue += p[2] * (T - t);
+ }
+
+ if (b != B)
+ {
+ uchar p[3];
+ get_pixel (page, x, B, p);
+ red += p[0] * (b - B);
+ green += p[1] * (b - B);
+ blue += p[2] * (b - B);
+ }
+ }
+
+ /* Add the left and right pixels */
+ for (var y = T; y < B; y++)
+ {
+ if (l != L)
+ {
+ uchar p[3];
+ get_pixel (page, L - 1, y, p);
+ red += p[0] * (L - l);
+ green += p[1] * (L - l);
+ blue += p[2] * (L - l);
+ }
+
+ if (r != R)
+ {
+ uchar p[3];
+ get_pixel (page, R, y, p);
+ red += p[0] * (r - R);
+ green += p[1] * (r - R);
+ blue += p[2] * (r - R);
+ }
+ }
+
+ /* Add the corner pixels */
+ if (l != L && t != T)
+ {
+ uchar p[3];
+ get_pixel (page, L - 1, T - 1, p);
+ red += p[0] * (L - l)*(T - t);
+ green += p[1] * (L - l)*(T - t);
+ blue += p[2] * (L - l)*(T - t);
+ }
+ if (r != R && t != T)
+ {
+ uchar p[3];
+ get_pixel (page, R, T - 1, p);
+ red += p[0] * (r - R)*(T - t);
+ green += p[1] * (r - R)*(T - t);
+ blue += p[2] * (r - R)*(T - t);
+ }
+ if (r != R && b != B)
+ {
+ uchar p[3];
+ get_pixel (page, R, B, p);
+ red += p[0] * (r - R)*(b - B);
+ green += p[1] * (r - R)*(b - B);
+ blue += p[2] * (r - R)*(b - B);
+ }
+ if (l != L && b != B)
+ {
+ uchar p[3];
+ get_pixel (page, L - 1, B, p);
+ red += p[0] * (L - l)*(b - B);
+ green += p[1] * (L - l)*(b - B);
+ blue += p[2] * (L - l)*(b - B);
+ }
+
+ /* Scale pixel values and clamp in range [0, 255] */
+ var scale = 1.0 / ((r - l) * (b - t));
+ output[offset] = (uchar)(red * scale + 0.5);
+ output[offset+1] = (uchar)(green * scale + 0.5);
+ output[offset+2] = (uchar)(blue * scale + 0.5);
+ }
+
+ private void update_preview (Page page, ref Gdk.Pixbuf? output_image, int output_width, int output_height,
+ ScanDirection scan_direction, int old_scan_line, int scan_line)
+ {
+ var input_width = page.get_width ();
+ var input_height = page.get_height ();
+
+ /* Create new image if one does not exist or has changed size */
+ int L, R, T, B;
+ if (output_image == null ||
+ output_image.get_width () != output_width ||
+ output_image.get_height () != output_height)
+ {
+ output_image = new Gdk.Pixbuf (Gdk.Colorspace.RGB,
+ false,
+ 8,
+ output_width,
+ output_height);
+
+ /* Update entire image */
+ L = 0;
+ R = output_width - 1;
+ T = 0;
+ B = output_height - 1;
+ }
+ /* Otherwise only update changed area */
+ else
+ {
+ switch (scan_direction)
+ {
+ case ScanDirection.TOP_TO_BOTTOM:
+ L = 0;
+ R = output_width - 1;
+ T = (int)((double)old_scan_line * output_height / input_height);
+ B = (int)((double)scan_line * output_height / input_height + 0.5);
+ break;
+ case ScanDirection.LEFT_TO_RIGHT:
+ L = (int)((double)old_scan_line * output_width / input_width);
+ R = (int)((double)scan_line * output_width / input_width + 0.5);
+ T = 0;
+ B = output_height - 1;
+ break;
+ case ScanDirection.BOTTOM_TO_TOP:
+ L = 0;
+ R = output_width - 1;
+ T = (int)((double)(input_height - scan_line) * output_height / input_height);
+ B = (int)((double)(input_height - old_scan_line) * output_height / input_height + 0.5);
+ break;
+ case ScanDirection.RIGHT_TO_LEFT:
+ L = (int)((double)(input_width - scan_line) * output_width / input_width);
+ R = (int)((double)(input_width - old_scan_line) * output_width / input_width + 0.5);
+ T = 0;
+ B = output_height - 1;
+ break;
+ default:
+ L = R = B = T = 0;
+ break;
+ }
+ }
+
+ /* FIXME: There's an off by one error in there somewhere... */
+ if (R >= output_width)
+ R = output_width - 1;
+ if (B >= output_height)
+ B = output_height - 1;
+
+ return_if_fail (L >= 0);
+ return_if_fail (R < output_width);
+ return_if_fail (T >= 0);
+ return_if_fail (B < output_height);
+ return_if_fail (output_image != null);
+
+ unowned uchar[] output = output_image.get_pixels ();
+ var output_rowstride = output_image.get_rowstride ();
+ var output_n_channels = output_image.get_n_channels ();
+
+ if (!page.has_data ())
+ {
+ for (var x = L; x <= R; x++)
+ for (var y = T; y <= B; y++)
+ {
+ var o = output_rowstride * y + x * output_n_channels;
+ output[o] = output[o+1] = output[o+2] = 0xFF;
+ }
+ return;
+ }
+
+ /* Update changed area */
+ for (var x = L; x <= R; x++)
+ {
+ var l = (double)x * input_width / output_width;
+ var r = (double)(x + 1) * input_width / output_width;
+
+ for (var y = T; y <= B; y++)
+ {
+ var t = (double)y * input_height / output_height;
+ var b = (double)(y + 1) * input_height / output_height;
+
+ set_pixel (page,
+ l, r, t, b,
+ output, output_rowstride * y + x * output_n_channels);
+ }
+ }
+ }
+
+ private int get_preview_width ()
+ {
+ return width - border_width * 2;
+ }
+
+ private int get_preview_height ()
+ {
+ return height - border_width * 2;
+ }
+
+ private void update_page_view ()
+ {
+ if (!update_image)
+ return;
+
+ var old_scan_line = scan_line;
+ var scan_line = page.get_scan_line ();
+
+ /* Delete old image if scan direction changed */
+ var left_steps = scan_direction - page.get_scan_direction ();
+ if (left_steps != 0 && image != null)
+ image = null;
+ scan_direction = page.get_scan_direction ();
+
+ update_preview (page,
+ ref image,
+ get_preview_width (),
+ get_preview_height (),
+ page.get_scan_direction (), old_scan_line, scan_line);
+
+ update_image = false;
+ this.scan_line = scan_line;
+ }
+
+ private int page_to_screen_x (int x)
+ {
+ return (int) ((double)x * get_preview_width () / page.get_width () + 0.5);
+ }
+
+ private int page_to_screen_y (int y)
+ {
+ return (int) ((double)y * get_preview_height () / page.get_height () + 0.5);
+ }
+
+ private int screen_to_page_x (int x)
+ {
+ return (int) ((double)x * page.get_width () / get_preview_width () + 0.5);
+ }
+
+ private int screen_to_page_y (int y)
+ {
+ return (int) ((double)y * page.get_height () / get_preview_height () + 0.5);
+ }
+
+ private CropLocation get_crop_location (int x, int y)
+ {
+ if (!page.has_crop ())
+ return 0;
+
+ int cx, cy, cw, ch;
+ page.get_crop (out cx, out cy, out cw, out ch);
+ var dx = page_to_screen_x (cx);
+ var dy = page_to_screen_y (cy);
+ var dw = page_to_screen_x (cw);
+ var dh = page_to_screen_y (ch);
+ var ix = x - dx;
+ var iy = y - dy;
+
+ if (ix < 0 || ix > dw || iy < 0 || iy > dh)
+ return CropLocation.NONE;
+
+ /* Can't resize named crops */
+ var name = page.get_named_crop ();
+ if (name != null)
+ return CropLocation.MIDDLE;
+
+ /* Adjust borders so can select */
+ int crop_border = 20;
+ if (dw < crop_border * 3)
+ crop_border = dw / 3;
+ if (dh < crop_border * 3)
+ crop_border = dh / 3;
+
+ /* Top left */
+ if (ix < crop_border && iy < crop_border)
+ return CropLocation.TOP_LEFT;
+ /* Top right */
+ if (ix > dw - crop_border && iy < crop_border)
+ return CropLocation.TOP_RIGHT;
+ /* Bottom left */
+ if (ix < crop_border && iy > dh - crop_border)
+ return CropLocation.BOTTOM_LEFT;
+ /* Bottom right */
+ if (ix > dw - crop_border && iy > dh - crop_border)
+ return CropLocation.BOTTOM_RIGHT;
+
+ /* Left */
+ if (ix < crop_border)
+ return CropLocation.LEFT;
+ /* Right */
+ if (ix > dw - crop_border)
+ return CropLocation.RIGHT;
+ /* Top */
+ if (iy < crop_border)
+ return CropLocation.TOP;
+ /* Bottom */
+ if (iy > dh - crop_border)
+ return CropLocation.BOTTOM;
+
+ /* In the middle */
+ return CropLocation.MIDDLE;
+ }
+
+ public void button_press (int x, int y)
+ {
+ CropLocation location;
+
+ /* See if selecting crop */
+ location = get_crop_location (x, y);;
+ if (location != CropLocation.NONE)
+ {
+ crop_location = location;
+ selected_crop_px = x;
+ selected_crop_py = y;
+ page.get_crop (out selected_crop_x,
+ out selected_crop_y,
+ out selected_crop_w,
+ out selected_crop_h);
+ }
+ }
+
+ public void motion (int x, int y)
+ {
+ var location = get_crop_location (x, y);
+ Gdk.CursorType cursor;
+ switch (location)
+ {
+ case CropLocation.MIDDLE:
+ cursor = Gdk.CursorType.HAND1;
+ break;
+ case CropLocation.TOP:
+ cursor = Gdk.CursorType.TOP_SIDE;
+ break;
+ case CropLocation.BOTTOM:
+ cursor = Gdk.CursorType.BOTTOM_SIDE;
+ break;
+ case CropLocation.LEFT:
+ cursor = Gdk.CursorType.LEFT_SIDE;
+ break;
+ case CropLocation.RIGHT:
+ cursor = Gdk.CursorType.RIGHT_SIDE;
+ break;
+ case CropLocation.TOP_LEFT:
+ cursor = Gdk.CursorType.TOP_LEFT_CORNER;
+ break;
+ case CropLocation.TOP_RIGHT:
+ cursor = Gdk.CursorType.TOP_RIGHT_CORNER;
+ break;
+ case CropLocation.BOTTOM_LEFT:
+ cursor = Gdk.CursorType.BOTTOM_LEFT_CORNER;
+ break;
+ case CropLocation.BOTTOM_RIGHT:
+ cursor = Gdk.CursorType.BOTTOM_RIGHT_CORNER;
+ break;
+ default:
+ cursor = Gdk.CursorType.ARROW;
+ break;
+ }
+
+ if (crop_location == CropLocation.NONE)
+ {
+ this.cursor = cursor;
+ return;
+ }
+
+ /* Move the crop */
+ var pw = page.get_width ();
+ var ph = page.get_height ();
+ int cx, cy, cw, ch;
+ page.get_crop (out cx, out cy, out cw, out ch);
+
+ var dx = screen_to_page_x (x - (int) selected_crop_px);
+ var dy = screen_to_page_y (y - (int) selected_crop_py);
+
+ var new_x = selected_crop_x;
+ var new_y = selected_crop_y;
+ var new_w = selected_crop_w;
+ var new_h = selected_crop_h;
+
+ /* Limit motion to remain within page and minimum crop size */
+ var min_size = screen_to_page_x (15);
+ if (crop_location == CropLocation.TOP_LEFT ||
+ crop_location == CropLocation.LEFT ||
+ crop_location == CropLocation.BOTTOM_LEFT)
+ {
+ if (dx > new_w - min_size)
+ dx = new_w - min_size;
+ if (new_x + dx < 0)
+ dx = -new_x;
+ }
+ if (crop_location == CropLocation.TOP_LEFT ||
+ crop_location == CropLocation.TOP ||
+ crop_location == CropLocation.TOP_RIGHT)
+ {
+ if (dy > new_h - min_size)
+ dy = new_h - min_size;
+ if (new_y + dy < 0)
+ dy = -new_y;
+ }
+
+ if (crop_location == CropLocation.TOP_RIGHT ||
+ crop_location == CropLocation.RIGHT ||
+ crop_location == CropLocation.BOTTOM_RIGHT)
+ {
+ if (dx < min_size - new_w)
+ dx = min_size - new_w;
+ if (new_x + new_w + dx > pw)
+ dx = pw - new_x - new_w;
+ }
+ if (crop_location == CropLocation.BOTTOM_LEFT ||
+ crop_location == CropLocation.BOTTOM ||
+ crop_location == CropLocation.BOTTOM_RIGHT)
+ {
+ if (dy < min_size - new_h)
+ dy = min_size - new_h;
+ if (new_y + new_h + dy > ph)
+ dy = ph - new_y - new_h;
+ }
+ if (crop_location == CropLocation.MIDDLE)
+ {
+ if (new_x + dx + new_w > pw)
+ dx = pw - new_x - new_w;
+ if (new_x + dx < 0)
+ dx = -new_x;
+ if (new_y + dy + new_h > ph)
+ dy = ph - new_y - new_h;
+ if (new_y + dy < 0)
+ dy = -new_y;
+ }
+
+ /* Move crop */
+ if (crop_location == CropLocation.MIDDLE)
+ {
+ new_x += dx;
+ new_y += dy;
+ }
+ if (crop_location == CropLocation.TOP_LEFT ||
+ crop_location == CropLocation.LEFT ||
+ crop_location == CropLocation.BOTTOM_LEFT)
+ {
+ new_x += dx;
+ new_w -= dx;
+ }
+ if (crop_location == CropLocation.TOP_LEFT ||
+ crop_location == CropLocation.TOP ||
+ crop_location == CropLocation.TOP_RIGHT)
+ {
+ new_y += dy;
+ new_h -= dy;
+ }
+
+ if (crop_location == CropLocation.TOP_RIGHT ||
+ crop_location == CropLocation.RIGHT ||
+ crop_location == CropLocation.BOTTOM_RIGHT)
+ new_w += dx;
+ if (crop_location == CropLocation.BOTTOM_LEFT ||
+ crop_location == CropLocation.BOTTOM ||
+ crop_location == CropLocation.BOTTOM_RIGHT)
+ new_h += dy;
+
+ page.move_crop (new_x, new_y);
+
+ /* If reshaped crop, must be a custom crop */
+ if (new_w != cw || new_h != ch)
+ page.set_custom_crop (new_w, new_h);
+ }
+
+ public void button_release (int x, int y)
+ {
+ /* Complete crop */
+ crop_location = CropLocation.NONE;
+ changed ();
+ }
+
+ public Gdk.CursorType get_cursor ()
+ {
+ return cursor;
+ }
+
+ private bool animation_cb ()
+ {
+ animate_segment = (animate_segment + 1) % animate_n_segments;
+ changed ();
+ return true;
+ }
+
+ private void update_animation ()
+ {
+ bool animate, is_animating;
+
+ animate = page.is_scanning () && !page.has_data ();
+ is_animating = animate_timeout != 0;
+ if (animate == is_animating)
+ return;
+
+ if (animate)
+ {
+ animate_segment = 0;
+ if (animate_timeout == 0)
+ animate_timeout = Timeout.add (150, animation_cb);
+ }
+ else
+ {
+ if (animate_timeout != 0)
+ Source.remove (animate_timeout);
+ animate_timeout = 0;
+ }
+ }
+
+ public void render (Cairo.Context context)
+ {
+ update_animation ();
+ update_page_view ();
+
+ var w = get_preview_width ();
+ var h = get_preview_height ();
+
+ context.set_line_width (1);
+ context.translate (x_offset, y_offset);
+
+ /* Draw page border */
+ context.set_source_rgb (0, 0, 0);
+ context.set_line_width (border_width);
+ context.rectangle ((double)border_width / 2,
+ (double)border_width / 2,
+ width - border_width,
+ height - border_width);
+ context.stroke ();
+
+ /* Draw image */
+ context.translate (border_width, border_width);
+ Gdk.cairo_set_source_pixbuf (context, image, 0, 0);
+ context.paint ();
+
+ /* Draw throbber */
+ if (page.is_scanning () && !page.has_data ())
+ {
+ double outer_radius;
+ if (w > h)
+ outer_radius = 0.15 * w;
+ else
+ outer_radius = 0.15 * h;
+ var arc = Math.PI / animate_n_segments;
+
+ /* Space circles */
+ var x = outer_radius * Math.sin (arc);
+ var y = outer_radius * (Math.cos (arc) - 1.0);
+ var inner_radius = 0.6 * Math.sqrt (x*x + y*y);
+
+ double offset = 0.0;
+ for (var i = 0; i < animate_n_segments; i++, offset += arc * 2)
+ {
+ x = w / 2 + outer_radius * Math.sin (offset);
+ y = h / 2 - outer_radius * Math.cos (offset);
+ context.arc (x, y, inner_radius, 0, 2 * Math.PI);
+
+ if (i == animate_segment)
+ {
+ context.set_source_rgb (0.75, 0.75, 0.75);
+ context.fill_preserve ();
+ }
+
+ context.set_source_rgb (0.5, 0.5, 0.5);
+ context.stroke ();
+ }
+ }
+
+ /* Draw scan line */
+ if (page.is_scanning () && page.get_scan_line () > 0)
+ {
+ var scan_line = page.get_scan_line ();
+
+ double s;
+ double x1, y1, x2, y2;
+ switch (page.get_scan_direction ())
+ {
+ case ScanDirection.TOP_TO_BOTTOM:
+ s = page_to_screen_y (scan_line);
+ x1 = 0; y1 = s + 0.5;
+ x2 = w; y2 = s + 0.5;
+ break;
+ case ScanDirection.BOTTOM_TO_TOP:
+ s = page_to_screen_y (scan_line);
+ x1 = 0; y1 = h - s + 0.5;
+ x2 = w; y2 = h - s + 0.5;
+ break;
+ case ScanDirection.LEFT_TO_RIGHT:
+ s = page_to_screen_x (scan_line);
+ x1 = s + 0.5; y1 = 0;
+ x2 = s + 0.5; y2 = h;
+ break;
+ case ScanDirection.RIGHT_TO_LEFT:
+ s = page_to_screen_x (scan_line);
+ x1 = w - s + 0.5; y1 = 0;
+ x2 = w - s + 0.5; y2 = h;
+ break;
+ default:
+ x1 = y1 = x2 = y2 = 0;
+ break;
+ }
+
+ context.move_to (x1, y1);
+ context.line_to (x2, y2);
+ context.set_source_rgb (1.0, 0.0, 0.0);
+ context.stroke ();
+ }
+
+ /* Draw crop */
+ if (page.has_crop ())
+ {
+ int x, y, crop_width, crop_height;
+ page.get_crop (out x, out y, out crop_width, out crop_height);
+
+ var dx = page_to_screen_x (x);
+ var dy = page_to_screen_y (y);
+ var dw = page_to_screen_x (crop_width);
+ var dh = page_to_screen_y (crop_height);
+
+ /* Shade out cropped area */
+ context.rectangle (0, 0, w, h);
+ context.new_sub_path ();
+ context.rectangle (dx, dy, dw, dh);
+ context.set_fill_rule (Cairo.FillRule.EVEN_ODD);
+ context.set_source_rgba (0.25, 0.25, 0.25, 0.2);
+ context.fill ();
+
+ /* Show new edge */
+ context.rectangle (dx - 1.5, dy - 1.5, dw + 3, dh + 3);
+ context.set_source_rgb (1.0, 1.0, 1.0);
+ context.stroke ();
+ context.rectangle (dx - 0.5, dy - 0.5, dw + 1, dh + 1);
+ context.set_source_rgb (0.0, 0.0, 0.0);
+ context.stroke ();
+ }
+ }
+
+ public void set_width (int width)
+ {
+ // FIXME: Automatically update when get updated image
+ var height = (int) ((double)width * page.get_height () / page.get_width ());
+ if (this.width == width && this.height == height)
+ return;
+
+ this.width = width;
+ this.height = height;
+
+ /* Regenerate image */
+ update_image = true;
+
+ size_changed ();
+ changed ();
+ }
+
+ public void set_height (int height)
+ {
+ // FIXME: Automatically update when get updated image
+ var width = (int) ((double)height * page.get_width () / page.get_height ());
+ if (this.width == width && this.height == height)
+ return;
+
+ this.width = width;
+ this.height = height;
+
+ /* Regenerate image */
+ update_image = true;
+
+ size_changed ();
+ changed ();
+ }
+
+ public int get_width ()
+ {
+ return width;
+ }
+
+ public int get_height ()
+ {
+ return height;
+ }
+
+ private void page_pixels_changed_cb (Page p)
+ {
+ /* Regenerate image */
+ update_image = true;
+ changed ();
+ }
+
+ private void page_size_changed_cb (Page p)
+ {
+ /* Regenerate image */
+ update_image = true;
+ size_changed ();
+ changed ();
+ }
+
+ private void page_overlay_changed_cb (Page p)
+ {
+ changed ();
+ }
+
+ private void scan_direction_changed_cb (Page p)
+ {
+ /* Regenerate image */
+ update_image = true;
+ size_changed ();
+ changed ();
+ }
+}