summaryrefslogtreecommitdiff
path: root/src/xsane-preview.c
diff options
context:
space:
mode:
authorAurelien Jarno <aurel32@debian.org>2005-02-03 16:24:20 +0100
committerMattia Rizzolo <mattia@mapreri.org>2014-10-03 14:05:06 +0000
commit825ef604db05e42ea267a86187bf62d54670c98c (patch)
treec41b8addd68e573fcf6ef599ec777e251a130b8e /src/xsane-preview.c
parentac8459519a9ef2a1ee635509b52a653da1bfe9d5 (diff)
parent817e6294b42b3e4435f1b99728afc1dca84a6445 (diff)
Imported Debian patch 0.97-3debian/0.97-3
Diffstat (limited to 'src/xsane-preview.c')
-rw-r--r--src/xsane-preview.c2328
1 files changed, 1872 insertions, 456 deletions
diff --git a/src/xsane-preview.c b/src/xsane-preview.c
index da81e3f..879bc99 100644
--- a/src/xsane-preview.c
+++ b/src/xsane-preview.c
@@ -3,7 +3,7 @@
xsane-preview.c
Oliver Rauch <Oliver.Rauch@rauch-domain.de>
- Copyright (C) 1998-2002 Oliver Rauch
+ Copyright (C) 1998-2005 Oliver Rauch
This file is part of the XSANE package.
This program is free software; you can redistribute it and/or modify
@@ -76,6 +76,7 @@
/* #include <sys/param.h> */
#include "xsane-back-gtk.h"
#include "xsane-front-gtk.h"
+#include "xsane-batch-scan.h"
#include "xsane-preview.h"
#include "xsane-preferences.h"
#include "xsane-gamma.h"
@@ -102,6 +103,11 @@
/* ---------------------------------------------------------------------------------------------------------------------- */
+#define XSANE_ZOOM_SIZE 80
+#define XSANE_ZOOM_FACTOR 4
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
static u_char *preview_gamma_data_red = 0;
static u_char *preview_gamma_data_green = 0;
static u_char *preview_gamma_data_blue = 0;
@@ -117,6 +123,8 @@ static u_char *histogram_medium_gamma_data_blue = 0;
static int preview_gamma_input_bits;
+static char *ratio_string[] = { "free", " 2:1", "16:9", "15:10", " 4:3", " 1:1", " 3:4", " 9:16", "10:15", " 1:2"};
+static float ratio_value[] = { 0.0, 2.0, 16.0/9.0, 15.0/10.0, 4.0/3.0, 1.0, 0.75, 0.5625, 10.0/15.0, 0.5 };
/* ---------------------------------------------------------------------------------------------------------------------- */
/* forward declarations */
@@ -161,14 +169,18 @@ static void preview_cancel_button_clicked(GtkWidget *widget, gpointer data);
static void preview_area_correct(Preview *p);
static void preview_save_image(Preview *p);
static void preview_delete_images(Preview *p);
+static void preview_select_zoom_point(Preview *p, int preview_x, int preview_y);
static void preview_zoom_not(GtkWidget *window, gpointer data);
static void preview_zoom_out(GtkWidget *window, gpointer data);
static void preview_zoom_in(GtkWidget *window, gpointer data);
+static void preview_zoom_area(GtkWidget *window, gpointer data);
static void preview_zoom_undo(GtkWidget *window, gpointer data);
static void preview_get_color(Preview *p, int x, int y, int range, int *red, int *green, int *blue);
+static void preview_add_batch(GtkWidget *window, Preview *p);
static void preview_pipette_white(GtkWidget *window, gpointer data);
static void preview_pipette_gray(GtkWidget *window, gpointer data);
static void preview_pipette_black(GtkWidget *window, gpointer data);
+static void preview_init_autoraise_scanarea(GtkWidget *window, gpointer data);
void preview_select_full_preview_area(Preview *p);
static void preview_full_preview_area_callback(GtkWidget *widget, gpointer call_data);
static void preview_delete_images_callback(GtkWidget *widget, gpointer call_data);
@@ -178,8 +190,10 @@ static gint preview_preset_area_delete_callback(GtkWidget *widget, GtkWidget *pr
static gint preview_preset_area_move_up_callback(GtkWidget *widget, GtkWidget *preset_area_widget);
static gint preview_preset_area_move_down_callback(GtkWidget *widget, GtkWidget *preset_area_widget);
static gint preview_preset_area_context_menu_callback(GtkWidget *widget, GdkEvent *event);
-static void preview_preset_area_callback(GtkWidget *widget, gpointer call_data);
-static void preview_rotation_callback(GtkWidget *widget, gpointer call_data);
+static void preview_preset_area_callback(GtkWidget *widget, gpointer data);
+static void preview_rotation_callback(GtkWidget *widget, gpointer data);
+static void preview_establish_ratio(Preview *p);
+static void preview_ratio_callback(GtkWidget *widget, gpointer data);
static void preview_autoselect_scanarea_callback(GtkWidget *window, gpointer data);
void preview_do_gamma_correction(Preview *p);
@@ -192,7 +206,8 @@ void preview_gamma_correction(Preview *p, int gamma_input_bits,
void preview_area_resize(Preview *p);
gint preview_area_resize_handler(GtkWidget *widget, GdkEvent *event, gpointer data);
void preview_update_maximum_output_size(Preview *p);
-void preview_set_maximum_output_size(Preview *p, float width, float height);
+void preview_set_maximum_output_size(Preview *p, float width, float height, int paper_orientation);
+void preview_autoraise_scanarea(Preview *p, int preview_x, int preview_y, float *autoselect_coord);
void preview_autoselect_scanarea(Preview *p, float *autoselect_coord);
void preview_display_valid(Preview *p);
@@ -574,16 +589,17 @@ static void preview_bound_selection(Preview *p)
if (p->selection.active)
{
-#if 0
+#if 1
xsane_bound_float(&p->selection.coordinate[0], p->scanner_surface[0], p->scanner_surface[2]);
xsane_bound_float(&p->selection.coordinate[2], p->scanner_surface[0], p->scanner_surface[2]);
xsane_bound_float(&p->selection.coordinate[1], p->scanner_surface[1], p->scanner_surface[3]);
xsane_bound_float(&p->selection.coordinate[3], p->scanner_surface[1], p->scanner_surface[3]);
-#endif
+#else
xsane_bound_float(&p->selection.coordinate[0], p->surface[0], p->surface[2]);
xsane_bound_float(&p->selection.coordinate[2], p->surface[0], p->surface[2]);
xsane_bound_float(&p->selection.coordinate[1], p->surface[1], p->surface[3]);
xsane_bound_float(&p->selection.coordinate[3], p->surface[1], p->surface[3]);
+#endif
}
}
@@ -1304,7 +1320,14 @@ static void preview_restore_option(Preview *p, int option, void *saved_value, in
{
char buf[256];
opt = xsane_get_option_descriptor(dev, option);
- snprintf(buf, sizeof(buf), "%s %s: %s.", ERR_SET_OPTION, opt->name, XSANE_STRSTATUS(status));
+ if (opt && opt->name)
+ {
+ snprintf(buf, sizeof(buf), "%s %s: %s.", ERR_SET_OPTION, opt->name, XSANE_STRSTATUS(status));
+ }
+ else
+ {
+ snprintf(buf, sizeof(buf), "%s %d: %s.", ERR_SET_OPTION, option, XSANE_STRSTATUS(status));
+ }
xsane_back_gtk_error(buf, TRUE);
}
}
@@ -1413,8 +1436,8 @@ static int preview_increment_image_y(Preview *p)
if ( (!p->image_data_enh) || (!p->image_data_raw) )
{
- preview_scan_done(p, 0);
snprintf(buf, sizeof(buf), "%s %s.", ERR_FAILED_ALLOCATE_IMAGE, strerror(errno));
+ preview_scan_done(p, 0);
xsane_back_gtk_error(buf, TRUE);
return -1;
}
@@ -1435,8 +1458,6 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
SANE_Handle dev;
SANE_Int len;
int i, j;
- int offset = 0;
- char last = 0;
DBG(DBG_proc, "preview_read_image_data\n");
@@ -1449,11 +1470,12 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
}
else if (p->params.depth == 16)
{
- if (offset)
+ if (p->read_offset_16)
{
- buf16[0] = last; /* ATTENTION: that is wrong! */
- /* use sizeof(buf) here because sizeof(buf16) returns the size of a pointer */
- status = sane_read(dev, ((SANE_Byte *) buf16) + 1, sizeof(buf) - 1, &len);
+ buf[0] = p->last_offset_16_byte;
+ /* use buf and sizeof(buf) here because sizeof(buf16) returns the size of a pointer */
+ status = sane_read(dev, buf+1, sizeof(buf) - 1, &len);
+ len++;
}
else
{
@@ -1463,18 +1485,18 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
if (len % 2) /* odd number of bytes */
{
len--;
- last = buf16[len];
- offset = 1;
+ p->last_offset_16_byte = buf16[len];
+ p->read_offset_16 = 1;
}
else /* even number of bytes */
{
- offset = 0;
+ p->read_offset_16 = 0;
}
}
else /* bad bitdepth */
{
- preview_scan_done(p, 0);
snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth);
+ preview_scan_done(p, 0);
xsane_back_gtk_error(buf, TRUE);
return;
}
@@ -1526,7 +1548,19 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
if (!len)
{
- break; /* out of data for now */
+ if (p->input_tag >= 0) /* we have a selecet fd */
+ {
+ break; /* leave preview_read_image_data, will be called by gdk when select_fd event occurs */
+ }
+ else
+ {
+ while (gtk_events_pending())
+ {
+ DBG(DBG_info, "preview_read_image_data: calling gtk_main_iteration\n");
+ gtk_main_iteration();
+ }
+ continue; /* we have to keep this loop running because it will never be called again */
+ }
}
switch (p->params.format)
@@ -1581,8 +1615,8 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
break;
default:
- preview_scan_done(p, 0);
snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth);
+ preview_scan_done(p, 0);
xsane_back_gtk_error(buf, TRUE);
return;
}
@@ -1678,8 +1712,8 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
break;
default:
- preview_scan_done(p, 0);
snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth);
+ preview_scan_done(p, 0);
xsane_back_gtk_error(buf, TRUE);
return;
}
@@ -1705,8 +1739,8 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
u_char gl = (mask & 1) ? 0xff : 0x00;
mask >>= 1;
- p->image_data_raw[p->image_offset] = gl * 256;
- p->image_data_enh[p->image_offset++] = gl;
+ p->image_data_raw[p->image_offset] = gl * 256;
+ p->image_data_enh[p->image_offset] = gl;
p->image_offset += 3;
if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0)
@@ -1756,16 +1790,16 @@ static void preview_read_image_data(gpointer data, gint source, GdkInputConditio
break;
default:
- preview_scan_done(p, 0);
snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth);
+ preview_scan_done(p, 0);
xsane_back_gtk_error(buf, TRUE);
return;
}
break;
default:
- preview_scan_done(p, 0);
snprintf(buf, sizeof(buf), "%s %d.", ERR_BAD_FRAME_FORMAT, p->params.format);
+ preview_scan_done(p, 0);
xsane_back_gtk_error(buf, TRUE);
return;
}
@@ -1839,7 +1873,7 @@ static void preview_scan_done(Preview *p, int save_image)
sane_get_parameters(xsane.dev, &xsane.param); /* update xsane.param */
- if ( (preferences.preselect_scanarea) && (!p->startimage))
+ if ((preferences.preselect_scanarea) && (!p->startimage) && (!xsane.medium_calibration))
{
preview_autoselect_scanarea(p, p->selection.coordinate); /* get autoselection coordinates */
preview_draw_selection(p);
@@ -1847,12 +1881,14 @@ static void preview_scan_done(Preview *p, int save_image)
xsane_update_histogram(TRUE /* update_raw */); /* update histogram (necessary because overwritten by preview_update_surface) */
}
- if (preferences.auto_correct_colors)
+ if ((preferences.auto_correct_colors) && (!xsane.medium_calibration))
{
xsane_calculate_raw_histogram();
xsane_set_auto_enhancement();
xsane_enhancement_by_histogram(preferences.auto_enhance_gamma);
}
+
+ xsane_batch_scan_update_icon_list();
}
/* ---------------------------------------------------------------------------------------------------------------------- */
@@ -1927,17 +1963,11 @@ static void preview_scan_start(Preview *p)
SANE_Status status;
char buf[256];
int fd, y;
- int gamma_gray_size = 256; /* set this values to image depth for more than 8bpp input support!!! */
- int gamma_red_size = 256;
- int gamma_green_size = 256;
- int gamma_blue_size = 256;
- int gamma_gray_max = 255; /* set this to to image depth for more than 8bpp output support */
- int gamma_red_max = 255;
- int gamma_green_max = 255;
- int gamma_blue_max = 255;
DBG(DBG_proc, "preview_scan_start\n");
+ p->read_offset_16 = 0;
+
xsane.medium_changed = FALSE;
preview_display_valid(p);
@@ -1966,95 +1996,6 @@ static void preview_scan_start(Preview *p)
p->input_tag = -1;
}
- if (xsane.well_known.gamma_vector >0)
- {
- const SANE_Option_Descriptor *opt;
-
- opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector);
- if (SANE_OPTION_IS_ACTIVE(opt->cap))
- {
- SANE_Int *gamma_data;
-
- opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector);
- gamma_gray_size = opt->size / sizeof(opt->type);
- gamma_gray_max = opt->constraint.range->max;
-
- gamma_data = malloc(gamma_gray_size * sizeof(SANE_Int));
-
- if ((xsane.xsane_colors > 1) || (xsane.no_preview_medium_gamma)) /* color scan or medium preview gamma disabled */
- {
- xsane_create_gamma_curve(gamma_data, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_gray_size, gamma_gray_max);
- }
- else /* grayscale scan */
- {
- xsane_create_gamma_curve(gamma_data, xsane.medium_negative, 1.0, 0.0, 0.0,
- xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray,
- gamma_gray_size, gamma_gray_max);
- }
-
- xsane_back_gtk_update_vector(xsane.well_known.gamma_vector, gamma_data);
- free(gamma_data);
- }
- }
-
- if (xsane.well_known.gamma_vector_r >0)
- {
- const SANE_Option_Descriptor *opt;
-
- opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_r);
- if (SANE_OPTION_IS_ACTIVE(opt->cap))
- {
- SANE_Int *gamma_data_red, *gamma_data_green, *gamma_data_blue;
-
- opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_r);
- gamma_red_size = opt->size / sizeof(opt->type);
- gamma_red_max = opt->constraint.range->max;
-
- opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_g);
- gamma_green_size = opt->size / sizeof(opt->type);
- gamma_green_max = opt->constraint.range->max;
-
- opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_b);
- gamma_blue_size = opt->size / sizeof(opt->type);
- gamma_blue_max = opt->constraint.range->max;
-
- gamma_data_red = malloc(gamma_red_size * sizeof(SANE_Int));
- gamma_data_green = malloc(gamma_green_size * sizeof(SANE_Int));
- gamma_data_blue = malloc(gamma_blue_size * sizeof(SANE_Int));
-
- if (xsane.no_preview_medium_gamma) /* do not use medium gamma for preview */
- {
- DBG(DBG_info, "preview: not using medium gamma table\n");
-
- xsane_create_gamma_curve(gamma_data_red, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_red_size, gamma_red_max);
- xsane_create_gamma_curve(gamma_data_green, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_green_size, gamma_green_max);
- xsane_create_gamma_curve(gamma_data_blue, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_blue_size, gamma_blue_max);
- }
- else /* use medium gamma for preview */
- {
- DBG(DBG_info, "preview: using medium gamma table\n");
-
- xsane_create_gamma_curve(gamma_data_red, xsane.medium_negative, 1.0, 0.0, 0.0,
- xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red,
- gamma_red_size, gamma_red_max);
- xsane_create_gamma_curve(gamma_data_green, xsane.medium_negative, 1.0, 0.0, 0.0,
- xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green,
- gamma_green_size, gamma_green_max);
- xsane_create_gamma_curve(gamma_data_blue, xsane.medium_negative, 1.0, 0.0, 0.0,
- xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue,
- gamma_blue_size, gamma_blue_max);
- }
-
- xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_r, gamma_data_red);
- xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_g, gamma_data_green);
- xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_b, gamma_data_blue);
-
- free(gamma_data_red);
- free(gamma_data_green);
- free(gamma_data_blue);
- }
- }
-
status = sane_start(dev);
if (status != SANE_STATUS_GOOD)
{
@@ -2110,15 +2051,11 @@ static void preview_scan_start(Preview *p)
p->previous_selection_maximum.active = FALSE;
#ifndef BUGGY_GDK_INPUT_EXCEPTION
- /* for unix */
if ((sane_set_io_mode(dev, SANE_TRUE) == SANE_STATUS_GOOD) && (sane_get_select_fd(dev, &fd) == SANE_STATUS_GOOD))
{
p->input_tag = gdk_input_add(fd, GDK_INPUT_READ | GDK_INPUT_EXCEPTION, preview_read_image_data, p);
}
else
-#else
- /* for win32 */
- sane_set_io_mode(dev, SANE_FALSE);
#endif
{
preview_read_image_data(p, -1, GDK_INPUT_READ);
@@ -2133,12 +2070,370 @@ static int preview_make_image_path(Preview *p, size_t filename_size, char *filen
DBG(DBG_proc, "preview_make_image_path\n");
- snprintf(buf, sizeof(buf), "preview-level-%d-", level);
+ snprintf(buf, sizeof(buf), "xsane-preview-level-%d-", level);
return xsane_back_gtk_make_path(filename_size, filename, 0, 0, buf, xsane.dev_name, ".ppm", XSANE_PATH_TMP);
}
/* ---------------------------------------------------------------------------------------------------------------------- */
+int preview_create_batch_icon_from_file(Preview *p, FILE *in, Batch_Scan_Parameters *parameters, int min_quality, int *min_time)
+{
+ u_int psurface_type, psurface_unit;
+ int image_width, image_height;
+ int xoffset, yoffset, width, height;
+ int max_val;
+ int x, y, dx, dy;
+ int time;
+ float psurface[4];
+ float dsurface[4];
+ char buf[255];
+ float scale;
+ int header = 0;
+ int rotate16 = 16 - preview_gamma_input_bits;
+ int rotate8 = preview_gamma_input_bits - 8;
+ guint16 r,g,b;
+ int c;
+ int maximum_size;
+ int quality = 0;
+ int xx, yy;
+ int offset = 0;
+ guchar *data;
+
+ DBG(DBG_proc, "preview_create_batch_icon_from_file\n");
+
+ if (!in)
+ {
+ return min_quality;
+ }
+
+ /* See whether there is a saved preview and load it if present: */
+ if (fscanf(in, "P6\n"
+ "# surface: %g %g %g %g %u %u\n"
+ "# time: %d\n"
+ "%d %d\n%d",
+ psurface + 0, psurface + 1, psurface + 2, psurface + 3,
+ &psurface_type, &psurface_unit,
+ &time,
+ &image_width, &image_height,
+ &max_val) != 10)
+ {
+ DBG(DBG_info, "no preview image\n");
+ return min_quality;
+ }
+
+ fgets(buf, sizeof(buf), in); /* skip newline character. this made a lot of problems in the past, so I skip it this way */
+
+ header = ftell(in);
+
+ if (min_quality >= 0) /* read real preview */
+ {
+ if ((psurface_type != p->surface_type) || (psurface_unit != p->surface_unit))
+ {
+ DBG(DBG_info, "incompatible surface types %d <> %d\n", psurface_type, p->surface_type);
+ return min_quality;
+ }
+
+ preview_rotate_previewsurface_to_devicesurface(p->rotation, p->surface, dsurface);
+
+
+ DBG(DBG_info, "stored image surface = [%3.2f %3.2f %3.2f %3.2f]\n",
+ psurface[0], psurface[1], psurface[2], psurface[3]);
+ DBG(DBG_info, "batch selection = [%3.2f %3.2f %3.2f %3.2f]\n",
+ parameters->tl_x, parameters->tl_y, parameters->br_x, parameters->br_y);
+ DBG(DBG_info, "preview device surface = [%3.2f %3.2f %3.2f %3.2f]\n",
+ dsurface[0], dsurface[1], dsurface[2], dsurface[3]);
+
+ xoffset = (parameters->tl_x - psurface[0])/(psurface[2] - psurface[0]) * image_width;
+ yoffset = (parameters->tl_y - psurface[1])/(psurface[3] - psurface[1]) * image_height;
+ width = (parameters->br_x - parameters->tl_x)/(psurface[2] - psurface[0]) * image_width;
+ height = (parameters->br_y - parameters->tl_y)/(psurface[3] - psurface[1]) * image_height;
+
+ quality = width;
+
+ if ((xoffset < 0) || (yoffset < 0) ||
+ (xoffset+width > image_width) || (yoffset+height > image_height) ||
+ (width == 0) || (height == 0))
+ {
+ DBG(DBG_info, "image does not cover wanted surface part\n");
+ return min_quality;
+ }
+
+ DBG(DBG_info, "quality = %d\n", quality);
+
+ if ( ((float) min_quality / (quality+1)) > 1.05) /* already loaded image has better quality */
+ {
+ DBG(DBG_info, "already loaded image has higher quality\n");
+ return min_quality;
+ }
+
+ if ( ((float) min_quality / (quality+1)) > 0.95) /* qualities are comparable */
+ {
+ if (*min_time > time) /* take more recent scan */
+ {
+ DBG(DBG_info, "images have comparable quality, already loaded is more up to date\n");
+ return min_quality;
+ }
+ DBG(DBG_info, "images have comparable quality, this image is more up to date\n");
+ }
+ else
+ {
+ DBG(DBG_info, "image has best quality\n");
+ }
+ }
+ else
+ {
+ xoffset = 0;
+ yoffset = 0;
+ width = image_width;
+ height = image_height;
+ }
+
+
+ {
+ float xscale = (float)width / parameters->gtk_preview_size;
+ float yscale = (float)height / parameters->gtk_preview_size;
+
+ if (xscale > yscale)
+ {
+ scale = xscale;
+ }
+ else
+ {
+ scale = yscale;
+ }
+ }
+
+ width = width / scale;
+ height = height / scale;
+
+ if (width > parameters->gtk_preview_size)
+ {
+ width = parameters->gtk_preview_size;
+ }
+
+ if (height > parameters->gtk_preview_size)
+ {
+ height = parameters->gtk_preview_size;
+ }
+
+ maximum_size = parameters->gtk_preview_size -1;
+
+ dx = (parameters->gtk_preview_size - width) / 2;
+ dy = (parameters->gtk_preview_size - height) / 2;
+
+
+ data = malloc(parameters->gtk_preview_size * parameters->gtk_preview_size * 3);
+ if (!data)
+ {
+ DBG(DBG_error, "preview_create_batch_icon_from_file: out of memory\n");
+ return min_quality;
+ }
+
+ /* make unused parts white */
+ for (x = 0; x< parameters->gtk_preview_size * parameters->gtk_preview_size * 3; x++)
+ {
+ data[x] = 0xF0;
+ }
+
+ if (max_val == 65535)
+ {
+ for (y=0; y < height; y++)
+ {
+ for (x=0; x < width; x++)
+ {
+ fseek(in, header + (xoffset + (int)(x * scale) + (yoffset + (int)(y * scale)) * image_width) * 6, SEEK_SET);
+
+ fread(&r, 2, 1, in); /* read 16 bit value in machines byte order */
+ r = preview_gamma_data_red[r >> rotate16];
+
+ fread(&g, 2, 1, in);
+ g = preview_gamma_data_green[g >> rotate16];
+
+ fread(&b, 2, 1, in);
+ b = preview_gamma_data_blue[b >> rotate16];
+
+ c = r * 65536 + g * 256 + b;
+
+ switch (parameters->rotation)
+ {
+ case 0: /* 0 degree */
+ xx = x + dx;
+ yy = y + dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 1: /* 90 degree */
+ xx = maximum_size - y;
+ yy = x + dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 2: /* 180 degree */
+ xx = maximum_size - x - dx;
+ yy = maximum_size - y - dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 3: /* 270 degree */
+ xx = y + dy;
+ yy = maximum_size - x - dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 4: /* 0 degree, x-mirror */
+ xx = maximum_size - x - dx;
+ yy = y + dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 5: /* 90 degree, x-mirror */
+ xx = y + dy;
+ yy = x + dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 6: /* 180 degree, x-mirror */
+ xx = x + dx;
+ yy = maximum_size - y - dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 7: /* 270 degree, x-mirror */
+ xx = maximum_size - y - dy;
+ yy = maximum_size - x - dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+ }
+
+ data[offset + 0] = r;
+ data[offset + 1] = g;
+ data[offset + 2] = b;
+ }
+ }
+
+ for (y = 0; y < parameters->gtk_preview_size; y++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(parameters->gtk_preview), data + 3 * parameters->gtk_preview_size * y,
+ 0, y, parameters->gtk_preview_size);
+ }
+ }
+ else /* depth = 8 */
+ {
+ for (y=0; y < height; y++)
+ {
+ for (x=0; x < width; x++)
+ {
+ fseek(in, header + (xoffset + (int)(x * scale) + (yoffset + (int)(y * scale)) * image_width) * 3, SEEK_SET);
+
+ r = fgetc(in);
+ r = preview_gamma_data_red[r << rotate8];
+
+ g = fgetc(in);
+ g = preview_gamma_data_green[g << rotate8];
+
+ b = fgetc(in);
+ b = preview_gamma_data_blue[b << rotate8];
+ switch (parameters->rotation)
+ {
+ case 0: /* 0 degree */
+ xx = x + dx;
+ yy = y + dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 1: /* 90 degree */
+ xx = maximum_size - y;
+ yy = x + dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 2: /* 180 degree */
+ xx = maximum_size - x - dx;
+ yy = maximum_size - y - dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 3: /* 270 degree */
+ xx = y + dy;
+ yy = maximum_size - x - dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 4: /* 0 degree, x-mirror */
+ xx = maximum_size - x - dx;
+ yy = y + dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 5: /* 90 degree, x-mirror */
+ xx = y + dy;
+ yy = x + dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 6: /* 180 degree, x-mirror */
+ xx = x + dx;
+ yy = maximum_size - y - dy;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+
+ case 7: /* 270 degree, x-mirror */
+ xx = maximum_size - y - dy;
+ yy = maximum_size - x - dx;
+ offset = parameters->gtk_preview_size * 3 * yy + 3*(xx);
+ break;
+ }
+
+ data[offset + 0] = r;
+ data[offset + 1] = g;
+ data[offset + 2] = b;
+ }
+ }
+
+ for (y = 0; y < parameters->gtk_preview_size; y++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(parameters->gtk_preview), data + 3 * parameters->gtk_preview_size * y,
+ 0, y, parameters->gtk_preview_size);
+ }
+ }
+
+ free(data);
+
+ return quality;
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+void preview_create_batch_icon(Preview *p, Batch_Scan_Parameters *parameters)
+{
+ FILE *in;
+ int quality = 0;
+ int time = 0;
+
+ in = fopen(xsane.preview->filename[0], "rb");
+ quality = preview_create_batch_icon_from_file(xsane.preview, in, parameters, quality, &time);
+
+ if (quality <= 0)
+ {
+ char filename[PATH_MAX];
+
+ if (in)
+ {
+ fclose(in);
+ }
+
+ xsane_back_gtk_make_path(sizeof(filename), filename, "xsane", 0, "xsane-startimage", 0, ".pnm", XSANE_PATH_SYSTEM);
+ in = fopen(filename, "rb"); /* read binary (b for win32) */
+ if (in)
+ {
+ preview_create_batch_icon_from_file(xsane.preview, in, parameters, -1, &time);
+ }
+ }
+ fclose(in);
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
static int preview_restore_image_from_file(Preview *p, FILE *in, int min_quality, int *min_time)
{
u_int psurface_type, psurface_unit;
@@ -2202,6 +2497,7 @@ static int preview_restore_image_from_file(Preview *p, FILE *in, int min_quality
yoffset = (dsurface[1] - psurface[1])/(psurface[3] - psurface[1]) * image_height;
width = (dsurface[2] - dsurface[0])/(psurface[2] - psurface[0]) * image_width;
height = (dsurface[3] - dsurface[1])/(psurface[3] - psurface[1]) * image_height;
+
quality = width;
if ((xoffset < 0) || (yoffset < 0) ||
@@ -2397,6 +2693,284 @@ static void preview_restore_image(Preview *p)
/* ---------------------------------------------------------------------------------------------------------------------- */
+static int preview_get_pixel_color(Preview *p, int x, int y, int *raw_red, int *raw_green, int *raw_blue,
+ int *enh_red, int *enh_green, int *enh_blue)
+{
+ int image_x, image_y;
+ int offset;
+ int rotate = 16 - preview_gamma_input_bits;
+
+ DBG(DBG_proc, "preview_get_pixel_color\n");
+
+ if (p->image_data_raw)
+ {
+ preview_transform_coordinate_window_to_image(p, x, y, &image_x, &image_y);
+
+ if ( (image_x >= 0) && (image_x < p->image_width) && (image_y >=0) && (image_y < p->image_height) )
+ {
+ offset = 3 * (image_y * p->image_width + image_x);
+
+ if (!xsane.negative) /* positive */
+ {
+ *raw_red = (p->image_data_raw[offset ]) >> 8;
+ *raw_green = (p->image_data_raw[offset + 1]) >> 8;
+ *raw_blue = (p->image_data_raw[offset + 2]) >> 8;
+ }
+ else /* negative */
+ {
+ *raw_red = 255 - ((p->image_data_raw[offset ]) >> 8);
+ *raw_green = 255 - ((p->image_data_raw[offset + 1]) >> 8);
+ *raw_blue = 255 - ((p->image_data_raw[offset + 2]) >> 8);
+ }
+
+ /* the enhanced pixels are already inverted when negative is selected */
+ /* do not use image_data_enh because the preview gamma value is applied to this */
+ *enh_red = histogram_gamma_data_red [(p->image_data_raw[offset ]) >> rotate];
+ *enh_green = histogram_gamma_data_green[(p->image_data_raw[offset + 1]) >> rotate];
+ *enh_blue = histogram_gamma_data_blue [(p->image_data_raw[offset + 2]) >> rotate];
+
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static void xsane_swap_int(int *a, int *b)
+{
+ int i;
+ i = *a;
+ *a = *b;
+ *b = i;
+}
+
+static void preview_display_zoom(Preview *p, int x, int y, int zoom)
+{
+ int pointer_x, pointer_y;
+ int image_x, image_y;
+ int image_x_lof, image_x_rof;
+ int image_y_tof, image_y_bof;
+ int image_x_min, image_y_min;
+ int image_x_max, image_y_max;
+ int image_x_direction, image_y_direction;
+ int offset;
+ int r, g, b;
+ int px, py;
+ int i;
+ char *row;
+
+ DBG(DBG_proc, "preview_display_zoom");
+
+ if (!p->image_data_raw)
+ {
+ return;
+ }
+
+ row = calloc(XSANE_ZOOM_SIZE, 3);
+
+ if (row)
+ {
+ preview_transform_coordinate_window_to_image(p, x, y, &image_x, &image_y);
+ preview_transform_coordinate_window_to_image(p, x, y, &pointer_x, &pointer_y);
+
+ image_x_min = image_x - XSANE_ZOOM_SIZE/(zoom*2);
+ image_y_min = image_y - XSANE_ZOOM_SIZE/(zoom*2);
+
+ image_x_max = image_x_min + XSANE_ZOOM_SIZE/zoom + 1;
+ image_y_max = image_y_min + XSANE_ZOOM_SIZE/zoom + 1;
+
+ xsane_bound_int(&image_x_min, 0, p->image_width - 1);
+ xsane_bound_int(&image_x_max, 0, p->image_width - 1);
+ xsane_bound_int(&image_y_min, 0, p->image_height - 1);
+ xsane_bound_int(&image_y_max, 0, p->image_height - 1);
+
+ if ((image_x_max - image_x_min) && (image_y_max - image_y_min))
+ {
+ image_x_lof = image_x_min - (image_x - XSANE_ZOOM_SIZE/(zoom*2));
+ image_x_rof = image_x - XSANE_ZOOM_SIZE/(zoom*2) + XSANE_ZOOM_SIZE/zoom + 1 - image_x_max;
+ image_y_tof = image_y_min - (image_y - XSANE_ZOOM_SIZE/(zoom*2));
+ image_y_bof = image_y - XSANE_ZOOM_SIZE/(zoom*2) + XSANE_ZOOM_SIZE/zoom + 1 - image_y_max;
+
+ image_x_direction = 1;
+ image_y_direction = 1;
+
+ switch (p->rotation & 3)
+ {
+ case 0: /* do not rotate - 0 degree */
+ default:
+ break;
+
+ case 1: /* 90 degree */
+ xsane_swap_int(&image_y_min, &image_y_max);
+ xsane_swap_int(&image_y_tof, &image_y_bof);
+ image_y_direction *= -1;
+ break;
+
+ case 2: /* 180 degree */
+ xsane_swap_int(&image_x_min, &image_x_max);
+ xsane_swap_int(&image_x_lof, &image_x_rof);
+ xsane_swap_int(&image_y_min, &image_y_max);
+ xsane_swap_int(&image_y_tof, &image_y_bof);
+ image_x_direction *= -1;
+ image_y_direction *= -1;
+ break;
+
+ case 3: /* 270 degree */
+ xsane_swap_int(&image_x_min, &image_x_max);
+ xsane_swap_int(&image_x_lof, &image_x_rof);
+ image_x_direction *= -1;
+ break;
+ }
+
+
+ if ((p->rotation & 1) == 0)
+ {
+ if (p->rotation & 4) /* mirror */
+ {
+ xsane_swap_int(&image_x_min, &image_x_max);
+ xsane_swap_int(&image_x_lof, &image_x_rof);
+ image_x_direction *= -1;
+ }
+
+ py = image_y_tof * zoom;
+
+ for (i=0; i < py; i++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(p->zoom), row, 0, i, XSANE_ZOOM_SIZE);
+ }
+
+ for (image_y = image_y_min; image_y != image_y_max + image_y_direction; image_y += image_y_direction)
+ {
+ px = image_x_lof * zoom;
+
+ for (image_x = image_x_min; image_x != image_x_max + image_x_direction; image_x += image_x_direction)
+ {
+ offset = 3 * (image_y * p->image_width + image_x);
+
+ r = (p->image_data_enh[offset ]);
+ g = (p->image_data_enh[offset+1]);
+ b = (p->image_data_enh[offset+2]);
+
+ if ( (image_x == pointer_x) && (image_y == pointer_y) )
+ {
+ r = g = b = (128 + (r+g+b) / 3) & 255; /* mark the cursor position */
+ }
+
+ for (i=0; (i<zoom) && (px < XSANE_ZOOM_SIZE); i++)
+ {
+ row[px*3+0] = r;
+ row[px*3+1] = g;
+ row[px*3+2] = b;
+ px++;
+ }
+ }
+
+ for (i=0; (i<zoom) && (py < XSANE_ZOOM_SIZE); i++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(p->zoom), row, 0, py++, XSANE_ZOOM_SIZE);
+ }
+ }
+ }
+ else /* swap x and y */
+ {
+ if (p->rotation & 4) /* mirror */
+ {
+ xsane_swap_int(&image_y_min, &image_y_max);
+ xsane_swap_int(&image_y_tof, &image_y_bof);
+ image_y_direction *= -1;
+ }
+
+ py = image_x_lof * zoom;
+
+ for (i=0; i < py; i++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(p->zoom), row, 0, i, XSANE_ZOOM_SIZE);
+ }
+
+ for (image_x = image_x_min; image_x != image_x_max + image_x_direction; image_x += image_x_direction)
+ {
+ px = image_y_tof * zoom;
+
+ for (image_y = image_y_min; image_y != image_y_max + image_y_direction; image_y += image_y_direction)
+ {
+ offset = 3 * (image_y * p->image_width + image_x);
+
+ r = (p->image_data_enh[offset ]);
+ g = (p->image_data_enh[offset+1]);
+ b = (p->image_data_enh[offset+2]);
+
+ if ( (image_x == pointer_x) && (image_y == pointer_y) )
+ {
+ r = g = b = (128 + (r+g+b) / 3) & 255; /* mark the cursor position */
+ }
+
+ for (i=0; (i<zoom) && (px < XSANE_ZOOM_SIZE); i++)
+ {
+ row[px*3+0] = r;
+ row[px*3+1] = g;
+ row[px*3+2] = b;
+ px++;
+ }
+ }
+
+ for (i=0; (i<zoom) && (py < XSANE_ZOOM_SIZE); i++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(p->zoom), row, 0, py++, XSANE_ZOOM_SIZE);
+ }
+ }
+ }
+
+ for (i=0; i < XSANE_ZOOM_SIZE; i++)
+ {
+ row[i*3+0] = 0;
+ row[i*3+1] = 0;
+ row[i*3+2] = 0;
+ }
+
+ for (i=py; i < XSANE_ZOOM_SIZE; i++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(p->zoom), row, 0, i, XSANE_ZOOM_SIZE);
+ }
+ }
+ else
+ {
+ for (i = 0; i < XSANE_ZOOM_SIZE; i++)
+ {
+ gtk_preview_draw_row(GTK_PREVIEW(p->zoom), row, 0, i, XSANE_ZOOM_SIZE);
+ }
+ }
+ gtk_widget_queue_draw(p->zoom);
+
+ free(row);
+ }
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static void preview_display_color_components(Preview *p, int x, int y)
+{
+ char buffer[256];
+ int raw_red, raw_green, raw_blue, enh_red, enh_green, enh_blue;
+
+ if (! preview_get_pixel_color(p, x, y, &raw_red, &raw_green, &raw_blue, &enh_red, &enh_green, &enh_blue))
+ {
+ snprintf(buffer, sizeof(buffer), " %03d, %03d, %03d \n" \
+ " %03d, %03d, %03d ",
+ raw_red, raw_green, raw_blue, enh_red, enh_green, enh_blue);
+ }
+ else
+ {
+ snprintf(buffer, sizeof(buffer), " ###, ###, ### \n" \
+ " ###, ###, ### ");
+ }
+
+ gtk_label_set_text(GTK_LABEL(p->rgb_label), buffer);
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
static gint preview_hold_event_handler(gpointer data)
{
Preview *p = data;
@@ -2437,6 +3011,9 @@ static gint preview_motion_event_handler(GtkWidget *window, GdkEvent *event, gpo
if (!p->scanning)
{
+ preview_display_zoom(p, event->motion.x, event->motion.y, XSANE_ZOOM_FACTOR);
+ preview_display_color_components(p, event->motion.x, event->motion.y);
+
switch (((GdkEventMotion *)event)->state &
GDK_Num_Lock & GDK_Caps_Lock & GDK_Shift_Lock & GDK_Scroll_Lock) /* mask all Locks */
{
@@ -2447,8 +3024,159 @@ static gint preview_motion_event_handler(GtkWidget *window, GdkEvent *event, gpo
if ( (p->selection_drag) || (p->selection_drag_edge) )
{
p->selection.active = TRUE;
- p->selection.coordinate[p->selection_xedge] = preview_x;
- p->selection.coordinate[p->selection_yedge] = preview_y;
+
+ if (preview_x < p->scanner_surface[p->index_xmin])
+ {
+ preview_x = p->scanner_surface[p->index_xmin];
+ }
+ else if (preview_x > p->scanner_surface[p->index_xmax])
+ {
+ preview_x = p->scanner_surface[p->index_xmax];
+ }
+
+ if (preview_y < p->scanner_surface[p->index_ymin])
+ {
+ preview_y = p->scanner_surface[p->index_ymin];
+ }
+ else if (preview_y > p->scanner_surface[p->index_ymax])
+ {
+ preview_y = p->scanner_surface[p->index_ymax];
+ }
+
+
+ if (p->selection_xedge != -1)
+ {
+ p->selection.coordinate[p->selection_xedge] = preview_x;
+ }
+
+ if (p->selection_yedge != -1)
+ {
+ p->selection.coordinate[p->selection_yedge] = preview_y;
+ }
+
+ if (p->ratio) /* forced preview ratio ? */
+ {
+ if ( (p->selection_xedge == p->index_xmin) && (p->selection_yedge == p->index_ymin) ) /* top left corner */
+ {
+ float width;
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+
+ p->selection.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + width / p->ratio;
+
+ if (p->selection.coordinate[p->index_ymax] > p->scanner_surface[p->index_ymax])
+ {
+ float height;
+ p->selection.coordinate[p->index_ymax] = p->scanner_surface[p->index_ymax];
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+ p->selection.coordinate[p->index_xmin] = p->selection.coordinate[p->index_xmax] - height * p->ratio;
+ }
+ }
+ else if ( (p->selection_xedge == p->index_xmax) && (p->selection_yedge == p->index_ymin) )/* top right corner */
+ {
+ float width;
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+
+ p->selection.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + width / p->ratio;
+
+ if (p->selection.coordinate[p->index_ymax] > p->scanner_surface[p->index_ymax])
+ {
+ float height;
+ p->selection.coordinate[p->index_ymax] = p->scanner_surface[p->index_ymax];
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+ p->selection.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + height * p->ratio;
+ }
+ }
+ else if ( (p->selection_xedge == p->index_xmin) && (p->selection_yedge == p->index_ymax) ) /* bottom left edge */
+ {
+ float width;
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+
+ p->selection.coordinate[p->index_ymin] = p->selection.coordinate[p->index_ymax] - width / p->ratio;
+
+ if (p->selection.coordinate[p->index_ymin] < p->scanner_surface[p->index_ymin])
+ {
+ float height;
+ p->selection.coordinate[p->index_ymin] = p->scanner_surface[p->index_ymin];
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+ p->selection.coordinate[p->index_xmin] = p->selection.coordinate[p->index_xmax] - height * p->ratio;
+ }
+ }
+ else if ( (p->selection_xedge == p->index_xmax) && (p->selection_yedge == p->index_ymax) ) /* bottom right edge */
+ {
+ float width;
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+
+ p->selection.coordinate[p->index_ymin] = p->selection.coordinate[p->index_ymax] - width / p->ratio;
+
+ if (p->selection.coordinate[p->index_ymin] < p->scanner_surface[p->index_ymin])
+ {
+ float height;
+ p->selection.coordinate[p->index_ymin] = p->scanner_surface[p->index_ymin];
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+ p->selection.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + height * p->ratio;
+ }
+ }
+ else if (p->selection_xedge == p->index_xmin) /* left edge */
+ {
+ float width;
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+
+ p->selection.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + width / p->ratio;
+
+ if (p->selection.coordinate[p->index_ymax] > p->scanner_surface[p->index_ymax])
+ {
+ float height;
+ p->selection.coordinate[p->index_ymax] = p->scanner_surface[p->index_ymax];
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+ p->selection.coordinate[p->index_xmin] = p->selection.coordinate[p->index_xmax] - height * p->ratio;
+ }
+ }
+ else if (p->selection_xedge == p->index_xmax) /* right edge */
+ {
+ float width;
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+
+ p->selection.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + width / p->ratio;
+
+ if (p->selection.coordinate[p->index_ymax] > p->scanner_surface[p->index_ymax])
+ {
+ float height;
+ p->selection.coordinate[p->index_ymax] = p->scanner_surface[p->index_ymax];
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+ p->selection.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + height * p->ratio;
+ }
+ }
+ else if (p->selection_yedge == p->index_ymin) /* top edge */
+ {
+ float height;
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+
+ p->selection.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + height * p->ratio;
+
+ if (p->selection.coordinate[p->index_xmax] > p->scanner_surface[p->index_xmax])
+ {
+ float width;
+ p->selection.coordinate[p->index_xmax] = p->scanner_surface[p->index_xmax];
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+ p->selection.coordinate[p->index_ymin] = p->selection.coordinate[p->index_ymax] - width / p->ratio;
+ }
+ }
+ else if (p->selection_yedge == p->index_ymax) /* bottom edge */
+ {
+ float height;
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+
+ p->selection.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + height * p->ratio;
+
+ if (p->selection.coordinate[p->index_xmax] > p->scanner_surface[p->index_xmax])
+ {
+ float width;
+ p->selection.coordinate[p->index_xmax] = p->scanner_surface[p->index_xmax];
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+ p->selection.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + width / p->ratio;
+ }
+ }
+ }
preview_order_selection(p);
preview_bound_selection(p);
@@ -2551,7 +3279,7 @@ static gint preview_motion_event_handler(GtkWidget *window, GdkEvent *event, gpo
{
cursor = gdk_cursor_new(cursornr); /* set curosr */
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = cursornr;
}
break;
@@ -2727,7 +3455,7 @@ static gint preview_motion_event_handler(GtkWidget *window, GdkEvent *event, gpo
{
cursor = gdk_cursor_new(cursornr); /* set curosr */
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = cursornr;
}
break;
@@ -2842,7 +3570,7 @@ static gint preview_button_press_event_handler(GtkWidget *window, GdkEvent *even
cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW);
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = XSANE_CURSOR_PREVIEW;
}
break;
@@ -2947,7 +3675,7 @@ static gint preview_button_press_event_handler(GtkWidget *window, GdkEvent *even
cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW);
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = XSANE_CURSOR_PREVIEW;
}
break;
@@ -3037,11 +3765,51 @@ static gint preview_button_press_event_handler(GtkWidget *window, GdkEvent *even
cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW);
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
+ p->cursornr = XSANE_CURSOR_PREVIEW;
+ }
+ break;
+
+ case MODE_AUTORAISE_SCANAREA:
+ {
+ DBG(DBG_info, "autoraise scanarea mode\n");
+
+ if ( ( (((GdkEventButton *)event)->button == 1) || (((GdkEventButton *)event)->button == 2) ) &&
+ (p->image_data_raw) ) /* left or middle button */
+ {
+ preview_autoraise_scanarea(p, event->button.x, event->button.y, p->selection.coordinate); /* raise selection area */
+ }
+
+ p->mode = MODE_NORMAL;
+
+ cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW);
+ gdk_window_set_cursor(p->window->window, cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = XSANE_CURSOR_PREVIEW;
}
break;
+ case MODE_ZOOM_IN:
+ {
+ DBG(DBG_info, "zoom in mode\n");
+
+ if ( ( (((GdkEventButton *)event)->button == 1) || (((GdkEventButton *)event)->button == 2) ) &&
+ (p->image_data_raw) ) /* left or middle button */
+ {
+ preview_select_zoom_point(p, event->button.x, event->button.y); /* select zoom point */
+ }
+ else
+ {
+ p->mode = MODE_NORMAL;
+
+ cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW);
+ gdk_window_set_cursor(p->window->window, cursor);
+ gdk_cursor_unref(cursor);
+ p->cursornr = XSANE_CURSOR_PREVIEW;
+ }
+ }
+ break;
+
case MODE_NORMAL:
{
DBG(DBG_info, "normal mode\n");
@@ -3117,7 +3885,7 @@ static gint preview_button_press_event_handler(GtkWidget *window, GdkEvent *even
cursornr = GDK_CROSS;
cursor = gdk_cursor_new(cursornr); /* set curosr */
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = cursornr;
}
break;
@@ -3139,7 +3907,7 @@ static gint preview_button_press_event_handler(GtkWidget *window, GdkEvent *even
cursornr = GDK_HAND2;
cursor = gdk_cursor_new(cursornr); /* set curosr */
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = cursornr;
}
break;
@@ -3184,7 +3952,7 @@ static gint preview_button_release_event_handler(GtkWidget *window, GdkEvent *ev
cursornr = XSANE_CURSOR_PREVIEW;
cursor = gdk_cursor_new(cursornr); /* set curosr */
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = cursornr;
}
@@ -3220,7 +3988,7 @@ static gint preview_expose_event_handler_start(GtkWidget *window, GdkEvent *even
if (!p->gc_selection)
{
DBG(DBG_info, "defining line styles for selection and page frames\n");
- colormap = gdk_window_get_colormap(p->window->window);
+ colormap = gdk_drawable_get_colormap(p->window->window);
p->gc_selection = gdk_gc_new(p->window->window);
gdk_gc_set_function(p->gc_selection, GDK_INVERT);
@@ -3265,7 +4033,7 @@ static gint preview_expose_event_handler_end(GtkWidget *window, GdkEvent *event,
if (!p->gc_selection)
{
DBG(DBG_info, "defining line styles for selection and page frames\n");
- colormap = gdk_window_get_colormap(p->window->window);
+ colormap = gdk_drawable_get_colormap(p->window->window);
p->gc_selection = gdk_gc_new(p->window->window);
gdk_gc_set_function(p->gc_selection, GDK_INVERT);
@@ -3283,8 +4051,8 @@ static gint preview_expose_event_handler_end(GtkWidget *window, GdkEvent *event,
}
else
{
- p->selection.active = expose_event_selection_active;
- p->selection_maximum.active = expose_event_selection_maximum_active;
+ p->selection.active = expose_event_selection_active;
+ p->selection_maximum.active = expose_event_selection_maximum_active;
preview_draw_selection(p); /* draw selections again */
}
}
@@ -3335,8 +4103,8 @@ static void preview_create_preset_area_menu(Preview *p, int selection)
{
preset_area_item = gtk_menu_item_new_with_label(preferences.preset_area[i]->name);
gtk_container_add(GTK_CONTAINER(preset_area_menu), preset_area_item);
- gtk_signal_connect(GTK_OBJECT(preset_area_item), "button_press_event", (GtkSignalFunc) preview_preset_area_context_menu_callback, p);
- gtk_signal_connect(GTK_OBJECT(preset_area_item), "activate", (GtkSignalFunc) preview_preset_area_callback, p);
+ g_signal_connect(GTK_OBJECT(preset_area_item), "button_press_event", (GtkSignalFunc) preview_preset_area_context_menu_callback, p);
+ g_signal_connect(GTK_OBJECT(preset_area_item), "activate", (GtkSignalFunc) preview_preset_area_callback, p);
gtk_object_set_data(GTK_OBJECT(preset_area_item), "Selection", (void *) i);
gtk_object_set_data(GTK_OBJECT(preset_area_item), "Preview", (void *) p);
@@ -3410,16 +4178,20 @@ Preview *preview_new(void)
GtkWidget *table, *frame;
GtkSignalFunc signal_func;
GtkWidgetClass *class;
- GtkWidget *vbox, *hbox;
+ GtkWidget *vbox, *action_box;
+ GtkWidget *outer_hbox, *middle_vbox;
GdkCursor *cursor;
GtkWidget *preset_area_option_menu;
GtkWidget *rotation_option_menu, *rotation_menu, *rotation_item;
+ GtkWidget *ratio_option_menu, *ratio_menu, *ratio_item;
GtkWidget *delete_images;
GdkBitmap *mask;
GdkPixmap *pixmap = NULL;
+ GtkWidget *pixmapwidget;
Preview *p;
int i;
char buf[256];
+ int ratio_nr = 0;
DBG(DBG_proc, "preview_new\n");
@@ -3468,12 +4240,14 @@ Preview *preview_new(void)
p->maximum_output_width = INF; /* full output with */
p->maximum_output_height = INF; /* full output height */
+ p->block_update_maximum_output_size_clipping = FALSE;
p->preview_colors = -1;
p->invalid = TRUE; /* no valid preview */
+ p->ratio = 0.0;
#ifndef XSERVER_WITH_BUGGY_VISUALS
- gtk_widget_push_visual(gtk_preview_get_visual());
+ gtk_widget_push_visual(gtk_preview_get_visual()); /* this has no function for gtk+-2.0 */
#endif
gtk_widget_push_colormap(gtk_preview_get_cmap());
@@ -3481,7 +4255,8 @@ Preview *preview_new(void)
p->top = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(p->top), buf);
xsane_set_window_icon(p->top, 0);
- gtk_accel_group_attach(xsane.accelerator_group, GTK_OBJECT(p->top));
+ gtk_window_add_accel_group(GTK_WINDOW(p->top), xsane.accelerator_group);
+
/* set the main vbox */
vbox = gtk_vbox_new(FALSE, 0);
@@ -3489,39 +4264,51 @@ Preview *preview_new(void)
gtk_container_add(GTK_CONTAINER(p->top), vbox);
gtk_widget_show(vbox);
- /* set the main hbox */
- hbox = gtk_hbox_new(FALSE, 0);
- gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
- gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
- gtk_widget_show(hbox);
- /* top hbox for icons */
+ /* the button_box (hbox) */
p->button_box = gtk_hbox_new(FALSE, 1);
- gtk_container_set_border_width(GTK_CONTAINER(p->button_box), 1);
+ gtk_container_set_border_width(GTK_CONTAINER(p->button_box), 0);
gtk_box_pack_start(GTK_BOX(vbox), p->button_box, FALSE, FALSE, 0);
+
+ /* add new selection for batch scanning */
+ p->add_batch = xsane_button_new_with_pixmap(p->top->window, p->button_box, add_batch_xpm, DESC_ADD_BATCH, (GtkSignalFunc) preview_add_batch, p);
+
+ xsane_vseparator_new(p->button_box, 3);
+
/* White, gray and black pipette button */
p->pipette_white = xsane_button_new_with_pixmap(p->top->window, p->button_box, pipette_white_xpm, DESC_PIPETTE_WHITE, (GtkSignalFunc) preview_pipette_white, p);
p->pipette_gray = xsane_button_new_with_pixmap(p->top->window, p->button_box, pipette_gray_xpm, DESC_PIPETTE_GRAY, (GtkSignalFunc) preview_pipette_gray, p);
p->pipette_black = xsane_button_new_with_pixmap(p->top->window, p->button_box, pipette_black_xpm, DESC_PIPETTE_BLACK, (GtkSignalFunc) preview_pipette_black, p);
+ xsane_vseparator_new(p->button_box, 3);
+
/* Zoom not, zoom out and zoom in button */
- p->zoom_not = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_not_xpm, DESC_ZOOM_FULL, (GtkSignalFunc) preview_zoom_not, p);
- p->zoom_out = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_out_xpm, DESC_ZOOM_OUT, (GtkSignalFunc) preview_zoom_out, p);
- p->zoom_in = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_in_xpm, DESC_ZOOM_IN, (GtkSignalFunc) preview_zoom_in, p);
- p->zoom_undo = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_undo_xpm, DESC_ZOOM_UNDO, (GtkSignalFunc) preview_zoom_undo, p);
- p->full_area = xsane_button_new_with_pixmap(p->top->window, p->button_box, auto_select_preview_area_xpm, DESC_AUTOSELECT_SCANAREA, (GtkSignalFunc) preview_autoselect_scanarea_callback, p);
- p->autoselect = xsane_button_new_with_pixmap(p->top->window, p->button_box, full_preview_area_xpm, DESC_FULL_PREVIEW_AREA, (GtkSignalFunc) preview_full_preview_area_callback, p);
- delete_images = xsane_button_new_with_pixmap(p->top->window, p->button_box, delete_images_xpm, DESC_DELETE_IMAGES, (GtkSignalFunc) preview_delete_images_callback, p);
-
- gtk_widget_add_accelerator(p->zoom_not, "clicked", xsane.accelerator_group, GDK_KP_Multiply, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt keypad_* */
- gtk_widget_add_accelerator(p->zoom_out, "clicked", xsane.accelerator_group, GDK_KP_Subtract, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt keypad_- */
- gtk_widget_add_accelerator(p->zoom_in, "clicked", xsane.accelerator_group, GDK_KP_Add, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt keypad_+ */
- gtk_widget_add_accelerator(p->zoom_undo, "clicked", xsane.accelerator_group, GDK_KP_Divide, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt keypad_/ */
- gtk_widget_add_accelerator(p->full_area, "clicked", xsane.accelerator_group, GDK_A, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt keypad_* */
- gtk_widget_add_accelerator(p->autoselect, "clicked", xsane.accelerator_group, GDK_V, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt keypad_* */
- gtk_widget_add_accelerator(delete_images, "clicked", xsane.accelerator_group, GDK_KP_Delete, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt keypad_* */
+ p->zoom_not = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_not_xpm, DESC_ZOOM_FULL, (GtkSignalFunc) preview_zoom_not, p);
+ p->zoom_out = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_out_xpm, DESC_ZOOM_OUT, (GtkSignalFunc) preview_zoom_out, p);
+ p->zoom_in = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_in_xpm, DESC_ZOOM_IN, (GtkSignalFunc) preview_zoom_in, p);
+ p->zoom_area = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_area_xpm, DESC_ZOOM_AREA, (GtkSignalFunc) preview_zoom_area, p);
+ p->zoom_undo = xsane_button_new_with_pixmap(p->top->window, p->button_box, zoom_undo_xpm, DESC_ZOOM_UNDO, (GtkSignalFunc) preview_zoom_undo, p);
+
+ xsane_vseparator_new(p->button_box, 3);
+
+ p->full_area = xsane_button_new_with_pixmap(p->top->window, p->button_box, auto_select_preview_area_xpm, DESC_AUTOSELECT_SCANAREA, (GtkSignalFunc) preview_autoselect_scanarea_callback, p);
+ p->autoraise = xsane_button_new_with_pixmap(p->top->window, p->button_box, auto_raise_preview_area_xpm, DESC_AUTORAISE_SCANAREA, (GtkSignalFunc) preview_init_autoraise_scanarea, p);
+ p->autoselect = xsane_button_new_with_pixmap(p->top->window, p->button_box, full_preview_area_xpm, DESC_FULL_PREVIEW_AREA, (GtkSignalFunc) preview_full_preview_area_callback, p);
+
+ xsane_vseparator_new(p->button_box, 3);
+
+ delete_images = xsane_button_new_with_pixmap(p->top->window, p->button_box, delete_images_xpm, DESC_DELETE_IMAGES, (GtkSignalFunc) preview_delete_images_callback, p);
+
+ gtk_widget_add_accelerator(p->zoom_not, "clicked", xsane.accelerator_group, GDK_KP_Multiply, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_* */
+ gtk_widget_add_accelerator(p->zoom_out, "clicked", xsane.accelerator_group, GDK_KP_Subtract, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_- */
+ gtk_widget_add_accelerator(p->zoom_in, "clicked", xsane.accelerator_group, GDK_KP_Add, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_+ */
+ gtk_widget_add_accelerator(p->zoom_area, "clicked", xsane.accelerator_group, GDK_KP_Enter, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_Enter */
+ gtk_widget_add_accelerator(p->zoom_undo, "clicked", xsane.accelerator_group, GDK_KP_Divide, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_/ */
+ gtk_widget_add_accelerator(p->full_area, "clicked", xsane.accelerator_group, GDK_A, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_* */
+ gtk_widget_add_accelerator(p->autoselect, "clicked", xsane.accelerator_group, GDK_V, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_* */
+ gtk_widget_add_accelerator(delete_images, "clicked", xsane.accelerator_group, GDK_KP_Delete, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt keypad_* */
gtk_widget_set_sensitive(p->zoom_not, FALSE); /* no zoom at this point, so no zoom not */
gtk_widget_set_sensitive(p->zoom_out, FALSE); /* no zoom at this point, so no zoom out */
@@ -3530,42 +4317,157 @@ Preview *preview_new(void)
gtk_widget_set_sensitive(p->autoselect, FALSE); /* no selection */
+ gtk_widget_show(p->button_box);
+ /* the button box is ready */
+
+
+
+ /* construct the preview area (table with sliders & preview window) */
+
+ table = gtk_table_new(2, 2, /* homogeneous */ FALSE);
+ gtk_table_set_col_spacing(GTK_TABLE(table), 0, 1);
+ gtk_table_set_row_spacing(GTK_TABLE(table), 0, 1);
+ gtk_container_set_border_width(GTK_CONTAINER(table), 1);
+ gtk_box_pack_start(GTK_BOX(vbox), table, /* expand */ TRUE, /* fill */ TRUE, /* padding */ 0);
+ gtk_widget_show(table);
+
+ /* the empty box in the top-left corner */
+ frame = gtk_frame_new(/* label */ 0);
+ gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
+ gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+ gtk_widget_show(frame);
+
+ /* the unit label */
+ p->unit_label = gtk_label_new("cm");
+ gtk_container_add(GTK_CONTAINER(frame), p->unit_label);
+ gtk_widget_show(p->unit_label);
+
+ /* the horizontal ruler */
+ p->hruler = gtk_hruler_new();
+ gtk_table_attach(GTK_TABLE(table), p->hruler, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
+ gtk_widget_show(p->hruler);
+
+ /* the vertical ruler */
+ p->vruler = gtk_vruler_new();
+ gtk_table_attach(GTK_TABLE(table), p->vruler, 0, 1, 1, 2, 0, GTK_FILL, 0, 0);
+ gtk_widget_show(p->vruler);
+
+ /* the preview area */
+ p->window = gtk_preview_new(GTK_PREVIEW_COLOR);
+ gtk_preview_set_expand(GTK_PREVIEW(p->window), TRUE);
+
+ gtk_widget_set_events(p->window, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
+ GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
+
+ /* the first expose_event is responsible to undraw the selection frame */
+ g_signal_connect(GTK_OBJECT(p->window), "expose_event", (GtkSignalFunc) preview_expose_event_handler_start, p);
+ g_signal_connect(GTK_OBJECT(p->window), "button_press_event", (GtkSignalFunc) preview_button_press_event_handler, p);
+ g_signal_connect(GTK_OBJECT(p->window), "motion_notify_event", (GtkSignalFunc) preview_motion_event_handler, p);
+ g_signal_connect(GTK_OBJECT(p->window), "button_release_event", (GtkSignalFunc) preview_button_release_event_handler, p);
+
+ g_signal_connect_after(GTK_OBJECT(p->window), "size_allocate", (GtkSignalFunc) preview_area_resize_handler, p);
+ /* the second expose_event is responsible to redraw the selection frame */
+ g_signal_connect_after(GTK_OBJECT(p->window), "expose_event", (GtkSignalFunc) preview_expose_event_handler_end, p);
+
+ /* Connect the motion-notify events of the preview area with the rulers. Nifty stuff! */
+
+#ifdef HAVE_GTK2
+ class = (GtkWidgetClass *) GTK_HSCROLLBAR_GET_CLASS(p->hruler);
+#else
+ class = GTK_WIDGET_CLASS(GTK_OBJECT(p->hruler)->klass);
+#endif
+
+ signal_func = (GtkSignalFunc) class->motion_notify_event;
+ g_signal_connect_swapped(GTK_OBJECT(p->window), "motion_notify_event", signal_func, GTK_OBJECT(p->hruler));
+
+#ifdef HAVE_GTK2
+ class = (GtkWidgetClass *) GTK_VSCROLLBAR_GET_CLASS(p->vruler);
+#else
+ class = GTK_WIDGET_CLASS(GTK_OBJECT(p->vruler)->klass);
+#endif
+
+ signal_func = (GtkSignalFunc) class->motion_notify_event;
+ g_signal_connect_swapped(GTK_OBJECT(p->window), "motion_notify_event", signal_func, GTK_OBJECT(p->vruler));
+
+
+ p->viewport = gtk_frame_new(/* label */ 0);
+ gtk_frame_set_shadow_type(GTK_FRAME(p->viewport), GTK_SHADOW_IN);
+ gtk_container_add(GTK_CONTAINER(p->viewport), p->window);
+ gtk_widget_show(p->viewport);
+
+ gtk_table_attach(GTK_TABLE(table), p->viewport, 1, 2, 1, 2,
+ GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
+ /* the preview area is ready */
+
+
+
+ /* the outer hbox at the bottom */
+ outer_hbox = gtk_hbox_new(FALSE, 4);
+ gtk_container_set_border_width(GTK_CONTAINER(outer_hbox), 1);
+ gtk_box_pack_start(GTK_BOX(vbox), outer_hbox, FALSE, FALSE, 0);
+ gtk_widget_show(outer_hbox);
+
+ /* the middle vbox at the bottom */
+ middle_vbox = gtk_vbox_new(FALSE, 4);
+ gtk_container_set_border_width(GTK_CONTAINER(middle_vbox), 1);
+ gtk_box_pack_start(GTK_BOX(outer_hbox), middle_vbox, FALSE, FALSE, 0);
+ gtk_widget_show(middle_vbox);
+
+ /* the menu_box (hbox) */
+ p->menu_box = gtk_hbox_new(FALSE, 4);
+ gtk_container_set_border_width(GTK_CONTAINER(p->menu_box), 1);
+ gtk_box_pack_start(GTK_BOX(middle_vbox), p->menu_box, FALSE, FALSE, 0);
+
+ xsane_separator_new(middle_vbox, 1);
+
+
/* select maximum scanarea */
+ pixmap = gdk_pixmap_create_from_xpm_d(p->top->window, &mask, xsane.bg_trans, (gchar **) size_xpm);
+ pixmapwidget = gtk_image_new_from_pixmap(pixmap, mask);
+ gtk_box_pack_start(GTK_BOX(p->menu_box), pixmapwidget, FALSE, FALSE, 2);
+ gtk_widget_show(pixmapwidget);
+ gdk_drawable_unref(pixmap);
preset_area_option_menu = gtk_option_menu_new();
xsane_back_gtk_set_tooltip(xsane.tooltips, preset_area_option_menu, DESC_PRESET_AREA);
- gtk_box_pack_start(GTK_BOX(p->button_box), preset_area_option_menu, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(p->menu_box), preset_area_option_menu, FALSE, FALSE, 0);
gtk_widget_show(preset_area_option_menu);
p->preset_area_option_menu = preset_area_option_menu;
preview_create_preset_area_menu(p, 0); /* build menu and set default to 0=full size */
+ xsane_vseparator_new(p->menu_box, 3);
/* select rotation */
+ pixmap = gdk_pixmap_create_from_xpm_d(p->top->window, &mask, xsane.bg_trans, (gchar **) rotation_xpm);
+ pixmapwidget = gtk_image_new_from_pixmap(pixmap, mask);
+ gtk_box_pack_start(GTK_BOX(p->menu_box), pixmapwidget, FALSE, FALSE, 2);
+ gtk_widget_show(pixmapwidget);
+ gdk_drawable_unref(pixmap);
+
rotation_menu = gtk_menu_new();
for (i = 0; i < 12; ++i)
{
- char buffer[256];
int rot;
if (i<4)
{
- snprintf(buffer, sizeof(buffer), "%03d ", i*90);
+ snprintf(buf, sizeof(buf), "%03d ", i*90);
rot = i;
}
else if (i<8)
{
- snprintf(buffer, sizeof(buffer), "%03d |", i*90-360);
+ snprintf(buf, sizeof(buf), "%03d |", i*90-360);
rot = i;
}
else
{
- snprintf(buffer, sizeof(buffer), "%03d -", i*90-2*360);
+ snprintf(buf, sizeof(buf), "%03d -", i*90-2*360);
rot = (((i & 3) + 2) & 3) + 4;
}
- rotation_item = gtk_menu_item_new_with_label(buffer);
+ rotation_item = gtk_menu_item_new_with_label(buf);
gtk_container_add(GTK_CONTAINER(rotation_menu), rotation_item);
- gtk_signal_connect(GTK_OBJECT(rotation_item), "activate", (GtkSignalFunc) preview_rotation_callback, p);
+ g_signal_connect(GTK_OBJECT(rotation_item), "activate", (GtkSignalFunc) preview_rotation_callback, p);
gtk_object_set_data(GTK_OBJECT(rotation_item), "Selection", (void *) rot);
gtk_widget_show(rotation_item);
@@ -3573,133 +4475,143 @@ Preview *preview_new(void)
rotation_option_menu = gtk_option_menu_new();
xsane_back_gtk_set_tooltip(xsane.tooltips, rotation_option_menu, DESC_ROTATION);
- gtk_box_pack_start(GTK_BOX(p->button_box), rotation_option_menu, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(p->menu_box), rotation_option_menu, FALSE, FALSE, 0);
gtk_option_menu_set_menu(GTK_OPTION_MENU(rotation_option_menu), rotation_menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(rotation_option_menu), p->rotation); /* set rotation */
-/* xsane_back_gtk_set_tooltip(tooltips, rotation_option_menu, desc); */
gtk_widget_show(rotation_option_menu);
p->rotation_option_menu = rotation_option_menu;
+ xsane_vseparator_new(p->menu_box, 3);
- gtk_widget_show(p->button_box);
-
+ /* the preview aspect ratio menu */
+ pixmap = gdk_pixmap_create_from_xpm_d(p->top->window, &mask, xsane.bg_trans, (gchar **) aspect_ratio_xpm);
+ pixmapwidget = gtk_image_new_from_pixmap(pixmap, mask);
+ gtk_box_pack_start(GTK_BOX(p->menu_box), pixmapwidget, FALSE, FALSE, 2);
+ gtk_widget_show(pixmapwidget);
+ gdk_drawable_unref(pixmap);
+ ratio_menu = gtk_menu_new();
- /* construct the preview area (table with sliders & preview window) */
- table = gtk_table_new(2, 2, /* homogeneous */ FALSE);
- gtk_table_set_col_spacing(GTK_TABLE(table), 0, 1);
- gtk_table_set_row_spacing(GTK_TABLE(table), 0, 1);
- gtk_container_set_border_width(GTK_CONTAINER(table), 1);
- gtk_box_pack_start(GTK_BOX(vbox), table, /* expand */ TRUE, /* fill */ TRUE, /* padding */ 0);
+ for (i = 0; i < sizeof(ratio_value)/sizeof(float); ++i)
+ {
+ ratio_item = gtk_menu_item_new_with_label(ratio_string[i]);
+ gtk_container_add(GTK_CONTAINER(ratio_menu), ratio_item);
+ g_signal_connect(GTK_OBJECT(ratio_item), "activate", (GtkSignalFunc) preview_ratio_callback, p);
+ gtk_object_set_data(GTK_OBJECT(ratio_item), "Selection", &ratio_value[i]);
- /* the empty box in the top-left corner */
- frame = gtk_frame_new(/* label */ 0);
- gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
- gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+ gtk_widget_show(ratio_item);
- /* the unit label */
- p->unit_label = gtk_label_new("cm");
- gtk_container_add(GTK_CONTAINER(frame), p->unit_label);
- gtk_widget_show(p->unit_label);
+ if (ratio_value[i] == p->ratio)
+ {
+ ratio_nr = i;
+ }
+ }
- /* the horizontal ruler */
- p->hruler = gtk_hruler_new();
- gtk_table_attach(GTK_TABLE(table), p->hruler, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
+ ratio_option_menu = gtk_option_menu_new();
+ xsane_back_gtk_set_tooltip(xsane.tooltips, ratio_option_menu, DESC_RATIO);
+ gtk_box_pack_start(GTK_BOX(p->menu_box), ratio_option_menu, FALSE, FALSE, 0);
+ gtk_option_menu_set_menu(GTK_OPTION_MENU(ratio_option_menu), ratio_menu);
+ gtk_option_menu_set_history(GTK_OPTION_MENU(ratio_option_menu), ratio_nr); /* set ratio */
- /* the vertical ruler */
- p->vruler = gtk_vruler_new();
- gtk_table_attach(GTK_TABLE(table), p->vruler, 0, 1, 1, 2, 0, GTK_FILL, 0, 0);
+ gtk_widget_show(ratio_option_menu);
+ p->ratio_option_menu = ratio_option_menu;
- /* the preview area */
- p->window = gtk_preview_new(GTK_PREVIEW_COLOR);
- gtk_preview_set_expand(GTK_PREVIEW(p->window), TRUE);
-
- gtk_widget_set_events(p->window, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
- GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
-
- /* the first expose_event is responsible to undraw the selection frame */
- gtk_signal_connect(GTK_OBJECT(p->window), "expose_event", (GtkSignalFunc) preview_expose_event_handler_start, p);
- gtk_signal_connect(GTK_OBJECT(p->window), "button_press_event", (GtkSignalFunc) preview_button_press_event_handler, p);
- gtk_signal_connect(GTK_OBJECT(p->window), "motion_notify_event", (GtkSignalFunc) preview_motion_event_handler, p);
- gtk_signal_connect(GTK_OBJECT(p->window), "button_release_event", (GtkSignalFunc) preview_button_release_event_handler, p);
- gtk_signal_connect_after(GTK_OBJECT(p->window), "size_allocate", (GtkSignalFunc) preview_area_resize_handler, p);
- /* the second expose_event is responsible to redraw the selection frame */
- gtk_signal_connect_after(GTK_OBJECT(p->window), "expose_event", (GtkSignalFunc) preview_expose_event_handler_end, p);
+ /* the pointer zoom */
+ frame = gtk_frame_new(0);
+ gtk_box_pack_start(GTK_BOX(outer_hbox), frame, FALSE, FALSE, 3);
+ gtk_container_set_border_width(GTK_CONTAINER(frame), 0);
+ gtk_widget_show(frame);
+ p->zoom = gtk_preview_new(GTK_PREVIEW_COLOR);
+ gtk_preview_size(GTK_PREVIEW(p->zoom), XSANE_ZOOM_SIZE, XSANE_ZOOM_SIZE);
+ gtk_container_add(GTK_CONTAINER(frame), p->zoom);
+ gtk_widget_show(p->zoom);
- /* Connect the motion-notify events of the preview area with the rulers. Nifty stuff! */
- class = GTK_WIDGET_CLASS(GTK_OBJECT(p->hruler)->klass);
- signal_func = (GtkSignalFunc) class->motion_notify_event;
- gtk_signal_connect_object(GTK_OBJECT(p->window), "motion_notify_event", signal_func, GTK_OBJECT(p->hruler));
- class = GTK_WIDGET_CLASS(GTK_OBJECT(p->vruler)->klass);
- signal_func = (GtkSignalFunc) class->motion_notify_event;
- gtk_signal_connect_object(GTK_OBJECT(p->window), "motion_notify_event", signal_func, GTK_OBJECT(p->vruler));
+#if 0
+ /* the RGB label */
+ frame = gtk_frame_new(0);
+ gtk_box_pack_start(GTK_BOX(p->menu_box), frame, FALSE, FALSE, 3);
+ gtk_widget_show(frame);
+ p->rgb_label = gtk_label_new(0);
+ gtk_container_add(GTK_CONTAINER(frame), p->rgb_label);
+ gtk_widget_show(p->rgb_label);
+ preview_display_color_components(p, -1, -1); /* display "###, ###, ###" */
+#endif
+ gtk_widget_show(p->menu_box);
+ /* the menu box is ready */
- p->viewport = gtk_frame_new(/* label */ 0);
- gtk_frame_set_shadow_type(GTK_FRAME(p->viewport), GTK_SHADOW_IN);
- gtk_container_add(GTK_CONTAINER(p->viewport), p->window);
- gtk_table_attach(GTK_TABLE(table), p->viewport, 1, 2, 1, 2,
- GTK_FILL | GTK_EXPAND | GTK_SHRINK, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
- preview_update_surface(p, 0);
+ /* set the action_hbox */
+ action_box = gtk_hbox_new(FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(middle_vbox), action_box, FALSE, FALSE, 2);
+ gtk_container_set_border_width(GTK_CONTAINER(action_box), 0);
+ gtk_widget_show(action_box);
- /* fill in action area: */
/* the (in)valid pixmaps */
pixmap = gdk_pixmap_create_from_xpm_d(p->top->window, &mask, xsane.bg_trans, (gchar **) valid_xpm);
- p->valid_pixmap = gtk_pixmap_new(pixmap, mask);
- gtk_box_pack_start(GTK_BOX(hbox), p->valid_pixmap, FALSE, FALSE, 0);
+ p->valid_pixmap = gtk_image_new_from_pixmap(pixmap, mask);
+ gtk_box_pack_start(GTK_BOX(action_box), p->valid_pixmap, FALSE, FALSE, 0);
gtk_widget_show(p->valid_pixmap);
- gdk_pixmap_unref(pixmap);
+ gdk_drawable_unref(pixmap);
pixmap = gdk_pixmap_create_from_xpm_d(p->top->window, &mask, xsane.bg_trans, (gchar **) scanning_xpm);
- p->scanning_pixmap = gtk_pixmap_new(pixmap, mask);
- gtk_box_pack_start(GTK_BOX(hbox), p->scanning_pixmap, FALSE, FALSE, 0);
+ p->scanning_pixmap = gtk_image_new_from_pixmap(pixmap, mask);
+ gtk_box_pack_start(GTK_BOX(action_box), p->scanning_pixmap, FALSE, FALSE, 0);
gtk_widget_show(p->scanning_pixmap);
- gdk_pixmap_unref(pixmap);
+ gdk_drawable_unref(pixmap);
pixmap = gdk_pixmap_create_from_xpm_d(p->top->window, &mask, xsane.bg_trans, (gchar **) incomplete_xpm);
- p->incomplete_pixmap = gtk_pixmap_new(pixmap, mask);
- gtk_box_pack_start(GTK_BOX(hbox), p->incomplete_pixmap, FALSE, FALSE, 0);
+ p->incomplete_pixmap = gtk_image_new_from_pixmap(pixmap, mask);
+ gtk_box_pack_start(GTK_BOX(action_box), p->incomplete_pixmap, FALSE, FALSE, 0);
gtk_widget_show(p->incomplete_pixmap);
- gdk_pixmap_unref(pixmap);
+ gdk_drawable_unref(pixmap);
pixmap = gdk_pixmap_create_from_xpm_d(p->top->window, &mask, xsane.bg_trans, (gchar **) invalid_xpm);
- p->invalid_pixmap = gtk_pixmap_new(pixmap, mask);
- gtk_box_pack_start(GTK_BOX(hbox), p->invalid_pixmap, FALSE, FALSE, 0);
+ p->invalid_pixmap = gtk_image_new_from_pixmap(pixmap, mask);
+ gtk_box_pack_start(GTK_BOX(action_box), p->invalid_pixmap, FALSE, FALSE, 0);
gtk_widget_show(p->invalid_pixmap);
- gdk_pixmap_unref(pixmap);
+ gdk_drawable_unref(pixmap);
+
/* Start button */
p->start = gtk_button_new_with_label(BUTTON_PREVIEW_ACQUIRE);
xsane_back_gtk_set_tooltip(xsane.tooltips, p->start, DESC_PREVIEW_ACQUIRE);
- gtk_signal_connect(GTK_OBJECT(p->start), "clicked", (GtkSignalFunc) preview_start_button_clicked, p);
- gtk_box_pack_start(GTK_BOX(hbox), p->start, TRUE, TRUE, 10);
- gtk_widget_add_accelerator(p->start, "clicked", xsane.accelerator_group, GDK_P, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt P */
+ g_signal_connect(GTK_OBJECT(p->start), "clicked", (GtkSignalFunc) preview_start_button_clicked, p);
+ gtk_box_pack_start(GTK_BOX(action_box), p->start, TRUE, TRUE, 5);
+ gtk_widget_add_accelerator(p->start, "clicked", xsane.accelerator_group, GDK_P, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt P */
+ gtk_widget_show(p->start);
/* Cancel button */
p->cancel = gtk_button_new_with_label(BUTTON_PREVIEW_CANCEL);
xsane_back_gtk_set_tooltip(xsane.tooltips, p->cancel, DESC_PREVIEW_CANCEL);
- gtk_signal_connect(GTK_OBJECT(p->cancel), "clicked", (GtkSignalFunc) preview_cancel_button_clicked, p);
- gtk_box_pack_start(GTK_BOX(hbox), p->cancel, TRUE, TRUE, 10);
- gtk_widget_add_accelerator(p->cancel, "clicked", xsane.accelerator_group, GDK_Escape, GDK_MOD1_MASK, GTK_ACCEL_LOCKED); /* Alt ESC */
+ g_signal_connect(GTK_OBJECT(p->cancel), "clicked", (GtkSignalFunc) preview_cancel_button_clicked, p);
+ gtk_box_pack_start(GTK_BOX(action_box), p->cancel, TRUE, TRUE, 5);
+ gtk_widget_add_accelerator(p->cancel, "clicked", xsane.accelerator_group, GDK_Escape, GDK_MOD1_MASK, DEF_GTK_ACCEL_LOCKED); /* Alt ESC */
+ gtk_widget_show(p->cancel);
gtk_widget_set_sensitive(p->cancel, FALSE);
- gtk_widget_show(p->cancel);
- gtk_widget_show(p->start);
- gtk_widget_show(p->viewport);
- gtk_widget_show(p->window);
- gtk_widget_show(p->hruler);
- gtk_widget_show(p->vruler);
+#if 1
+ /* the RGB label */
+ frame = gtk_frame_new(0);
+ gtk_box_pack_start(GTK_BOX(action_box), frame, FALSE, FALSE, 3);
gtk_widget_show(frame);
- gtk_widget_show(table);
+ p->rgb_label = gtk_label_new(0);
+ gtk_container_add(GTK_CONTAINER(frame), p->rgb_label);
+ gtk_widget_show(p->rgb_label);
+ preview_display_color_components(p, -1, -1); /* display "###, ###, ###" */
+#endif
+
+ preview_update_surface(p, 0);
+
+ gtk_widget_show(p->window);
gtk_widget_show(p->top);
cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW); /* set default curosr */
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = XSANE_CURSOR_PREVIEW;
gtk_widget_pop_colormap();
@@ -3875,6 +4787,7 @@ void preview_update_surface(Preview *p, int surface_changed)
{
gtk_widget_set_sensitive(p->preset_area_option_menu, TRUE); /* enable preset area */
gtk_widget_set_sensitive(p->zoom_in, TRUE); /* zoom in is allowed at all */
+ gtk_widget_set_sensitive(p->zoom_area, TRUE); /* zoom area is allowed at all */
gtk_widget_set_sensitive(p->full_area, TRUE); /* enable selection buttons */
gtk_widget_set_sensitive(p->autoselect, TRUE);
}
@@ -3882,6 +4795,7 @@ void preview_update_surface(Preview *p, int surface_changed)
{
gtk_widget_set_sensitive(p->preset_area_option_menu, FALSE); /* disable preset area */
gtk_widget_set_sensitive(p->zoom_in, FALSE); /* no zoom at all */
+ gtk_widget_set_sensitive(p->zoom_area, FALSE);
gtk_widget_set_sensitive(p->zoom_out, FALSE);
gtk_widget_set_sensitive(p->zoom_undo, FALSE);
gtk_widget_set_sensitive(p->zoom_not, FALSE);
@@ -3906,7 +4820,11 @@ void preview_update_surface(Preview *p, int surface_changed)
width = p->surface[p->index_xmax] - p->surface[p->index_xmin];
height = p->surface[p->index_ymax] - p->surface[p->index_ymin];
+#if 0
if ( (p->calibration) || (p->startimage) ) /* predefined image should have constant aspect */
+#else
+ if (p->calibration) /* predefined calibration image should have constant aspect */
+#endif
{
p->aspect = fabs(p->image_width/(float) p->image_height);
}
@@ -3942,7 +4860,7 @@ void preview_update_surface(Preview *p, int surface_changed)
p->preview_window_width = 0.3 * gdk_screen_width();
p->preview_window_height = 0.5 * gdk_screen_height();
preview_area_correct(p); /* calculate preview_width and height */
- gtk_widget_set_usize(GTK_WIDGET(p->window), p->preview_width, p->preview_height);
+ gtk_widget_set_size_request(GTK_WIDGET(p->window), p->preview_width, p->preview_height);
}
else if (surface_changed) /* establish new surface */
{
@@ -3967,6 +4885,7 @@ void preview_update_surface(Preview *p, int surface_changed)
/* ---------------------------------------------------------------------------------------------------------------------- */
+/* preview_scan is called once when the "Preview scan" button is pressed */
void preview_scan(Preview *p)
{
double min, max, swidth, sheight, width, height, dpi = 0;
@@ -3974,6 +4893,14 @@ void preview_scan(Preview *p)
gint gwidth, gheight;
int i;
float dsurface[4];
+ int gamma_gray_size = 256; /* set this values to image depth for more than 8bpp input support!!! */
+ int gamma_red_size = 256;
+ int gamma_green_size = 256;
+ int gamma_blue_size = 256;
+ int gamma_gray_max = 255; /* set this to to image depth for more than 8bpp output support */
+ int gamma_red_max = 255;
+ int gamma_green_max = 255;
+ int gamma_blue_max = 255;
DBG(DBG_proc, "preview_scan\n");
@@ -3995,10 +4922,6 @@ void preview_scan(Preview *p)
preview_save_option(p, xsane.well_known.bit_depth, &p->saved_bit_depth, &p->saved_bit_depth_valid);
-#if 0
- xsane_set_medium(preferences.medium[xsane.medium_nr]); /* make sure medium gamma values are up to date */
-#endif
-
/* determine dpi, if necessary: */
if (xsane.well_known.dpi > 0)
@@ -4066,6 +4989,7 @@ void preview_scan(Preview *p)
xsane_set_resolution(xsane.well_known.dpi_y, dpi); /* set resolution to dpi or next higher value that is available */
}
+
preview_rotate_previewsurface_to_devicesurface(p->rotation, p->surface, dsurface);
for (i = 0; i < 4; ++i)
@@ -4087,6 +5011,97 @@ void preview_scan(Preview *p)
}
#endif
+
+ if (xsane.well_known.gamma_vector >0)
+ {
+ const SANE_Option_Descriptor *opt;
+
+ opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector);
+ if (SANE_OPTION_IS_ACTIVE(opt->cap))
+ {
+ SANE_Int *gamma_data;
+
+ opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector);
+ gamma_gray_size = opt->size / sizeof(opt->type);
+ gamma_gray_max = opt->constraint.range->max;
+
+ gamma_data = malloc(gamma_gray_size * sizeof(SANE_Int));
+
+ if ((xsane.xsane_colors > 1) || (xsane.no_preview_medium_gamma)) /* color scan or medium preview gamma disabled */
+ {
+ xsane_create_gamma_curve(gamma_data, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_gray_size, gamma_gray_max);
+ }
+ else /* grayscale scan */
+ {
+ xsane_create_gamma_curve(gamma_data, xsane.medium_negative, 1.0, 0.0, 0.0,
+ xsane.medium_shadow_gray, xsane.medium_highlight_gray, xsane.medium_gamma_gray,
+ gamma_gray_size, gamma_gray_max);
+ }
+
+ xsane_back_gtk_update_vector(xsane.well_known.gamma_vector, gamma_data);
+ free(gamma_data);
+ }
+ }
+
+ if (xsane.well_known.gamma_vector_r >0)
+ {
+ const SANE_Option_Descriptor *opt;
+
+ opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_r);
+ if (SANE_OPTION_IS_ACTIVE(opt->cap))
+ {
+ SANE_Int *gamma_data_red, *gamma_data_green, *gamma_data_blue;
+
+ opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_r);
+ gamma_red_size = opt->size / sizeof(opt->type);
+ gamma_red_max = opt->constraint.range->max;
+
+ opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_g);
+ gamma_green_size = opt->size / sizeof(opt->type);
+ gamma_green_max = opt->constraint.range->max;
+
+ opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.gamma_vector_b);
+ gamma_blue_size = opt->size / sizeof(opt->type);
+ gamma_blue_max = opt->constraint.range->max;
+
+ gamma_data_red = malloc(gamma_red_size * sizeof(SANE_Int));
+ gamma_data_green = malloc(gamma_green_size * sizeof(SANE_Int));
+ gamma_data_blue = malloc(gamma_blue_size * sizeof(SANE_Int));
+
+ if (xsane.no_preview_medium_gamma) /* do not use medium gamma for preview */
+ {
+ DBG(DBG_info, "preview: not using medium gamma table\n");
+
+ xsane_create_gamma_curve(gamma_data_red, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_red_size, gamma_red_max);
+ xsane_create_gamma_curve(gamma_data_green, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_green_size, gamma_green_max);
+ xsane_create_gamma_curve(gamma_data_blue, 0, 1.0, 0.0, 0.0, 0.0, 100.0, 1.0, gamma_blue_size, gamma_blue_max);
+ }
+ else /* use medium gamma for preview */
+ {
+ DBG(DBG_info, "preview: using medium gamma table\n");
+
+ xsane_create_gamma_curve(gamma_data_red, xsane.medium_negative, 1.0, 0.0, 0.0,
+ xsane.medium_shadow_red, xsane.medium_highlight_red, xsane.medium_gamma_red,
+ gamma_red_size, gamma_red_max);
+ xsane_create_gamma_curve(gamma_data_green, xsane.medium_negative, 1.0, 0.0, 0.0,
+ xsane.medium_shadow_green, xsane.medium_highlight_green, xsane.medium_gamma_green,
+ gamma_green_size, gamma_green_max);
+ xsane_create_gamma_curve(gamma_data_blue, xsane.medium_negative, 1.0, 0.0, 0.0,
+ xsane.medium_shadow_blue, xsane.medium_highlight_blue, xsane.medium_gamma_blue,
+ gamma_blue_size, gamma_blue_max);
+ }
+
+ xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_r, gamma_data_red);
+ xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_g, gamma_data_green);
+ xsane_back_gtk_update_vector(xsane.well_known.gamma_vector_b, gamma_data_blue);
+
+ free(gamma_data_red);
+ free(gamma_data_green);
+ free(gamma_data_blue);
+ }
+ }
+
+
xsane.block_update_param = FALSE;
p->preview_colors = xsane.xsane_colors;
p->scan_incomplete = FALSE;
@@ -4189,6 +5204,8 @@ static void preview_delete_images(Preview *p)
fclose(out);
}
preview_update_surface(p, 1);
+
+ xsane_batch_scan_update_icon_list();
}
/* ---------------------------------------------------------------------------------------------------------------------- */
@@ -4232,12 +5249,12 @@ void preview_destroy(Preview *p)
if (p->gc_selection)
{
- gdk_gc_destroy(p->gc_selection);
+ gdk_gc_unref(p->gc_selection);
}
if (p->gc_selection_maximum)
{
- gdk_gc_destroy(p->gc_selection_maximum);
+ gdk_gc_unref(p->gc_selection_maximum);
}
if (p->top)
@@ -4251,6 +5268,27 @@ void preview_destroy(Preview *p)
/* ---------------------------------------------------------------------------------------------------------------------- */
+static void preview_zoom_area(GtkWidget *window, gpointer data)
+{
+ Preview *p=data;
+ int i;
+
+ DBG(DBG_proc, "preview_zoom_area\n");
+
+ for (i=0; i<4; i++)
+ {
+ p->old_surface[i] = p->surface[i];
+ p->surface[i] = p->selection.coordinate[i];
+ }
+
+ preview_update_surface(p, 1);
+ gtk_widget_set_sensitive(p->zoom_not, TRUE); /* allow unzoom */
+ gtk_widget_set_sensitive(p->zoom_out, TRUE); /* allow zoom out */
+ gtk_widget_set_sensitive(p->zoom_undo,TRUE); /* allow zoom undo */
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
static void preview_zoom_not(GtkWidget *window, gpointer data)
{
Preview *p=data;
@@ -4320,19 +5358,25 @@ static void preview_zoom_out(GtkWidget *window, gpointer data)
/* ---------------------------------------------------------------------------------------------------------------------- */
-static void preview_zoom_in(GtkWidget *window, gpointer data)
+static void preview_select_zoom_point(Preview *p, int preview_x, int preview_y)
{
- Preview *p=data;
int i;
+ float device_x, device_y;
- DBG(DBG_proc, "preview_zoom_in\n");
+ DBG(DBG_proc, "preview_select_zoom_point(%d, %d)\n", preview_x, preview_y);
+
+ preview_transform_coordinate_window_to_device(p, preview_x, preview_y, &device_x, &device_y);
for (i=0; i<4; i++)
{
p->old_surface[i] = p->surface[i];
- p->surface[i] = p->selection.coordinate[i];
}
+ p->surface[0] = device_x + (p->surface[0] - device_x) * 0.8;
+ p->surface[1] = device_y + (p->surface[1] - device_y) * 0.8;
+ p->surface[2] = device_x + (p->surface[2] - device_x) * 0.8;
+ p->surface[3] = device_y + (p->surface[3] - device_y) * 0.8;
+
preview_update_surface(p, 1);
gtk_widget_set_sensitive(p->zoom_not, TRUE); /* allow unzoom */
gtk_widget_set_sensitive(p->zoom_out, TRUE); /* allow zoom out */
@@ -4375,7 +5419,7 @@ static void preview_get_color(Preview *p, int x, int y, int range, int *red, int
{
preview_transform_coordinate_window_to_image(p, x, y, &image_x, &image_y);
- if ( (image_x < p->image_width) && (image_y < p->image_height) )
+ if ( (image_x >= 0) && (image_x < p->image_width) && (image_y >=0) && (image_y < p->image_height) )
{
image_x_min = image_x - range/2;
image_y_min = image_y - range/2;
@@ -4423,6 +5467,20 @@ static void preview_get_color(Preview *p, int x, int y, int range, int *red, int
/* ---------------------------------------------------------------------------------------------------------------------- */
+static void preview_add_batch(GtkWidget *window, Preview *data)
+{
+ DBG(DBG_proc, "preview_add_batch\n");
+
+ xsane_batch_scan_add(); /* add active settings to batch list */
+
+#if 0
+ preview_draw_selection(p); /* read selection from backend: correct rotation */
+ preview_establish_selection(p); /* read selection from backend: correct rotation */
+#endif
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
static void preview_pipette_white(GtkWidget *window, gpointer data)
{
Preview *p=data;
@@ -4450,7 +5508,7 @@ static void preview_pipette_white(GtkWidget *window, gpointer data)
cursor = gdk_cursor_new_from_pixmap(pixmap, mask, &fg, &bg, CURSOR_PIPETTE_HOT_X, CURSOR_PIPETTE_HOT_Y);
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = -1;
}
@@ -4483,7 +5541,7 @@ static void preview_pipette_gray(GtkWidget *window, gpointer data)
cursor = gdk_cursor_new_from_pixmap(pixmap, mask, &fg, &bg, CURSOR_PIPETTE_HOT_X, CURSOR_PIPETTE_HOT_Y);
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = -1;
}
@@ -4516,12 +5574,77 @@ static void preview_pipette_black(GtkWidget *window, gpointer data)
cursor = gdk_cursor_new_from_pixmap(pixmap, mask, &fg, &bg, CURSOR_PIPETTE_HOT_X, CURSOR_PIPETTE_HOT_Y);
gdk_window_set_cursor(p->window->window, cursor);
- gdk_cursor_destroy(cursor);
+ gdk_cursor_unref(cursor);
+ p->cursornr = -1;
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static void preview_init_autoraise_scanarea(GtkWidget *window, gpointer data)
+{
+ Preview *p=data;
+ GdkCursor *cursor;
+ GdkColor fg;
+ GdkColor bg;
+ GdkPixmap *pixmap;
+ GdkPixmap *mask;
+
+ DBG(DBG_proc, "preview_init_autoraise_scanarea\n");
+
+ p->mode = MODE_AUTORAISE_SCANAREA;
+
+ pixmap = gdk_bitmap_create_from_data(p->top->window, cursor_autoraise_scanarea, CURSOR_AUTORAISE_SCANAREA_WIDTH, CURSOR_AUTORAISE_SCANAREA_HEIGHT);
+ mask = gdk_bitmap_create_from_data(p->top->window, cursor_autoraise_scanarea_mask, CURSOR_AUTORAISE_SCANAREA_WIDTH, CURSOR_AUTORAISE_SCANAREA_HEIGHT);
+
+ fg.red = 0;
+ fg.green = 0;
+ fg.blue = 0;
+
+ bg.red = 65535;
+ bg.green = 65535;
+ bg.blue = 65535;
+
+ cursor = gdk_cursor_new_from_pixmap(pixmap, mask, &fg, &bg, CURSOR_AUTORAISE_SCANAREA_HOT_X, CURSOR_AUTORAISE_SCANAREA_HOT_Y);
+
+ gdk_window_set_cursor(p->window->window, cursor);
+ gdk_cursor_unref(cursor);
p->cursornr = -1;
}
/* ---------------------------------------------------------------------------------------------------------------------- */
+static void preview_zoom_in(GtkWidget *window, gpointer data)
+{
+ Preview *p=data;
+ GdkCursor *cursor;
+ GdkColor fg;
+ GdkColor bg;
+ GdkPixmap *pixmap;
+ GdkPixmap *mask;
+
+ DBG(DBG_proc, "preview_zoom\n");
+
+ p->mode = MODE_ZOOM_IN;
+
+ pixmap = gdk_bitmap_create_from_data(p->top->window, cursor_zoom, CURSOR_ZOOM_WIDTH, CURSOR_ZOOM_HEIGHT);
+ mask = gdk_bitmap_create_from_data(p->top->window, cursor_zoom_mask, CURSOR_ZOOM_WIDTH, CURSOR_ZOOM_HEIGHT);
+
+ fg.red = 0;
+ fg.green = 0;
+ fg.blue = 0;
+
+ bg.red = 65535;
+ bg.green = 65535;
+ bg.blue = 65535;
+
+ cursor = gdk_cursor_new_from_pixmap(pixmap, mask, &fg, &bg, CURSOR_ZOOM_HOT_X, CURSOR_ZOOM_HOT_Y);
+
+ gdk_window_set_cursor(p->window->window, cursor);
+ gdk_cursor_unref(cursor);
+ p->cursornr = -1;
+}
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
void preview_select_full_preview_area(Preview *p)
{
int i;
@@ -4566,32 +5689,15 @@ static void preview_delete_images_callback(GtkWidget *widget, gpointer call_data
/* ---------------------------------------------------------------------------------------------------------------------- */
-int xsane_preset_area_entry_rename;
-
-static void xsane_preset_area_entry_rename_button_callback(GtkWidget *widget, gpointer data)
-{
- DBG(DBG_proc, "xsane_preset_area_entry_rename\n");
-
- xsane_preset_area_entry_rename = (int) data;
-}
-
-/* ---------------------------------------------------------------------------------------------------------------------- */
-
static gint preview_preset_area_rename_callback(GtkWidget *widget, GtkWidget *preset_area_widget)
{
int selection;
char *oldname;
char *newname;
Preview *p;
- GtkWidget *rename_dialog;
- GtkWidget *text;
- GtkWidget *button;
- GtkWidget *vbox, *hbox;
GtkWidget *old_preset_area_menu;
- char buf[256];
int old_selection;
-
DBG(DBG_proc, "preview_preset_area_rename_callback\n");
selection = (int) gtk_object_get_data(GTK_OBJECT(preset_area_widget), "Selection");
@@ -4599,71 +5705,15 @@ static gint preview_preset_area_rename_callback(GtkWidget *widget, GtkWidget *pr
DBG(DBG_info ,"rename %s\n", preferences.preset_area[selection]->name);
+ /* set menu in correct state, is a bit strange this way but I do not have a better idea */
old_preset_area_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(p->preset_area_option_menu));
old_selection = (int) gtk_object_get_data(GTK_OBJECT(gtk_menu_get_active(GTK_MENU(old_preset_area_menu))), "Selection");
-
gtk_menu_popdown(GTK_MENU(old_preset_area_menu));
- /* set menu in correct state, is a bit strange this way but I do not have a better idea */
gtk_option_menu_set_history(GTK_OPTION_MENU(p->preset_area_option_menu), old_selection);
oldname = strdup(preferences.preset_area[selection]->name);
- rename_dialog = gtk_window_new(GTK_WINDOW_DIALOG);
- xsane_set_window_icon(rename_dialog, 0);
-
- /* set rename dialog */
- gtk_window_set_position(GTK_WINDOW(rename_dialog), GTK_WIN_POS_CENTER);
- gtk_window_set_policy(GTK_WINDOW(rename_dialog), FALSE, FALSE, FALSE);
- snprintf(buf, sizeof(buf), "%s %s", xsane.prog_name, WINDOW_PRESET_AREA_RENAME);
- gtk_window_set_title(GTK_WINDOW(rename_dialog), buf);
- gtk_signal_connect(GTK_OBJECT(rename_dialog), "delete_event", (GtkSignalFunc) xsane_preset_area_entry_rename_button_callback, (void *) -1);
- gtk_widget_show(rename_dialog);
-
- /* set the main vbox */
- vbox = gtk_vbox_new(FALSE, 0);
- gtk_container_set_border_width(GTK_CONTAINER(vbox), 0);
- gtk_container_add(GTK_CONTAINER(rename_dialog), vbox);
- gtk_widget_show(vbox);
-
- /* set the main hbox */
- hbox = gtk_hbox_new(FALSE, 0);
- xsane_separator_new(vbox, 2);
- gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
- gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
- gtk_widget_show(hbox);
-
- text = gtk_entry_new_with_max_length(64);
- xsane_back_gtk_set_tooltip(xsane.tooltips, text, DESC_PRESET_AREA_NAME);
- gtk_entry_set_text(GTK_ENTRY(text), oldname);
- gtk_widget_set_usize(text, 300, 0);
- gtk_box_pack_start(GTK_BOX(vbox), text, TRUE, TRUE, 4);
- gtk_widget_show(text);
-
-
- button = gtk_button_new_with_label("OK");
- gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc) xsane_preset_area_entry_rename_button_callback, (void *) 1);
- gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
- gtk_widget_show(button);
-
- button = gtk_button_new_with_label("Cancel");
- gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc) xsane_preset_area_entry_rename_button_callback, (void *) -1);
- gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
- gtk_widget_show(button);
-
- xsane_preset_area_entry_rename = 0;
-
- while (xsane_preset_area_entry_rename == 0)
- {
- while (gtk_events_pending())
- {
- DBG(DBG_info, "preview_preset_area_rename_callback: calling gtk_main_iteration\n");
- gtk_main_iteration();
- }
- }
-
- newname = strdup(gtk_entry_get_text(GTK_ENTRY(text)));
-
- if (xsane_preset_area_entry_rename == 1) /* OK button has been pressed */
+ if (!xsane_front_gtk_getname_dialog(WINDOW_PRESET_AREA_RENAME, DESC_PRESET_AREA_RENAME, oldname, &newname))
{
gtk_option_menu_remove_menu(GTK_OPTION_MENU(p->preset_area_option_menu));
@@ -4682,8 +5732,6 @@ static gint preview_preset_area_rename_callback(GtkWidget *widget, GtkWidget *pr
free(oldname);
free(newname);
- gtk_widget_destroy(rename_dialog);
-
xsane_set_sensitivity(TRUE);
return TRUE; /* event is handled */
@@ -4695,6 +5743,9 @@ static gint preview_preset_area_add_callback(GtkWidget *widget, GtkWidget *prese
{
int selection, i, old_selection = 0;
Preview *p;
+ float coord[4];
+ char suggested_name[256];
+ char *newname;
GtkWidget *old_preset_area_menu;
DBG(DBG_proc, "preview_preset_area_add_callback\n");
@@ -4702,11 +5753,18 @@ static gint preview_preset_area_add_callback(GtkWidget *widget, GtkWidget *prese
selection = (int) gtk_object_get_data(GTK_OBJECT(preset_area_widget), "Selection");
p = (Preview *) gtk_object_get_data(GTK_OBJECT(preset_area_widget), "Preview");
- if (selection < preferences.preset_area_definitions)
- {
- char buf[256];
- float coord[4];
+ /* set menu in correct state, is a bit strange this way but I do not have a better idea */
+ old_preset_area_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(p->preset_area_option_menu));
+ old_selection = (int) gtk_object_get_data(GTK_OBJECT(gtk_menu_get_active(GTK_MENU(old_preset_area_menu))), "Selection");
+ gtk_menu_popdown(GTK_MENU(old_preset_area_menu));
+ gtk_option_menu_set_history(GTK_OPTION_MENU(p->preset_area_option_menu), old_selection);
+
+ /* sugggest name = size in mm */
+ preview_rotate_previewsurface_to_devicesurface(p->rotation, p->selection.coordinate, coord);
+ snprintf(suggested_name, sizeof(suggested_name), "%d mm x %d mm", (int) (coord[2]-coord[0]), (int) (coord[3]-coord[1]));
+ if (!xsane_front_gtk_getname_dialog(WINDOW_PRESET_AREA_ADD, DESC_PRESET_AREA_ADD, suggested_name, &newname))
+ {
preferences.preset_area = realloc(preferences.preset_area, (preferences.preset_area_definitions+1) * sizeof(void *));
/* shift all items after selection */
@@ -4715,32 +5773,18 @@ static gint preview_preset_area_add_callback(GtkWidget *widget, GtkWidget *prese
preferences.preset_area[i+1] = preferences.preset_area[i];
}
- /* insert new item behind selected item, name is size in mm */
- preview_rotate_previewsurface_to_devicesurface(p->rotation, p->selection.coordinate, coord);
- snprintf(buf, sizeof(buf), "%d mm x %d mm", (int) (coord[2]-coord[0]), (int) (coord[3]-coord[1]));
+ /* insert new item behind selected item */
preferences.preset_area[selection+1] = calloc(sizeof(Preferences_preset_area_t), 1);
- preferences.preset_area[selection+1]->name = strdup(buf);
+ preferences.preset_area[selection+1]->name = strdup(newname);
preferences.preset_area[selection+1]->xoffset = coord[0];
preferences.preset_area[selection+1]->yoffset = coord[1];
preferences.preset_area[selection+1]->width = coord[2] - coord[0];
preferences.preset_area[selection+1]->height = coord[3] - coord[1];
- DBG(DBG_proc, "added %s\n", buf);
+ DBG(DBG_proc, "added %s\n", newname);
preferences.preset_area_definitions++;
- old_preset_area_menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(p->preset_area_option_menu));
-
- gtk_option_menu_remove_menu(GTK_OPTION_MENU(p->preset_area_option_menu));
- old_selection = (int) gtk_object_get_data(GTK_OBJECT(gtk_menu_get_active(GTK_MENU(old_preset_area_menu))), "Selection");
-
- if (old_selection > selection) /* we are moving the selected surface */
- {
- old_selection++;
- }
-
- gtk_widget_destroy(old_preset_area_menu);
-
preview_create_preset_area_menu(p, old_selection);
}
@@ -4895,6 +5939,7 @@ static gint preview_preset_area_context_menu_callback(GtkWidget *widget, GdkEven
GtkWidget *menu_item;
GdkEventButton *event_button;
int selection;
+ char buf[256];
DBG(DBG_proc, "preview_preset_area_context_menu_callback\n");
@@ -4912,42 +5957,51 @@ static gint preview_preset_area_context_menu_callback(GtkWidget *widget, GdkEven
menu_item = gtk_menu_item_new_with_label(MENU_ITEM_PRESET_AREA_ADD_SEL);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(menu), menu_item);
- gtk_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_add_callback, widget);
+ g_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_add_callback, widget);
+
+ /* add separator */
+ menu_item = gtk_menu_item_new();
+ gtk_widget_show(menu_item);
+ gtk_container_add(GTK_CONTAINER(menu), menu_item);
/* rename preset area */
- menu_item = gtk_menu_item_new_with_label(MENU_ITEM_PRESET_AREA_RENAME);
+ snprintf(buf, sizeof(buf), "%s: %s", preferences.preset_area[selection]->name, MENU_ITEM_RENAME);
+ menu_item = gtk_menu_item_new_with_label(buf);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(menu), menu_item);
- gtk_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_rename_callback, widget);
+ g_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_rename_callback, widget);
if (selection) /* not available for "full area" */
{
/* delete preset area */
- menu_item = gtk_menu_item_new_with_label(MENU_ITEM_PRESET_AREA_DELETE);
+ snprintf(buf, sizeof(buf), "%s: %s", preferences.preset_area[selection]->name, MENU_ITEM_DELETE);
+ menu_item = gtk_menu_item_new_with_label(buf);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(menu), menu_item);
- gtk_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_delete_callback, widget);
+ g_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_delete_callback, widget);
}
if (selection>1) /* available from 3rd item */
{
/* move up */
- menu_item = gtk_menu_item_new_with_label(MENU_OTEM_PRESET_AREA_MOVE_UP);
+ snprintf(buf, sizeof(buf), "%s: %s", preferences.preset_area[selection]->name, MENU_ITEM_MOVE_UP);
+ menu_item = gtk_menu_item_new_with_label(buf);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(menu), menu_item);
- gtk_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_move_up_callback, widget);
+ g_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_move_up_callback, widget);
}
if ((selection) && (selection < preferences.preset_area_definitions-1))
{
/* move down */
- menu_item = gtk_menu_item_new_with_label(MENU_OTEM_PRESET_AREA_MOVE_DWN);
+ snprintf(buf, sizeof(buf), "%s: %s", preferences.preset_area[selection]->name, MENU_ITEM_MOVE_DWN);
+ menu_item = gtk_menu_item_new_with_label(buf);
gtk_widget_show(menu_item);
gtk_container_add(GTK_CONTAINER(menu), menu_item);
- gtk_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_move_down_callback, widget);
+ g_signal_connect(GTK_OBJECT(menu_item), "activate", (GtkSignalFunc) preview_preset_area_move_down_callback, widget);
}
- gtk_widget_show(menu);
+/* gtk_widget_show(menu); */
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event_button->button, event_button->time);
return TRUE; /* event is handled */
@@ -4959,9 +6013,9 @@ static gint preview_preset_area_context_menu_callback(GtkWidget *widget, GdkEven
/* ---------------------------------------------------------------------------------------------------------------------- */
-static void preview_preset_area_callback(GtkWidget *widget, gpointer call_data)
+static void preview_preset_area_callback(GtkWidget *widget, gpointer data)
{
- Preview *p = call_data;
+ Preview *p = data;
int selection;
DBG(DBG_proc, "preview_preset_area_callback\n");
@@ -4982,9 +6036,9 @@ static void preview_preset_area_callback(GtkWidget *widget, gpointer call_data)
/* ---------------------------------------------------------------------------------------------------------------------- */
-static void preview_rotation_callback(GtkWidget *widget, gpointer call_data)
+static void preview_rotation_callback(GtkWidget *widget, gpointer data)
{
- Preview *p = call_data;
+ Preview *p = data;
float rotated_surface[4];
int rot;
@@ -5070,8 +6124,84 @@ static void preview_rotation_callback(GtkWidget *widget, gpointer call_data)
p->rotation = rot;
- preview_update_selection(p); /* read selection from backend: correct rotation */
+ p->block_update_maximum_output_size_clipping = TRUE; /* necessary when in copy mode */
preview_update_surface(p, 2); /* rotate surfaces */
+ p->block_update_maximum_output_size_clipping = FALSE;
+ preview_update_selection(p); /* read selection from backend: correct rotation */
+ xsane_batch_scan_update_icon_list(); /* rotate batch scan icons */
+ preview_establish_ratio(p); /* make sure ratio is like selected - when selected */
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static void preview_establish_ratio(Preview *p)
+{
+ float width, height;
+
+ DBG(DBG_proc, "preview_establish_ratio\n");
+
+ if (p->ratio == 0.0)
+ {
+ return;
+ }
+
+ width = fabs(p->selection.coordinate[p->index_xmax] - p->selection.coordinate[p->index_xmin]);
+ height = fabs(p->selection.coordinate[p->index_ymax] - p->selection.coordinate[p->index_ymin]);
+
+ if ( (0.99 < width / p->ratio / height) && (width / p->ratio / height < 1.01) )
+ {
+ return;
+ }
+
+ if ( (0.99 < width * p->ratio / height) && (width * p->ratio / height < 1.01) )
+ {
+ width = height;
+
+ if (width > p->scanner_surface[p->index_xmax] - p->scanner_surface[p->index_xmin])
+ {
+ width = p->scanner_surface[p->index_xmax] - p->scanner_surface[p->index_xmin];
+ }
+ }
+
+ height = width / p->ratio;
+ if (height > p->scanner_surface[p->index_ymax] - p->scanner_surface[p->index_ymin])
+ {
+ height = p->scanner_surface[p->index_ymax] - p->scanner_surface[p->index_ymin];
+ width = height * p->ratio;
+ }
+
+ p->selection.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + width;
+ if (p->selection.coordinate[p->index_xmax] > p->scanner_surface[p->index_xmax])
+ {
+ p->selection.coordinate[p->index_xmax] = p->scanner_surface[p->index_xmax];
+ p->selection.coordinate[p->index_xmin] = p->selection.coordinate[p->index_xmax] - width;
+ }
+
+ p->selection.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + height;
+ if (p->selection.coordinate[p->index_ymax] > p->scanner_surface[p->index_ymax])
+ {
+ p->selection.coordinate[p->index_ymax] = p->scanner_surface[p->index_ymax];
+ p->selection.coordinate[p->index_ymin] = p->selection.coordinate[p->index_ymax] - height;
+ }
+
+ preview_draw_selection(p);
+ preview_establish_selection(p);
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+
+static void preview_ratio_callback(GtkWidget *widget, gpointer data)
+{
+ Preview *p = data;
+ float *ratio;
+
+ DBG(DBG_proc, "preview_ratio_callback\n");
+
+ ratio = (float *) gtk_object_get_data(GTK_OBJECT(widget), "Selection");
+
+ p->ratio = *ratio;
+
+ preview_establish_ratio(p);
}
/* ---------------------------------------------------------------------------------------------------------------------- */
@@ -5092,8 +6222,8 @@ void preview_do_gamma_correction(Preview *p)
{
int x,y;
int offset;
- u_char *image_data_enhp;
- guint16 *image_data_rawp;
+ u_char *image_data_enhp = NULL;
+ guint16 *image_data_rawp = NULL;
int rotate = 16 - preview_gamma_input_bits;
DBG(DBG_proc, "preview_do_gamma_correction\n");
@@ -5142,7 +6272,10 @@ void preview_do_gamma_correction(Preview *p)
for (x=0; x < p->image_width; x++)
{
- level = ((*image_data_rawp++) + (*image_data_rawp++) + (*image_data_rawp++)) / 3;
+ level = (*image_data_rawp++); /* red */
+ level += (*image_data_rawp++); /* green */
+ level += (*image_data_rawp++); /* blue */
+ level /= 3;
level >>= rotate;
*image_data_enhp++ = preview_gamma_data_red [level]; /* use 12 bit gamma table */
*image_data_enhp++ = preview_gamma_data_green[level];
@@ -5619,11 +6752,28 @@ gint preview_area_resize_handler(GtkWidget *widget, GdkEvent *event, gpointer da
}
/* ---------------------------------------------------------------------------------------------------------------------- */
-#if 0
+
void preview_update_maximum_output_size(Preview *p)
{
+ float xxx = 0.0;
+ float yyy = 0.0;
+ float dxmin = 0;
+ float dymin = 0;
+ float dxmax = 0;
+ float dymax = 0;
+
+ int paper_orientation = 0;
+
+ if (p->block_update_maximum_output_size_clipping)
+ {
+ DBG(DBG_info, "preview_update_maximum_output_size: blocked\n");
+ return;
+ }
+
DBG(DBG_proc, "preview_update_maximum_output_size\n");
+ p->block_update_maximum_output_size_clipping = TRUE;
+
if ( (p->maximum_output_width >= INF) || (p->maximum_output_height >= INF) )
{
if (p->selection_maximum.active)
@@ -5631,127 +6781,384 @@ void preview_update_maximum_output_size(Preview *p)
p->selection_maximum.active = FALSE;
}
}
- else
+ else /* we have a maximum output size definition */
{
p->previous_selection_maximum = p->selection_maximum;
-
p->selection_maximum.active = TRUE;
- p->selection_maximum.coordinate[0] = (p->selection.coordinate[0] + p->selection.coordinate[2] - p->maximum_output_width )/2.0;
- p->selection_maximum.coordinate[1] = (p->selection.coordinate[1] + p->selection.coordinate[3] - p->maximum_output_height)/2.0;
- p->selection_maximum.coordinate[2] = (p->selection.coordinate[0] + p->selection.coordinate[2] + p->maximum_output_width )/2.0;
- p->selection_maximum.coordinate[3] = (p->selection.coordinate[1] + p->selection.coordinate[3] + p->maximum_output_height)/2.0;
- if (p->selection_maximum.coordinate[0] < p->max_scanner_surface[0])
+ if (p->paper_orientation & 4) /* center? */
{
- p->selection_maximum.coordinate[0] = p->max_scanner_surface[0];
+ paper_orientation = p->paper_orientation;
}
-
- if (p->selection_maximum.coordinate[1] < p->max_scanner_surface[1])
+ else /* not in center */
{
- p->selection_maximum.coordinate[1] = p->max_scanner_surface[1];
- }
+ switch (p->rotation)
+ {
+ default:
+ case 0: /* 0 degree */
+ paper_orientation = p->paper_orientation & 3;
+ break;
- if (p->selection_maximum.coordinate[2] > p->max_scanner_surface[2])
- {
- p->selection_maximum.coordinate[2] = p->max_scanner_surface[2];
+ case 1: /* 90 degree */
+ paper_orientation = (1 - p->paper_orientation) & 3;
+ break;
+
+ case 2: /* 180 degree */
+ paper_orientation = (2 + p->paper_orientation) & 3;
+ break;
+
+ case 3: /* 270 degree */
+ paper_orientation = (3 - p->paper_orientation) & 3;
+ break;
+
+ case 4: /* 0 degree, x mirror */
+ paper_orientation = (1 - p->paper_orientation) & 3;
+ break;
+
+ case 5: /* 90 degree, x mirror */
+ paper_orientation = p->paper_orientation & 3;
+ break;
+
+ case 6: /* 180 degree, x mirror */
+ paper_orientation = (3 - p->paper_orientation) & 3;
+ break;
+
+ case 7: /* 270 degree, x mirror */
+ paper_orientation = (2 + p->paper_orientation) & 3;
+ break;
+ }
}
- if (p->selection_maximum.coordinate[3] > p->max_scanner_surface[3])
+ switch (paper_orientation)
{
- p->selection_maximum.coordinate[3] = p->max_scanner_surface[3];
+ default:
+ case 0: /* top left portrait */
+ case 8: /* top left landscape */
+ xxx = 0.0;
+ yyy = 0.0;
+ break;
+
+ case 1: /* top right portrait */
+ case 9: /* top right landscape */
+ xxx = 1.0;
+ yyy = 0.0;
+ break;
+
+ case 2: /* bottom right portrait */
+ case 10: /* bottom right landscape */
+ xxx = 1.0;
+ yyy = 1.0;
+ break;
+
+ case 3: /* bottom left portrait */
+ case 11: /* bottom left landscape */
+ xxx = 0.0;
+ yyy = 1.0;
+ break;
+
+ case 4: /* center portrait */
+ case 12: /* center landscape */
+ xxx = 0.5;
+ yyy = 0.5;
+ break;
}
- if ( (p->selection.coordinate[0] < p->selection_maximum.coordinate[0]) ||
- (p->selection.coordinate[1] < p->selection_maximum.coordinate[1]) ||
- (p->selection.coordinate[2] > p->selection_maximum.coordinate[2]) ||
- (p->selection.coordinate[3] > p->selection_maximum.coordinate[3]) )
+ p->selection_maximum.coordinate[p->index_xmin] = p->selection.coordinate[p->index_xmin] + xxx *(-p->selection.coordinate[p->index_xmin] + p->selection.coordinate[p->index_xmax]) - p->maximum_output_width * xxx - dxmin;
+ p->selection_maximum.coordinate[p->index_ymin] = p->selection.coordinate[p->index_ymin] + yyy *(-p->selection.coordinate[p->index_ymin] + p->selection.coordinate[p->index_ymax]) - p->maximum_output_height * yyy - dymin;
+ p->selection_maximum.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + xxx *(-p->selection.coordinate[p->index_xmin] + p->selection.coordinate[p->index_xmax]) + p->maximum_output_width * (1.0 - xxx) + dxmax;
+ p->selection_maximum.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + yyy *(-p->selection.coordinate[p->index_ymin] + p->selection.coordinate[p->index_ymax]) + p->maximum_output_height * (1.0 - yyy) + dymax;
+
+
+ if ( (p->selection.coordinate[p->index_xmin] < p->selection_maximum.coordinate[p->index_xmin]) ||
+ (p->selection.coordinate[p->index_ymin] < p->selection_maximum.coordinate[p->index_ymin]) ||
+ (p->selection.coordinate[p->index_xmax] > p->selection_maximum.coordinate[p->index_xmax]) ||
+ (p->selection.coordinate[p->index_ymax] > p->selection_maximum.coordinate[p->index_ymax]) )
{
- if (p->selection.coordinate[0] < p->selection_maximum.coordinate[0])
+ int selection_changed = FALSE;
+
+ if (p->selection.coordinate[p->index_xmin] < p->selection_maximum.coordinate[p->index_xmin])
{
- p->selection.coordinate[0] = p->selection_maximum.coordinate[0];
+ p->selection.coordinate[p->index_xmin] = p->selection_maximum.coordinate[p->index_xmin];
+ selection_changed = TRUE;
}
- if (p->selection.coordinate[1] < p->selection_maximum.coordinate[1])
+ if (p->selection.coordinate[p->index_ymin] < p->selection_maximum.coordinate[p->index_ymin])
{
- p->selection.coordinate[1] = p->selection_maximum.coordinate[1];
+ p->selection.coordinate[p->index_ymin] = p->selection_maximum.coordinate[p->index_ymin];
+ selection_changed = TRUE;
}
- if (p->selection.coordinate[2] > p->selection_maximum.coordinate[2])
+ if (p->selection.coordinate[p->index_xmax] > p->selection_maximum.coordinate[p->index_xmax])
{
- p->selection.coordinate[2] = p->selection_maximum.coordinate[2];
+ p->selection.coordinate[p->index_xmax] = p->selection_maximum.coordinate[p->index_xmax];
+ selection_changed = TRUE;
}
- if (p->selection.coordinate[3] > p->selection_maximum.coordinate[3])
+ if (p->selection.coordinate[p->index_ymax] > p->selection_maximum.coordinate[p->index_ymax])
{
- p->selection.coordinate[3] = p->selection_maximum.coordinate[3];
+ p->selection.coordinate[p->index_ymax] = p->selection_maximum.coordinate[p->index_ymax];
+ selection_changed = TRUE;
}
+
preview_draw_selection(p);
- preview_establish_selection(p);
+
+ if (selection_changed)
+ {
+ preview_establish_selection(p);
+ }
}
}
+
+ p->block_update_maximum_output_size_clipping=FALSE;
}
-#endif
+/* ---------------------------------------------------------------------------------------------------------------------- */
-void preview_update_maximum_output_size(Preview *p)
+void preview_set_maximum_output_size(Preview *p, float width, float height, int paper_orientation)
{
- if ( (p->maximum_output_width >= INF) || (p->maximum_output_height >= INF) )
+ /* witdh and height in device units */
+ DBG(DBG_proc, "preview_set_maximum_output_size\n");
+
+ p->maximum_output_width = width;
+ p->maximum_output_height = height;
+ p->paper_orientation = paper_orientation;
+
+ preview_update_maximum_output_size(p);
+ preview_draw_selection(p);
+}
+
+/* ---------------------------------------------------------------------------------------------------------------------- */
+#define AUTORAISE_ERROR 30
+void preview_autoraise_scanarea(Preview *p, int preview_x, int preview_y, float *autoselect_coord)
+{
+ int x, y;
+ int image_x, image_y;
+ int offset;
+ float average_color_r, average_color_g, average_color_b;
+ int count;
+ float error;
+ int top, bottom, left, right;
+ int top_ok, bottom_ok, left_ok, right_ok;
+ float xscale, yscale;
+
+ DBG(DBG_proc, "preview_autoraise_scanarea\n");
+
+ preview_transform_coordinate_window_to_image(p, preview_x, preview_y, &image_x, &image_y);
+
+ top_ok = FALSE;
+ bottom_ok = FALSE;
+ left_ok = FALSE;
+ right_ok = FALSE;
+
+ top = image_y - 5;
+ bottom = image_y + 5;
+ left = image_x - 5;
+ right = image_x + 5;
+
+
+ while (!(top_ok && bottom_ok && left_ok && right_ok))
{
- if (p->selection_maximum.active)
+ /* search top */
+ if (!top_ok)
{
- p->selection_maximum.active = FALSE;
+ top--;
}
- }
- else
- {
- p->previous_selection_maximum = p->selection_maximum;
- p->selection_maximum.active = TRUE;
- p->selection_maximum.coordinate[p->index_xmin] = p->selection.coordinate[p->index_xmin];
- p->selection_maximum.coordinate[p->index_ymin] = p->selection.coordinate[p->index_ymin];
- p->selection_maximum.coordinate[p->index_xmax] = p->selection.coordinate[p->index_xmin] + p->maximum_output_width;
- p->selection_maximum.coordinate[p->index_ymax] = p->selection.coordinate[p->index_ymin] + p->maximum_output_height;
+ top_ok = TRUE;
- if (p->selection_maximum.coordinate[p->index_xmax] > p->max_scanner_surface[p->index_xmax])
+ if (top <= 0)
{
- p->selection_maximum.coordinate[p->index_xmax] = p->max_scanner_surface[p->index_xmax];
+ top = 0;
+ }
+ else
+ {
+ average_color_r = average_color_g = average_color_b = 0;
+ count = 0;
+
+ for (x = left; x < right; x++)
+ {
+ offset = 3 * (top * p->image_width + x);
+ average_color_r += p->image_data_enh[offset + 0];
+ average_color_g += p->image_data_enh[offset + 1];
+ average_color_b += p->image_data_enh[offset + 2];
+ count++;
+ }
+
+ average_color_r /= count;
+ average_color_g /= count;
+ average_color_b /= count;
+
+ for (x = left; x < right; x++)
+ {
+ offset = 3 * (top * p->image_width + x);
+
+ error = fabs(p->image_data_enh[offset + 0] - average_color_r) +
+ fabs(p->image_data_enh[offset + 1] - average_color_g) +
+ fabs(p->image_data_enh[offset + 2] - average_color_b);
+
+ if (error > AUTORAISE_ERROR)
+ {
+ top_ok = FALSE;
+ break;
+ }
+ }
}
- if (p->selection_maximum.coordinate[p->index_ymax] > p->max_scanner_surface[p->index_ymax])
+ /* search bottom */
+ if (!bottom_ok)
{
- p->selection_maximum.coordinate[p->index_ymax] = p->max_scanner_surface[p->index_ymax];
+ bottom++;
}
- if ( (p->selection.coordinate[p->index_xmin] < p->selection_maximum.coordinate[p->index_xmin]) ||
- (p->selection.coordinate[p->index_ymin] < p->selection_maximum.coordinate[p->index_ymin]) ||
- (p->selection.coordinate[p->index_xmax] > p->selection_maximum.coordinate[p->index_xmax]) ||
- (p->selection.coordinate[p->index_ymax] > p->selection_maximum.coordinate[p->index_ymax]) )
+ bottom_ok = TRUE;
+
+ if (bottom >= p->image_height-1)
{
- if (p->selection.coordinate[p->index_xmax] > p->selection_maximum.coordinate[p->index_xmax])
+ bottom = p->image_height-1;
+ }
+ else
+ {
+ average_color_r = average_color_g = average_color_b = 0;
+ count = 0;
+
+ for (x = left; x < right; x++)
{
- p->selection.coordinate[p->index_xmax] = p->selection_maximum.coordinate[p->index_xmax];
+ offset = 3 * (bottom * p->image_width + x);
+ average_color_r += p->image_data_enh[offset + 0];
+ average_color_g += p->image_data_enh[offset + 1];
+ average_color_b += p->image_data_enh[offset + 2];
+ count++;
}
- if (p->selection.coordinate[p->index_ymax] > p->selection_maximum.coordinate[p->index_ymax])
+ average_color_r /= count;
+ average_color_g /= count;
+ average_color_b /= count;
+
+ for (x = left; x < right; x++)
{
- p->selection.coordinate[p->index_ymax] = p->selection_maximum.coordinate[p->index_ymax];
+ offset = 3 * (bottom * p->image_width + x);
+
+ error = fabs(p->image_data_enh[offset + 0] - average_color_r) +
+ fabs(p->image_data_enh[offset + 1] - average_color_g) +
+ fabs(p->image_data_enh[offset + 2] - average_color_b);
+
+ if (error > AUTORAISE_ERROR)
+ {
+ bottom_ok = FALSE;
+ break;
+ }
+ }
+ }
+
+ /* search left */
+ if (!left_ok)
+ {
+ left--;
+ }
+
+ left_ok = TRUE;
+
+ if (left <= 0)
+ {
+ left = 0;
+ }
+ else
+ {
+ average_color_r = average_color_g = average_color_b = 0;
+ count = 0;
+
+ for (y = top; y < bottom; y++)
+ {
+ offset = 3 * (left + y * p->image_width);
+ average_color_r += p->image_data_enh[offset + 0];
+ average_color_g += p->image_data_enh[offset + 1];
+ average_color_b += p->image_data_enh[offset + 2];
+ count++;
+ }
+
+ average_color_r /= count;
+ average_color_g /= count;
+ average_color_b /= count;
+
+ for (y = top; y < bottom; y++)
+ {
+ offset = 3 * (left + y * p->image_width);
+
+ error = fabs(p->image_data_enh[offset + 0] - average_color_r) +
+ fabs(p->image_data_enh[offset + 1] - average_color_g) +
+ fabs(p->image_data_enh[offset + 2] - average_color_b);
+
+ if (error > AUTORAISE_ERROR)
+ {
+ left_ok = FALSE;
+ break;
+ }
+ }
+ }
+
+ /* search right */
+ if (!right_ok)
+ {
+ right++;
+ }
+
+ right_ok = TRUE;
+
+ if (right >= p->image_width-1)
+ {
+ right = p->image_width-1;
+ }
+ else
+ {
+ average_color_r = average_color_g = average_color_b = 0;
+ count = 0;
+
+ for (y = top; y < bottom; y++)
+ {
+ offset = 3 * (right + y * p->image_width);
+ average_color_r += p->image_data_enh[offset + 0];
+ average_color_g += p->image_data_enh[offset + 1];
+ average_color_b += p->image_data_enh[offset + 2];
+ count++;
+ }
+
+ average_color_r /= count;
+ average_color_g /= count;
+ average_color_b /= count;
+
+ for (y = top; y < bottom; y++)
+ {
+ offset = 3 * (right + y * p->image_width);
+
+ error = fabs(p->image_data_enh[offset + 0] - average_color_r) +
+ fabs(p->image_data_enh[offset + 1] - average_color_g) +
+ fabs(p->image_data_enh[offset + 2] - average_color_b);
+
+ if (error > AUTORAISE_ERROR)
+ {
+ right_ok = FALSE;
+ break;
+ }
}
- preview_draw_selection(p);
- preview_establish_selection(p);
}
}
-}
-/* ---------------------------------------------------------------------------------------------------------------------- */
-void preview_set_maximum_output_size(Preview *p, float width, float height)
-{
- /* witdh and height in device units */
- DBG(DBG_proc, "preview_set_maximum_output_size\n");
- p->maximum_output_width = width;
- p->maximum_output_height = height;
+ preview_get_scale_device_to_image(p, &xscale, &yscale);
- preview_update_maximum_output_size(p);
- preview_draw_selection(p);
+ if (((p->rotation & 3) == 0) || ((p->rotation & 3) == 2)) /* 0 or 180 degree */
+ {
+ *(autoselect_coord+0) = p->image_surface[0] + left / xscale;
+ *(autoselect_coord+2) = p->image_surface[0] + right / xscale;
+ *(autoselect_coord+1) = p->image_surface[1] + top / yscale;
+ *(autoselect_coord+3) = p->image_surface[1] + bottom / yscale;
+ }
+ else /* 90 or 270 degree */
+ {
+ *(autoselect_coord+1) = p->image_surface[1] + left / xscale;
+ *(autoselect_coord+3) = p->image_surface[1] + right / xscale;
+ *(autoselect_coord+0) = p->image_surface[0] + top / yscale;
+ *(autoselect_coord+2) = p->image_surface[0] + bottom / yscale;
+ }
}
/* ---------------------------------------------------------------------------------------------------------------------- */
@@ -5932,6 +7339,15 @@ void preview_autoselect_scanarea(Preview *p, float *autoselect_coord)
}
}
+ if ( (top >= bottom) || (right <= left) ) /* empty selection: use complete image */
+ {
+ DBG(DBG_info, "autoselect_scanarea: empty selection: using complete area\n");
+ top = 0;
+ bottom = p->image_height -1;
+ left = 0;
+ right = p->image_width -1;
+ }
+
preview_get_scale_device_to_image(p, &xscale, &yscale);
if (((p->rotation & 3) == 0) || ((p->rotation & 3) == 2)) /* 0 or 180 degree */