diff options
Diffstat (limited to 'src/xsane-preview.c')
| -rw-r--r-- | src/xsane-preview.c | 5997 |
1 files changed, 5997 insertions, 0 deletions
diff --git a/src/xsane-preview.c b/src/xsane-preview.c new file mode 100644 index 0000000..da81e3f --- /dev/null +++ b/src/xsane-preview.c @@ -0,0 +1,5997 @@ +/* xsane -- a graphical (X11, gtk) scanner-oriented SANE frontend + + xsane-preview.c + + Oliver Rauch <Oliver.Rauch@rauch-domain.de> + Copyright (C) 1998-2002 Oliver Rauch + This file is part of the XSANE package. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +/* + + The preview strategy is as follows: + ----------------------------------- + + 1) The preview is done on the full scan area or a part of it. + + 2) The preview is zoomable so the user can precisely pick + the selection area even for small scans on a large scan + surface. + + 3) The preview window is resizeable. + + 4) The preview scan resolution depends on preview window size + and the selected preview surface (zoom area). + + 5) We let the user/backend pick whether a preview is in color, + grayscale, lineart or what not. The only options that the + preview may (temporarily) modify are: + + - resolution (set so the preview fills the window) + - scan area options (top-left corner, bottom-right corner) + - preview option (to let the backend know we're doing a preview) + - gamma table is set to default (gamma=1.0) + + 5) The initial size of the scan surface is determined based on the constraints + of the four corner coordinates. Missing constraints are replaced + by 0/+INF as appropriate (0 for top-left, +INF for bottom-right coords). + + 6) Given the preview window size and the scan surface size, we + select the resolution so the acquired preview image just fits + in the preview window. The resulting resolution may be out + of range in which case we pick the minum/maximum if there is + a range or word-list constraint or a default value if there is + no such constraint. + + 7) Once a preview image has been acquired, we know the size of the + preview image (in pixels). An initial scale factor is chosen + so the image fits into the preview window. + + 8) Surface definitions: + device = surface of the scanner + image = same oriantation like device + preview = rotated (0/90/180/270 degree) device surface + window = same oriantation like device, may be different scaling + +*/ + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +#include "xsane.h" +/* #include <sys/param.h> */ +#include "xsane-back-gtk.h" +#include "xsane-front-gtk.h" +#include "xsane-preview.h" +#include "xsane-preferences.h" +#include "xsane-gamma.h" +#include <gdk/gdkkeysyms.h> + + +#ifndef PATH_MAX +# define PATH_MAX 1024 +#endif + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +/* Cut fp conversion routines some slack: */ +#define GROSSLY_DIFFERENT(f1,f2) (fabs ((f1) - (f2)) > 1e-3) +#define GROSSLY_EQUAL(f1,f2) (fabs ((f1) - (f2)) < 1e-3) + +#ifdef __alpha__ + /* This seems to be necessary for at least some XFree86 3.1.2 + servers. It's known to be necessary for the XF86_TGA server for + Linux/Alpha. Fortunately, it's no great loss so we turn this on + by default for now. */ +# define XSERVER_WITH_BUGGY_VISUALS +#endif + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static u_char *preview_gamma_data_red = 0; +static u_char *preview_gamma_data_green = 0; +static u_char *preview_gamma_data_blue = 0; + +static u_char *histogram_gamma_data_red = 0; +static u_char *histogram_gamma_data_green = 0; +static u_char *histogram_gamma_data_blue = 0; + +/* histogram_medium_gamma_data_* is used when medium correction is done after preview-scan by xsane */ +static u_char *histogram_medium_gamma_data_red = 0; +static u_char *histogram_medium_gamma_data_green = 0; +static u_char *histogram_medium_gamma_data_blue = 0; + +static int preview_gamma_input_bits; + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +/* forward declarations */ +static void preview_rotate_devicesurface_to_previewsurface(int rotation, float dsurface[4], float *psurface); +static void preview_rotate_previewsurface_to_devicesurface(int rotation, float psurface[4], float *dsurface); +static void preview_transform_coordinates_device_to_window(Preview *p, float dcoordinate[4], float *win_coord); +static void preview_transform_coordinate_window_to_device(Preview *p, float winx, float winy, float *previewx, float *previewy); +static void preview_transform_coordinate_window_to_image(Preview *p, int winx, int winy, int *imagex, int *imagey); +static void preview_order_selection(Preview *p); +static void preview_bound_selection(Preview *p); +static void preview_draw_rect(Preview *p, GdkWindow *win, GdkGC *gc, float coord[4]); +static void preview_draw_selection(Preview *p); +static void preview_update_selection(Preview *p); +static void preview_establish_selection(Preview *p); +/* static void preview_update_batch_selection(Preview *p); */ +static void preview_get_scale_device_to_image(Preview *p, float *xscalep, float *yscalep); +static void preview_get_scale_device_to_window(Preview *p, float *xscalep, float *yscalep); +static void preview_get_scale_window_to_image(Preview *p, float *xscalep, float *yscalep); +static void preview_paint_image(Preview *p); +static void preview_display_partial_image(Preview *p); +static void preview_display_maybe(Preview *p); +static void preview_display_image(Preview *p); +static void preview_save_option(Preview *p, int option, void *save_loc, int *valid); +static void preview_restore_option(Preview *p, int option, void *saved_value, int valid); +static void preview_set_option(Preview *p, int option, void *value); +static void preview_set_option_float(Preview *p, int option, float value); +static void preview_set_option_val(Preview *p, int option, SANE_Int value); +static int preview_increment_image_y(Preview *p); +static void preview_read_image_data(gpointer data, gint source, GdkInputCondition cond); +static void preview_scan_done(Preview *p, int save_image); +static void preview_scan_start(Preview *p); +static int preview_make_image_path(Preview *p, size_t filename_size, char *filename, int level); +static void preview_restore_image(Preview *p); +static gint preview_expose_event_handler_start(GtkWidget *window, GdkEvent *event, gpointer data); +static gint preview_expose_event_handler_end(GtkWidget *window, GdkEvent *event, gpointer data); +static gint preview_hold_event_handler(gpointer data); +static gint preview_motion_event_handler(GtkWidget *window, GdkEvent *event, gpointer data); +static gint preview_button_press_event_handler(GtkWidget *window, GdkEvent *event, gpointer data); +static gint preview_button_release_event_handler(GtkWidget *window, GdkEvent *event, gpointer data); +static void preview_start_button_clicked(GtkWidget *widget, gpointer data); +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_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_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_pipette_white(GtkWidget *window, gpointer data); +static void preview_pipette_gray(GtkWidget *window, gpointer data); +static void preview_pipette_black(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); +static gint preview_preset_area_rename_callback(GtkWidget *widget, GtkWidget *preset_area_widget); +static gint preview_preset_area_add_callback(GtkWidget *widget, GtkWidget *preset_area_widget); +static gint preview_preset_area_delete_callback(GtkWidget *widget, GtkWidget *preset_area_widget); +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_autoselect_scanarea_callback(GtkWidget *window, gpointer data); + +void preview_do_gamma_correction(Preview *p); +void preview_calculate_raw_histogram(Preview *p, SANE_Int *count_raw, SANE_Int *count_raw_red, SANE_Int *count_raw_green, SANE_Int *count_raw_blue); +void preview_calculate_enh_histogram(Preview *p, SANE_Int *count, SANE_Int *count_red, SANE_Int *count_green, SANE_Int *count_blue); +void preview_gamma_correction(Preview *p, int gamma_input_bits, + u_char *gamma_red, u_char *gamma_green, u_char *gamma_blue, + u_char *gamma_red_hist, u_char *gamma_green_hist, u_char *gamma_blue_hist, + u_char *medium_gamma_red_hist, u_char *medium_gamma_green_hist, u_char *medium_gamma_blue_hist); +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_autoselect_scanarea(Preview *p, float *autoselect_coord); +void preview_display_valid(Preview *p); + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_rotate_devicesurface_to_previewsurface(int rotation, float dsurface[4], float *psurface) +{ + DBG(DBG_proc, "preview_rotate_devicesurface_to_previewsurface(rotation = %d)\n", rotation); + + switch (rotation & 3) + { + case 0: /* 0 degree */ + default: + *(psurface+0) = dsurface[0]; + *(psurface+1) = dsurface[1]; + *(psurface+2) = dsurface[2]; + *(psurface+3) = dsurface[3]; + break; + + case 1: /* 90 degree */ + *(psurface+0) = dsurface[3]; + *(psurface+1) = dsurface[0]; + *(psurface+2) = dsurface[1]; + *(psurface+3) = dsurface[2]; + break; + + case 2: /* 180 degree */ + *(psurface+0) = dsurface[2]; + *(psurface+1) = dsurface[3]; + *(psurface+2) = dsurface[0]; + *(psurface+3) = dsurface[1]; + break; + + case 3: /* 270 degree */ + *(psurface+0) = dsurface[1]; + *(psurface+1) = dsurface[2]; + *(psurface+2) = dsurface[3]; + *(psurface+3) = dsurface[0]; + break; + } + + if (rotation & 4) /* mirror in x direction */ + { + float help=*(psurface+0); + + *(psurface+0) = *(psurface+2); + *(psurface+2) = help; + } + + DBG(DBG_info, "device[%3.2f %3.2f %3.2f %3.2f] -> preview[%3.2f %3.2f %3.2f %3.2f]\n", + dsurface[0], dsurface[1], dsurface[2], dsurface[3], + *(psurface+0), *(psurface+1), *(psurface+2), *(psurface+3)); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_rotate_previewsurface_to_devicesurface(int rotation, float psurface[4], float *dsurface) +{ + DBG(DBG_proc, "preview_rotate_previewsurface_to_devicesurface(rotation = %d)\n", rotation); + + switch (rotation) + { + case 0: /* 0 degree */ + default: + *(dsurface+0) = psurface[0]; + *(dsurface+1) = psurface[1]; + *(dsurface+2) = psurface[2]; + *(dsurface+3) = psurface[3]; + break; + + case 1: /* 90 degree */ + *(dsurface+0) = psurface[1]; + *(dsurface+1) = psurface[2]; + *(dsurface+2) = psurface[3]; + *(dsurface+3) = psurface[0]; + break; + + case 2: /* 180 degree */ + *(dsurface+0) = psurface[2]; + *(dsurface+1) = psurface[3]; + *(dsurface+2) = psurface[0]; + *(dsurface+3) = psurface[1]; + break; + + case 3: /* 270 degree */ + *(dsurface+0) = psurface[3]; + *(dsurface+1) = psurface[0]; + *(dsurface+2) = psurface[1]; + *(dsurface+3) = psurface[2]; + break; + + case 4: /* 0 degree, x mirror */ + *(dsurface+0) = psurface[2]; + *(dsurface+1) = psurface[1]; + *(dsurface+2) = psurface[0]; + *(dsurface+3) = psurface[3]; + break; + + case 5: /* 90 degree, x mirror */ + *(dsurface+0) = psurface[1]; + *(dsurface+1) = psurface[0]; + *(dsurface+2) = psurface[3]; + *(dsurface+3) = psurface[2]; + break; + + case 6: /* 180 degree, x mirror */ + *(dsurface+0) = psurface[0]; + *(dsurface+1) = psurface[3]; + *(dsurface+2) = psurface[2]; + *(dsurface+3) = psurface[1]; + break; + + case 7: /* 270 degree, x mirror */ + *(dsurface+0) = psurface[3]; + *(dsurface+1) = psurface[2]; + *(dsurface+2) = psurface[1]; + *(dsurface+3) = psurface[0]; + break; + } + + DBG(DBG_info, "preview[%3.2f %3.2f %3.2f %3.2f] -> device[%3.2f %3.2f %3.2f %3.2f]\n", + psurface[0], psurface[1], psurface[2], psurface[3], + *(dsurface+0), *(dsurface+1), *(dsurface+2), *(dsurface+3)); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_transform_coordinates_device_to_window(Preview *p, float preview_coord[4], float *win_coord) +{ + float minx, maxx, miny, maxy; + float xscale, yscale; + + DBG(DBG_proc, "preview_transform_coordinates_device_to_window\n"); + + preview_get_scale_device_to_window(p, &xscale, &yscale); + + minx = preview_coord[0]; + miny = preview_coord[1]; + maxx = preview_coord[2]; + maxy = preview_coord[3]; + + if (minx > maxx) + { + float val = minx; + minx = maxx; + maxx = val; + } + + if (miny > maxy) + { + float val = miny; + miny = maxy; + maxy = val; + } + + switch (p->rotation) + { + case 0: /* 0 degree */ + default: + *(win_coord+0) = xscale * (minx - p->surface[0]); + *(win_coord+1) = yscale * (miny - p->surface[1]); + *(win_coord+2) = xscale * (maxx - p->surface[0]); + *(win_coord+3) = yscale * (maxy - p->surface[1]); + break; + + case 1: /* 90 degree */ + *(win_coord+0) = xscale * (p->surface[0] - maxx); + *(win_coord+1) = yscale * (miny - p->surface[1]); + *(win_coord+2) = xscale * (p->surface[0] - minx); + *(win_coord+3) = yscale * (maxy - p->surface[1]); + break; + + case 2: /* 180 degree */ + *(win_coord+0) = xscale * (p->surface[0] - maxx); + *(win_coord+1) = yscale * (p->surface[1] - maxy); + *(win_coord+2) = xscale * (p->surface[0] - minx); + *(win_coord+3) = yscale * (p->surface[1] - miny); + break; + + case 3: /* 270 degree */ + *(win_coord+0) = xscale * (minx - p->surface[0]); + *(win_coord+1) = yscale * (p->surface[1] - maxy); + *(win_coord+2) = xscale * (maxx - p->surface[0]); + *(win_coord+3) = yscale * (p->surface[1] - miny); + break; + + case 4: /* 0 degree, x mirror */ + *(win_coord+0) = xscale * (p->surface[0] - maxx); + *(win_coord+1) = yscale * (miny - p->surface[1]); + *(win_coord+2) = xscale * (p->surface[0] - minx); + *(win_coord+3) = yscale * (maxy - p->surface[1]); + break; + + case 5: /* 90 degree, x mirror */ + *(win_coord+0) = xscale * (minx - p->surface[0]); + *(win_coord+1) = yscale * (miny - p->surface[1]); + *(win_coord+2) = xscale * (maxx - p->surface[0]); + *(win_coord+3) = yscale * (maxy - p->surface[1]); + break; + + case 6: /* 180 degree, x mirror */ + *(win_coord+0) = xscale * (minx - p->surface[0]); + *(win_coord+1) = yscale * (p->surface[1] - maxy); + *(win_coord+2) = xscale * (maxx - p->surface[0]); + *(win_coord+3) = yscale * (p->surface[1] - miny); + break; + + case 7: /* 270 degree, x mirror */ + *(win_coord+0) = xscale * (p->surface[0] - maxx); + *(win_coord+1) = yscale * (p->surface[1] - maxy); + *(win_coord+2) = xscale * (p->surface[0] - minx); + *(win_coord+3) = yscale * (p->surface[1] - miny); + break; + } + + DBG(DBG_info, "preview[%3.2f %3.2f %3.2f %3.2f] -> window[%3.2f %3.2f %3.2f %3.2f]\n", + preview_coord[0], preview_coord[1], preview_coord[2], preview_coord[3], + *(win_coord+0), *(win_coord+1), *(win_coord+2), *(win_coord+3) ); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_transform_coordinate_window_to_device(Preview *p, float winx, float winy, float *devicex, float *devicey) +{ + float xscale, yscale; + + DBG(DBG_proc, "preview_transform_coordinate_window_to_device\n"); + + preview_get_scale_device_to_window(p, &xscale, &yscale); + + switch (p->rotation) + { + case 0: /* 0 degree */ + default: + *devicex = p->surface[0] + winx / xscale; + *devicey = p->surface[1] + winy / yscale; + break; + + case 1: /* 90 degree */ + *devicex = p->surface[0] - winx / xscale; + *devicey = p->surface[1] + winy / yscale; + break; + + case 2: /* 180 degree */ + *devicex = p->surface[0] - winx / xscale; + *devicey = p->surface[1] - winy / yscale; + break; + + case 3: /* 270 degree */ + *devicex = p->surface[0] + winx / xscale; + *devicey = p->surface[1] - winy / yscale; + break; + + case 4: /* 0 degree, x mirror */ + *devicex = p->surface[0] - winx / xscale; + *devicey = p->surface[1] + winy / yscale; + break; + + case 5: /* 90 degree, x mirror */ + *devicex = p->surface[0] + winx / xscale; + *devicey = p->surface[1] + winy / yscale; + break; + + case 6: /* 180 degree, x mirror */ + *devicex = p->surface[0] + winx / xscale; + *devicey = p->surface[1] - winy / yscale; + break; + + case 7: /* 270 degree, x mirror */ + *devicex = p->surface[0] - winx / xscale; + *devicey = p->surface[1] - winy / yscale; + break; + } + + DBG(DBG_info, "window[%3.2f %3.2f] -> device[%3.2f %3.2f]\n", winx, winy, *devicex, *devicey); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_transform_coordinate_window_to_image(Preview *p, int winx, int winy, int *imagex, int *imagey) +{ + float xscale, yscale; + + DBG(DBG_proc, "preview_transform_coordinate_window_to_image\n"); + + preview_get_scale_window_to_image(p, &xscale, &yscale); + + switch (p->rotation) + { + case 0: /* 0 degree */ + default: + *imagex = winx * xscale; + *imagey = winy * yscale; + break; + + case 1: /* 90 degree */ + *imagex = winy * yscale; + *imagey = p->image_height - winx * xscale; + break; + + case 2: /* 180 degree */ + *imagex = p->image_width - winx * xscale; + *imagey = p->image_height - winy * yscale; + break; + + case 3: /* 270 degree */ + *imagex = p->image_width - winy * yscale; + *imagey = winx * xscale; + break; + + case 4: /* 0 degree, x mirror */ + *imagex = p->image_width - winx * xscale; + *imagey = winy * yscale; + break; + + case 5: /* 90 degree, x mirror */ + *imagex = winy * yscale; + *imagey = winx * xscale; + break; + + case 6: /* 180 degree, x mirror */ + *imagex = winx * xscale; + *imagey = p->image_height - winy * yscale; + break; + + case 7: /* 270 degree, x mirror */ + *imagex = p->image_width - winy * yscale; + *imagey = p->image_height - winx * xscale; + break; + } + + DBG(DBG_info, "window[%d %d] -> image[%d %d]\n", winx, winy, *imagex, *imagey); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_order_selection(Preview *p) +{ + float tmp_coordinate; + + DBG(DBG_proc, "preview_order_selection\n"); + + p->selection.active = ( (p->selection.coordinate[0] != p->selection.coordinate[2]) && + (p->selection.coordinate[1] != p->selection.coordinate[3]) ); + + + if (p->selection.active) + { + + if (p->selection.coordinate[p->index_xmin] > p->selection.coordinate[p->index_xmax]) + { + tmp_coordinate = p->selection.coordinate[p->index_xmin]; + p->selection.coordinate[p->index_xmin] = p->selection.coordinate[p->index_xmax]; + p->selection.coordinate[p->index_xmax] = tmp_coordinate; + + p->selection_xedge = (p->selection_xedge + 2) & 3; + } + + if (p->selection.coordinate[p->index_ymin] > p->selection.coordinate[p->index_ymax]) + { + tmp_coordinate = p->selection.coordinate[p->index_ymin]; + p->selection.coordinate[p->index_ymin] = p->selection.coordinate[p->index_ymax]; + p->selection.coordinate[p->index_ymax] = tmp_coordinate; + + p->selection_yedge = (p->selection_yedge + 2) & 3; + } + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_bound_selection(Preview *p) +{ + DBG(DBG_proc, "preview_bound_selection\n"); + + p->selection.active = ( (p->selection.coordinate[0] != p->selection.coordinate[2]) && + (p->selection.coordinate[1] != p->selection.coordinate[3]) ); + + + if (p->selection.active) + { +#if 0 + 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 + 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]); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_draw_rect(Preview *p, GdkWindow *win, GdkGC *gc, float preview_coord[4]) +{ + float win_coord[4]; + + DBG(DBG_proc, "preview_draw_rect [%3.2f %3.2f %3.2f %3.2f]\n", preview_coord[0], preview_coord[1], preview_coord[2], preview_coord[3]); + + preview_transform_coordinates_device_to_window(p, preview_coord, win_coord); + gdk_draw_rectangle(win, gc, FALSE, win_coord[0], win_coord[1], win_coord[2]-win_coord[0] + 1, win_coord[3] - win_coord[1] + 1); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_draw_selection(Preview *p) +{ + DBG(DBG_proc, "preview_draw_selection\n"); + + if (!p->gc_selection) /* window isn't mapped yet */ + { + return; + } + + if ( (p->show_selection == FALSE) || (p->calibration) ) + { + return; + } + + if (p->previous_selection.active) + { + preview_draw_rect(p, p->window->window, p->gc_selection, p->previous_selection.coordinate); + } + + if (p->selection.active) + { + preview_draw_rect(p, p->window->window, p->gc_selection, p->selection.coordinate); + } + + p->previous_selection = p->selection; + + + if (!p->gc_selection_maximum) /* window isn't mapped yet */ + { + return; + } + + if (p->previous_selection_maximum.active) + { + preview_draw_rect(p, p->window->window, p->gc_selection_maximum, p->previous_selection_maximum.coordinate); + } + + if (p->selection_maximum.active) + { + preview_draw_rect(p, p->window->window, p->gc_selection_maximum, p->selection_maximum.coordinate); + } + + p->previous_selection_maximum = p->selection_maximum; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_update_selection(Preview *p) +/* draw selection box as defined in backend */ +{ + const SANE_Option_Descriptor *opt; + SANE_Status status; + SANE_Word val; + int i, optnum; + float coord[4]; + + DBG(DBG_proc, "preview_update_selection\n"); + + p->previous_selection = p->selection; + + for (i = 0; i < 4; ++i) + { + optnum = xsane.well_known.coord[i]; + if (optnum > 0) + { + opt = xsane_get_option_descriptor(xsane.dev, optnum); + status = xsane_control_option(xsane.dev, optnum, SANE_ACTION_GET_VALUE, &val, 0); + if (status != SANE_STATUS_GOOD) + { + continue; + } + if (opt->type == SANE_TYPE_FIXED) + { + coord[i] = SANE_UNFIX(val); + } + else + { + coord[i] = val; + } + } + else /* backend does not use scanarea options */ + { + switch (i) + { + case 0: + case 1: + coord[i] = 0; + break; + + case 2: + coord[i] = p->preview_width; + break; + + case 3: + coord[i] = p->preview_height; + break; + } + } + } + + preview_rotate_devicesurface_to_previewsurface(p->rotation, coord, p->selection.coordinate); + + p->selection.active = ( (p->selection.coordinate[0] != p->selection.coordinate[2]) && + (p->selection.coordinate[1] != p->selection.coordinate[3])); + + preview_update_maximum_output_size(p); + preview_draw_selection(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_establish_selection(Preview *p) +{ + /* This routine only shall be called if the preview area really is changed. */ + int i; + float coord[4]; + + DBG(DBG_proc, "preview_establish_selection\n"); + + preview_order_selection(p); + + xsane.block_update_param = TRUE; /* do not change parameters each time */ + + preview_rotate_previewsurface_to_devicesurface(p->rotation, p->selection.coordinate, coord); + + for (i = 0; i < 4; ++i) + { + preview_set_option_float(p, xsane.well_known.coord[i], coord[i]); + } + + xsane_back_gtk_update_scan_window(); + + xsane.block_update_param = FALSE; + + xsane_update_param(0); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +#if 0 +static void preview_update_batch_selection(Preview *p) +{ + Batch_selection *batch_selection; + + DBG(DBG_proc, "preview_update_batch_selection\n"); + + if (!p->gc_selection) /* window isn't mapped yet */ + { + return; + } + + batch_selection = p->batch_selection; + + while (batch_selection) + { + preview_draw_rect(p, p->window->window, p->gc_selection, batch_selection->coordinate); + + batch_selection = batch_selection->next; + } +} +#endif + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_get_scale_device_to_image(Preview *p, float *xscalep, float *yscalep) +{ + float device_width, device_height; + float xscale = 1.0; + float yscale = 1.0; + + device_width = fabs(p->image_surface[2] - p->image_surface[0]); + device_height = fabs(p->image_surface[3] - p->image_surface[1]); + + if ( ((p->rotation & 3) == 0) || ((p->rotation & 3) == 2) ) /* 0 or 180 degree */ + { + if ( (device_width >0) && (device_width < INF) ) + { + xscale = p->image_width / device_width; + } + + if ( (device_height >0) && (device_height < INF) ) + { + yscale = p->image_height / device_height; + } + } + else /* 90 or 270 degree */ + { + if ( (device_width >0) && (device_width < INF) ) + { + xscale = p->image_height / device_width; + } + + if ( (device_height >0) && (device_height < INF) ) + { + yscale = p->image_width / device_height; + } + } + +#if 1 + if (xscale > yscale) + { + yscale = xscale; + } + else + { + xscale = yscale; + } +#endif + + *xscalep = xscale; + *yscalep = yscale; + + DBG(DBG_info, "preview_get_scale_device_to_image: scale = %f, %f\n", xscale, yscale); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_get_scale_device_to_window(Preview *p, float *xscalep, float *yscalep) +{ + float device_width, device_height; + float xscale = 1.0; + float yscale = 1.0; + + /* device_* in device coords */ + device_width = fabs(p->image_surface[2] - p->image_surface[0]); + device_height = fabs(p->image_surface[3] - p->image_surface[1]); + + if ( (device_width >0) && (device_width < INF) ) + { + xscale = p->preview_width / device_width; /* preview width is in window coords */ + } + + if ( (device_height >0) && (device_height < INF) ) + { + yscale = p->preview_height / device_height; /* preview height is in window coords */ + } + + /* make sure pixels have square dimension */ + if (xscale > yscale) + { + yscale = xscale; + } + else + { + xscale = yscale; + } + + *xscalep = xscale; + *yscalep = yscale; + + DBG(DBG_info, "preview_get_scale_device_to_window: scale = %f, %f\n", xscale, yscale); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_get_scale_window_to_image(Preview *p, float *xscalep, float *yscalep) +{ + float xscale = 1.0; + float yscale = 1.0; + + switch (p->rotation & 3) + { + case 0: /* do not rotate - 0 degree */ + case 2: /* rotate 180 degree */ + default: + if (p->image_width > 0) + { + xscale = p->image_width / (float) p->preview_width; + } + + if (p->image_height > 0) + { + yscale = p->image_height / (float) p->preview_height; + } + break; + + case 1: /* rotate 90 degree */ + case 3: /* rotate 270 degree */ + if (p->image_height > 0) + { + xscale = p->image_height / (float) p->preview_width; + } + + if (p->image_width > 0) + { + yscale = p->image_width / (float) p->preview_height; + } + break; + + } + + /* make sure pixels have square dimension */ + if (xscale > yscale) + { + yscale = xscale; + } + else + { + xscale = yscale; + } + + *xscalep = xscale; + *yscalep = yscale; + + DBG(DBG_info, "preview_get_scale_window_to_image: scale = %f, %f\n", xscale, yscale); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_paint_image(Preview *p) +{ + float xscale, yscale, src_x, src_y; + int dst_x, dst_y, height, x, y, old_y, src_offset, x_direction; + int rotation; + + DBG(DBG_proc, "preview_paint_image (rotation=%d)\n", p->rotation); + + if (!p->image_data_enh) + { + return; /* no image data */ + } + + memset(p->preview_row, 0x80, 3 * p->preview_window_width); + + old_y = -1; + height = 0; + + rotation = p->rotation; + if (p->calibration) /* do not rotate calibration image */ + { + p->rotation = 0; + xscale=1.0; + yscale=1.0; + } + else + { + preview_get_scale_window_to_image(p, &xscale, &yscale); + } + + + switch (p->rotation & 3) + { + case 0: /* do not rotate - 0 degree */ + default: + + /* don't draw last line unless it's complete: */ + height = p->image_y; /* last line */ + + if (p->image_x == 0 && height < p->image_height) + { + ++height; /* use last line if it is complete */ + } + + src_y = 0.0; /* Source Y position index */ + + DBG(DBG_info, "preview_height=%d\n", p->preview_height); + + for (dst_y = 0; dst_y < p->preview_height; ++dst_y) + { + y = (int) (src_y + 0.5); + if (y >= height) + { + break; + } + + if (p->rotation & 4) /* mirror in x direction */ + { + src_offset = (y+1) * 3 * p->image_width - 3; + x_direction = -1; + } + else /* not mirrored */ + { + src_offset = y * 3 * p->image_width; + x_direction = 1; + } + + if (old_y != y) /* create new line ? - not necessary if the same line is used several times */ + { + old_y = y; + src_x = 0.0; /* Source X position index */ + + for (dst_x = 0; dst_x < p->preview_width; ++dst_x) + { + x = (int) (src_x + 0.5); + if (x >= p->image_width) + { + break; + } + + p->preview_row[3*dst_x + 0] = p->image_data_enh[src_offset + x_direction * 3 * x + 0]; /* R */ + p->preview_row[3*dst_x + 1] = p->image_data_enh[src_offset + x_direction * 3 * x + 1]; /* G */ + p->preview_row[3*dst_x + 2] = p->image_data_enh[src_offset + x_direction * 3 * x + 2]; /* B */ + src_x += xscale; /* calculate new source x position index */ + } + } + + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + src_y += yscale; /* calculate new source y position index */ + } + + memset(p->preview_row, 0x80, 3*p->preview_window_width); + for (; dst_y < p->preview_window_height; ++dst_y) + { + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + } + break; + + + case 1: /* 90 degree */ + /* because we run in x direction we have to draw all rows all the time */ + + src_y = 0.0; + + DBG(DBG_info, "height=%d\n", height); + DBG(DBG_info, "preview_height=%d\n", p->preview_height); + + for (dst_y = 0; dst_y < p->preview_height; ++dst_y) + { + y = (int) (src_y + 0.5); + if (y >= p->image_width) + { + break; + } + + if (p->rotation & 4) /* mirror in x direction */ + { + src_offset = y * 3 + 3 * p->image_width * (p->image_height-1); + x_direction = -1; + } + else /* not mirrored */ + { + src_offset = y * 3; + x_direction = 1; + } + + if (old_y != y) /* create new line ? - not necessary if the same line is used several times */ + { + old_y = y; + src_x = p->image_height - 1; + + for (dst_x = 0; dst_x < p->preview_width; ++dst_x) + { + x = (int) (src_x + 0.5); + if (x < 0) + { + break; + } + + p->preview_row[3*dst_x + 0] = p->image_data_enh[src_offset + x_direction * 3 * x * p->image_width + 0]; /* R */ + p->preview_row[3*dst_x + 1] = p->image_data_enh[src_offset + x_direction * 3 * x * p->image_width + 1]; /* G */ + p->preview_row[3*dst_x + 2] = p->image_data_enh[src_offset + x_direction * 3 * x * p->image_width + 2]; /* B */ + src_x -= xscale; + } + } + + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + src_y += yscale; + } + + memset(p->preview_row, 0x80, 3*p->preview_window_width); + for (; dst_y < p->preview_window_height; ++dst_y) + { + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + } + break; + + + case 2: /* 180 degree */ + + /* don't draw last line unless it's complete: */ + height = p->image_y; /* last line */ + + if ( (p->image_x == 0) && (height < p->image_height) ) + { + ++height; /* use last line if it is complete */ + } + + src_y = 0; /* Source Y position index */ + + DBG(DBG_info, "height=%d\n", height); + DBG(DBG_info, "preview_height=%d\n", p->preview_height); + + /* it looks like it is necessary to write row 0 at first */ + memset(p->preview_row, 0x80, 3*p->preview_window_width); + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, 0, p->preview_window_width); + for (dst_y = p->preview_height-1; dst_y >=0; --dst_y) + { + y = (int) (src_y + 0.5); + if (y >= height) + { + break; + } + + if (p->rotation & 4) /* mirror in x direction */ + { + src_offset = (y+1) * 3 * p->image_width - 3; + x_direction = -1; + } + else /* not mirrored */ + { + src_offset = y * 3 * p->image_width; + x_direction = 1; + } + + if (old_y != y) /* create new line ? - not necessary if the same line is used several times */ + { + old_y = y; + src_x = p->image_width - 1; + + for (dst_x = 0; dst_x < p->preview_width; ++dst_x) + { + x = (int) (src_x + 0.5); + if (x < 0) + { + break; + } + + p->preview_row[3*dst_x + 0] = p->image_data_enh[src_offset + x_direction * 3 * x + 0]; /* R */ + p->preview_row[3*dst_x + 1] = p->image_data_enh[src_offset + x_direction * 3 * x + 1]; /* G */ + p->preview_row[3*dst_x + 2] = p->image_data_enh[src_offset + x_direction * 3 * x + 2]; /* B */ + src_x -= xscale; + } + } + + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + src_y += yscale; + } + dst_y = p->preview_height; + + memset(p->preview_row, 0x80, 3*p->preview_window_width); + for (; dst_y < p->preview_window_height; ++dst_y) + { + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + } + break; + + + case 3: /* 270 degree */ + /* because we run in x direction we have to draw all rows all the time */ + + src_y = 0.0; + + DBG(DBG_info, "preview_height=%d\n", p->preview_height); + + for (dst_y = 0; dst_y < p->preview_height; ++dst_y) + { + y = (int) (src_y + 0.5); + if (y >= p->image_width) + { + break; + } + + if (p->rotation & 4) /* mirror in x direction */ + { + src_offset = (p->image_width - y - 1) * 3 + 3 * p->image_width * (p->image_height - 1); + x_direction = -1; + } + else /* not mirrored */ + { + src_offset = (p->image_width - y - 1) * 3; + x_direction = 1; + } + + if (old_y != y) /* create new line ? - not necessary if the same line is used several times */ + { + old_y = y; + src_x = 0.0; + + for (dst_x = 0; dst_x < p->preview_width; ++dst_x) + { + x = (int) (src_x + 0.5); + if (x >= p->image_height) + { + break; + } + + p->preview_row[3*dst_x + 0] = p->image_data_enh[src_offset + x_direction * 3 * x * p->image_width + 0]; /* R */ + p->preview_row[3*dst_x + 1] = p->image_data_enh[src_offset + x_direction * 3 * x * p->image_width + 1]; /* G */ + p->preview_row[3*dst_x + 2] = p->image_data_enh[src_offset + x_direction * 3 * x * p->image_width + 2]; /* B */ + src_x += xscale; + } + } + + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + src_y += yscale; + } + + memset(p->preview_row, 0x80, 3*p->preview_window_width); + for (; dst_y < p->preview_window_height; ++dst_y) + { + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, dst_y, p->preview_window_width); + } + break; + } + + if (p->calibration) /* do not rotate calibration image */ + { + p->rotation = rotation; + } + + /* image is redrawn, we have no visible selections */ + p->previous_selection.active = FALSE; + p->previous_selection_maximum.active = FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_display_partial_image(Preview *p) +{ + DBG(DBG_proc, "preview_display_partial_image\n"); + + preview_paint_image(p); + + if (GTK_WIDGET_DRAWABLE(p->window)) + { + GtkPreview *preview = GTK_PREVIEW(p->window); + int src_x, src_y; + + src_x = (p->window->allocation.width - preview->buffer_width)/2; + src_y = (p->window->allocation.height - preview->buffer_height)/2; + + gtk_preview_put(preview, p->window->window, p->window->style->black_gc, src_x, src_y, + 0, 0, p->preview_window_width, p->preview_window_height); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_display_maybe(Preview *p) +{ + time_t now; + + DBG(DBG_proc, "preview_display_maybe\n"); + + time(&now); + + if (now > p->image_last_time_updated) /* wait at least one secone */ + { + p->image_last_time_updated = now; + preview_display_partial_image(p); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_display_image(Preview *p) +{ + DBG(DBG_proc, "preview_display_image\n"); + + /* if image height was unknown and got larger than expected get missing memory */ + if (p->params.lines <= 0 && p->image_y < p->image_height) + { + p->image_height = p->image_y; + + p->image_data_raw = realloc(p->image_data_raw, 6 * p->image_width * p->image_height); + p->image_data_enh = realloc(p->image_data_enh, 3 * p->image_width * p->image_height); + assert(p->image_data_raw); + assert(p->image_data_enh); + } + + preview_do_gamma_correction(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_save_option(Preview *p, int option, void *save_loc, int *valid) +{ + SANE_Status status; + + DBG(DBG_proc, "preview_save_option\n"); + + if (option <= 0) + { + *valid = 0; + return; + } + + status = xsane_control_option(xsane.dev, option, SANE_ACTION_GET_VALUE, save_loc, 0); + *valid = (status == SANE_STATUS_GOOD); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_restore_option(Preview *p, int option, void *saved_value, int valid) +{ + const SANE_Option_Descriptor *opt; + SANE_Status status; + SANE_Handle dev; + + DBG(DBG_proc, "preview_restore_option\n"); + + if (!valid) + { + return; + } + + dev = xsane.dev; + status = xsane_control_option(dev, option, SANE_ACTION_SET_VALUE, saved_value, 0); + + if (status != SANE_STATUS_GOOD) + { + 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)); + xsane_back_gtk_error(buf, TRUE); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_set_option_float(Preview *p, int option, float value) +{ + const SANE_Option_Descriptor *opt; + SANE_Handle dev; + SANE_Word word; + + DBG(DBG_proc, "preview_set_option_float\n"); + + if (option <= 0 || value <= -INF || value >= INF) + { + return; + } + + dev = xsane.dev; + opt = xsane_get_option_descriptor(dev, option); + if (opt->type == SANE_TYPE_FIXED) + { + word = SANE_FIX(value); + } + else + { + word = value + 0.5; + } + + xsane_control_option(dev, option, SANE_ACTION_SET_VALUE, &word, 0); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_set_option(Preview *p, int option, void *value) +{ + SANE_Handle dev; + + DBG(DBG_proc, "preview_set_option\n"); + + if (option <= 0) + { + return; + } + + dev = xsane.dev; + xsane_control_option(dev, option, SANE_ACTION_SET_VALUE, value, 0); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_set_option_val(Preview *p, int option, SANE_Int value) +{ + SANE_Handle dev; + + DBG(DBG_proc, "preview_set_option_val\n"); + + if (option <= 0) + { + return; + } + + dev = xsane.dev; + xsane_control_option(dev, option, SANE_ACTION_SET_VALUE, &value, 0); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static int preview_test_image_y(Preview *p) +{ + if (p->image_y >= p->image_height) /* make sure backend does not send more data then expected */ + { + char buf[256]; + + --p->image_y; + preview_scan_done(p, 1); + snprintf(buf, sizeof(buf), "%s", ERR_TOO_MUCH_DATA); + xsane_back_gtk_error(buf, TRUE); + return -1; + } + + return 0; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static int preview_increment_image_y(Preview *p) +{ + size_t extra_size, offset; + char buf[256]; + + DBG(DBG_proc, "preview_increment_image_y\n"); + + p->image_x = 0; + ++p->image_y; + + if (p->params.lines <= 0 && p->image_y >= p->image_height) /* backend said it does not know image height */ + { + offset = 3 * p->image_width*p->image_height; + extra_size = 3 * 32 * p->image_width; + p->image_height += 32; + + p->image_data_raw = realloc(p->image_data_raw, (offset + extra_size) * 2); + p->image_data_enh = realloc(p->image_data_enh, offset + extra_size); + + 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)); + xsane_back_gtk_error(buf, TRUE); + return -1; + } + memset(p->image_data_enh + offset, 0xff, extra_size); + } + + return 0; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_read_image_data(gpointer data, gint source, GdkInputCondition cond) +{ + SANE_Status status; + Preview *p = data; + u_char buf[8192]; + guint16 *buf16 = (guint16 *) buf; + SANE_Handle dev; + SANE_Int len; + int i, j; + int offset = 0; + char last = 0; + + DBG(DBG_proc, "preview_read_image_data\n"); + + dev = xsane.dev; + while (1) + { + if ((p->params.depth == 1) || (p->params.depth == 8)) + { + status = sane_read(dev, buf, sizeof(buf), &len); + } + else if (p->params.depth == 16) + { + if (offset) + { + 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); + } + else + { + status = sane_read(dev, (SANE_Byte *) buf16, sizeof(buf), &len); + } + + if (len % 2) /* odd number of bytes */ + { + len--; + last = buf16[len]; + offset = 1; + } + else /* even number of bytes */ + { + offset = 0; + } + } + else /* bad bitdepth */ + { + preview_scan_done(p, 0); + snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth); + xsane_back_gtk_error(buf, TRUE); + return; + } + + + if (!p->scanning) /* preview scan may have been canceled while sane_read was executed */ + { + return; /* ok, the scan has been canceled */ + } + + + if (status != SANE_STATUS_GOOD) + { + if (status == SANE_STATUS_EOF) + { + if (p->params.last_frame) /* got all preview image data */ + { + p->invalid = FALSE; /* preview is valid now */ + preview_scan_done(p, 1); /* scan is done, save image */ + return; /* ok, all finished */ + } + else + { + if (p->input_tag >= 0) + { + gdk_input_remove(p->input_tag); + p->input_tag = -1; + } + preview_scan_start(p); + break; /* exit while loop, display_maybe */ + } + } + else if (status == SANE_STATUS_CANCELLED) + { + p->invalid = FALSE; /* preview is valid now - although it is cancled */ + p->scan_incomplete = TRUE; /* preview is incomplete */ + preview_scan_done(p, 1); /* save scanned part of the preview */ + snprintf(buf, sizeof(buf), "%s", XSANE_STRSTATUS(status)); + xsane_back_gtk_info(buf, TRUE); + return; + } + + /* not SANE_STATUS_GOOD and not SANE_STATUS_EOF and not SANE_STATUS_CANCELLED */ + preview_scan_done(p, 0); + snprintf(buf, sizeof(buf), "%s %s.", ERR_DURING_READ, XSANE_STRSTATUS(status)); + xsane_back_gtk_error(buf, TRUE); + return; + } + + if (!len) + { + break; /* out of data for now */ + } + + switch (p->params.format) + { + case SANE_FRAME_RGB: + switch (p->params.depth) + { + case 8: + { + for (i = 0; i < len; ++i) + { + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + p->image_data_raw[p->image_offset] = buf[i] * 256; + p->image_data_enh[p->image_offset++] = buf[i]; + + if (p->image_offset%3 == 0) + { + if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0) + { + return; + } + } + } + } + break; + + case 16: + { + for (i = 0; i < len/2; ++i) + { + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + p->image_data_raw[p->image_offset] = buf16[i]; + p->image_data_enh[p->image_offset++] = (u_char) (buf16[i]/256); + + if (p->image_offset%3 == 0) + { + if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0) + { + return; + } + } + } + } + break; + + default: + preview_scan_done(p, 0); + snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth); + xsane_back_gtk_error(buf, TRUE); + return; + } + break; + + case SANE_FRAME_GRAY: + switch (p->params.depth) + { + case 1: + for (i = 0; i < len; ++i) + { + u_char mask = buf[i]; + + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + for (j = 7; j >= 0; --j) + { + u_char gl = (mask & (1 << j)) ? 0x00 : 0xff; + + 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_data_raw[p->image_offset] = gl * 256; + p->image_data_enh[p->image_offset++] = gl; + + if (++p->image_x >= p->image_width) + { + if (preview_increment_image_y(p) < 0) + { + return; + } + break; /* skip padding bits */ + } + } + } + break; + + case 8: + for (i = 0; i < len; ++i) + { + u_char gray = buf[i]; + + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + p->image_data_raw[p->image_offset] = gray * 256; + p->image_data_enh[p->image_offset++] = gray; + + p->image_data_raw[p->image_offset] = gray * 256; + p->image_data_enh[p->image_offset++] = gray; + + p->image_data_raw[p->image_offset] = gray * 256; + p->image_data_enh[p->image_offset++] = gray; + if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0) + { + return; + } + } + break; + + case 16: + for (i = 0; i < len/2; ++i) + { + u_char gray = buf16[i]/256; + + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + p->image_data_raw[p->image_offset] = buf16[i]; + p->image_data_enh[p->image_offset++] = gray; + + p->image_data_raw[p->image_offset] = buf16[i]; + p->image_data_enh[p->image_offset++] = gray; + + p->image_data_raw[p->image_offset] = buf16[i]; + p->image_data_enh[p->image_offset++] = gray; + + if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0) + { + return; + } + } + break; + + default: + preview_scan_done(p, 0); + snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth); + xsane_back_gtk_error(buf, TRUE); + return; + } + break; + + case SANE_FRAME_RED: + case SANE_FRAME_GREEN: + case SANE_FRAME_BLUE: + switch (p->params.depth) + { + case 1: + for (i = 0; i < len; ++i) + { + u_char mask = buf[i]; + + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + for (j = 0; j < 8; ++j) + { + 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_offset += 3; + if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0) + { + return; + } + } + } + break; + + case 8: + for (i = 0; i < len; ++i) + { + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + p->image_data_raw[p->image_offset] = buf[i] * 256; + p->image_data_enh[p->image_offset] = buf[i]; + + p->image_offset += 3; + if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0) + { + return; + } + } + break; + + case 16: + for (i = 0; i < len/2; ++i) + { + if (preview_test_image_y(p)) + { + return; /* backend sends too much image data */ + } + + p->image_data_raw[p->image_offset] = buf16[i]; + p->image_data_enh[p->image_offset] = (u_char) (buf16[i]/256); + + p->image_offset += 3; + if (++p->image_x >= p->image_width && preview_increment_image_y(p) < 0) + { + return; + } + } + break; + + default: + preview_scan_done(p, 0); + snprintf(buf, sizeof(buf), "%s %d.", ERR_PREVIEW_BAD_DEPTH, p->params.depth); + 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); + xsane_back_gtk_error(buf, TRUE); + return; + } + + if (p->input_tag < 0) + { + preview_display_maybe(p); + while (gtk_events_pending()) + { + DBG(DBG_info, "preview_read_image_data: calling gtk_main_iteration\n"); + gtk_main_iteration(); + } + } + } + preview_display_maybe(p); + + return; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_scan_done(Preview *p, int save_image) +{ + int i; + + DBG(DBG_proc, "preview_scan_done\n"); + + p->scanning = FALSE; + + if (p->input_tag >= 0) + { + gdk_input_remove(p->input_tag); + p->input_tag = -1; + } + + sane_cancel(xsane.dev); + + xsane.block_update_param = TRUE; /* do not change parameters each time */ + + preview_restore_option(p, xsane.well_known.dpi, &p->saved_dpi, p->saved_dpi_valid); + preview_restore_option(p, xsane.well_known.dpi_x, &p->saved_dpi_x, p->saved_dpi_x_valid); + preview_restore_option(p, xsane.well_known.dpi_y, &p->saved_dpi_y, p->saved_dpi_y_valid); + + for (i = 0; i < 4; ++i) + { + preview_restore_option(p, xsane.well_known.coord[i], &p->saved_coord[i], p->saved_coord_valid[i]); + } + + preview_restore_option(p, xsane.well_known.scanmode, &p->saved_scanmode, p->saved_scanmode_valid); + + preview_restore_option(p, xsane.well_known.bit_depth, &p->saved_bit_depth, p->saved_bit_depth_valid); + + preview_set_option_val(p, xsane.well_known.preview, SANE_FALSE); + + gtk_widget_set_sensitive(p->cancel, FALSE); + xsane_set_sensitivity(TRUE); + + xsane.block_update_param = FALSE; + + preview_update_selection(p); + + if (save_image) + { + preview_save_image(p); /* save preview image */ + preview_display_image(p); + } + + preview_update_surface(p, 1); /* if surface was not defined it's necessary to redefine it now */ + + xsane_update_histogram(TRUE /* update raw */); + + sane_get_parameters(xsane.dev, &xsane.param); /* update xsane.param */ + + if ( (preferences.preselect_scanarea) && (!p->startimage)) + { + preview_autoselect_scanarea(p, p->selection.coordinate); /* get autoselection coordinates */ + preview_draw_selection(p); + preview_establish_selection(p); + xsane_update_histogram(TRUE /* update_raw */); /* update histogram (necessary because overwritten by preview_update_surface) */ + } + + if (preferences.auto_correct_colors) + { + xsane_calculate_raw_histogram(); + xsane_set_auto_enhancement(); + xsane_enhancement_by_histogram(preferences.auto_enhance_gamma); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static int preview_get_memory(Preview *p) +{ + char buf[256]; + + DBG(DBG_proc, "preview_get_memory\n"); + + if (p->image_data_enh) + { + free(p->image_data_enh); + p->image_data_enh = 0; + } + + if (p->image_data_raw) + { + free(p->image_data_raw); + p->image_data_raw = 0; + } + + if (p->preview_row) + { + free(p->preview_row); + p->preview_row = 0; + } + + p->image_data_raw = malloc(6 * p->image_width * p->image_height); + p->image_data_enh = malloc(3 * p->image_width * p->image_height); + p->preview_row = malloc(3 * p->preview_window_width); + + if ( (!p->image_data_raw) || (!p->image_data_enh) || (!p->preview_row) ) + { + if (p->image_data_enh) + { + free(p->image_data_enh); + p->image_data_enh = 0; + } + + if (p->image_data_raw) + { + free(p->image_data_raw); + p->image_data_raw = 0; + } + + if (p->preview_row) + { + free(p->preview_row); + p->preview_row = 0; + } + + DBG(DBG_error, "failed to allocate image buffer: %s", strerror(errno)); + snprintf(buf, sizeof(buf), "%s %s.", ERR_FAILED_ALLOCATE_IMAGE, strerror(errno)); + xsane_back_gtk_error(buf, TRUE); + + return -1; /* error */ + } + + memset(p->image_data_raw, 0x80, 6*p->image_width*p->image_height); /* clean memory */ + memset(p->image_data_enh, 0x80, 3*p->image_width*p->image_height); /* clean memory */ + + return 0; /* ok */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +/* preview_scan_start is called 3 times in 3 pass color scanning mode */ +static void preview_scan_start(Preview *p) +{ + SANE_Handle dev = xsane.dev; + 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"); + + xsane.medium_changed = FALSE; + + preview_display_valid(p); + + p->startimage = 0; /* we start the scan so lets say the startimage is not displayed any more */ + + p->image_surface[0] = p->surface[p->index_xmin]; + p->image_surface[1] = p->surface[p->index_ymin]; + p->image_surface[2] = p->surface[p->index_xmax]; + p->image_surface[3] = p->surface[p->index_ymax]; + + gtk_widget_set_sensitive(p->cancel, TRUE); + xsane_set_sensitivity(FALSE); + + /* clear preview row */ + memset(p->preview_row, 0xff, 3*p->preview_width); + + for (y = 0; y < p->preview_height; ++y) + { + gtk_preview_draw_row(GTK_PREVIEW(p->window), p->preview_row, 0, y, p->preview_width); + } + + if (p->input_tag >= 0) + { + gdk_input_remove(p->input_tag); + 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) + { + preview_scan_done(p, 0); + snprintf(buf, sizeof(buf), "%s %s.", ERR_FAILED_START_SCANNER, XSANE_STRSTATUS(status)); + xsane_back_gtk_error(buf, TRUE); + return; + } + + status = sane_get_parameters(dev, &p->params); + if (status != SANE_STATUS_GOOD) + { + preview_scan_done(p, 0); + snprintf(buf, sizeof(buf), "%s %s.", ERR_FAILED_GET_PARAMS, XSANE_STRSTATUS(status)); + xsane_back_gtk_error(buf, TRUE); + return; + } + + p->image_offset = p->image_x = p->image_y = 0; + + if (p->params.format >= SANE_FRAME_RED && p->params.format <= SANE_FRAME_BLUE) + { + p->image_offset = p->params.format - SANE_FRAME_RED; + } + + if ( (!p->image_data_enh) || (p->params.pixels_per_line != p->image_width) + || ( (p->params.lines >= 0) && (p->params.lines != p->image_height) ) ) + { + p->image_width = p->params.pixels_per_line; + p->image_height = p->params.lines; + + if (p->image_height < 0) + { + p->image_height = 32; /* may have to adjust as we go... */ + } + + if (preview_get_memory(p)) + { + preview_scan_done(p, 0); /* error */ + snprintf(buf, sizeof(buf), "%s", ERR_NO_MEM); + xsane_back_gtk_error(buf, TRUE); + return; + } + } + else if (p->scanning == FALSE) /* single pass scan or first run in 3 pass mode */ + { + memset(p->image_data_raw, 0x80, 6*p->image_width*p->image_height); /* clean memory */ + memset(p->image_data_enh, 0x80, 3*p->image_width*p->image_height); /* clean memory */ + } + + /* we do not have any active selection (image is redrawn while scanning) */ + p->selection.active = FALSE; + 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); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static int preview_make_image_path(Preview *p, size_t filename_size, char *filename, int level) +{ + char buf[256]; + + DBG(DBG_proc, "preview_make_image_path\n"); + + snprintf(buf, sizeof(buf), "preview-level-%d-", level); + return xsane_back_gtk_make_path(filename_size, filename, 0, 0, buf, xsane.dev_name, ".ppm", XSANE_PATH_TMP); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static int preview_restore_image_from_file(Preview *p, FILE *in, 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 quality = 0; + int x, y; + int time; + float psurface[4]; + float dsurface[4]; + size_t nread; + guint16 *imagep; + guint16 *imagepx; + char buf[255]; + + DBG(DBG_proc, "preview_restore_image_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 */ + + + 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, "preview selection surface = [%3.2f %3.2f %3.2f %3.2f]\n", + p->surface[0], p->surface[1], p->surface[2], p->surface[3]); + DBG(DBG_info, "preview device surface = [%3.2f %3.2f %3.2f %3.2f]\n", + dsurface[0], dsurface[1], dsurface[2], dsurface[3]); + + xoffset = (dsurface[0] - psurface[0])/(psurface[2] - psurface[0]) * image_width; + 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) || + (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; /* file does not cover wanted surface part */ + } + + 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 /* read startimage or calibrationimage */ + { + xoffset = 0; + yoffset = 0; + width = image_width; + height = image_height; + } + + if (max_val == 65535) + { + p->params.depth = 16; + } + else + { + p->params.depth = 8; + } + + p->image_width = width; + p->image_height = height; + + if (preview_get_memory(p)) + { + return min_quality; /* error allocating memory */ + } + + if (p->params.depth == 16) + { + fseek(in, yoffset * image_width * 6, SEEK_CUR); /* skip unused lines */ + + imagep = p->image_data_raw; + + for (y = yoffset; y < yoffset + height; y++) + { + fseek(in, xoffset * 6, SEEK_CUR); /* skip unused pixel left of area */ + + nread = fread(imagep, 6, width, in); + imagep += width * 3; /* imagep is a pointer to a 2 byte value, so we use 3 instead 6 here */ + + fseek(in, (image_width - width - xoffset) * 6, SEEK_CUR); /* skip unused pixel right of area */ + } + } + else /* depth = 8 */ + { + fseek(in, yoffset * image_width * 3, SEEK_CUR); /* skip unused lines */ + + imagep = p->image_data_raw; + + for (y = yoffset; y < yoffset + height; y++) + { + fseek(in, xoffset * 3, SEEK_CUR); /* skip unused pixel left of area */ + + imagepx = imagep; + for (x = 0; x < width; x++) + { + *imagepx++ = ((guint16) fgetc(in)) * 256; /* transfrom to 16 bit image with correct byte order */ + *imagepx++ = ((guint16) fgetc(in)) * 256; + *imagepx++ = ((guint16) fgetc(in)) * 256; + } + imagep += width * 3; /* imagep is a pointer to a 2 byte value, so we use 3 instead 6 here */ + + fseek(in, (image_width - width - xoffset) * 3, SEEK_CUR); /* skip unused pixel right of area */ + } + } + + p->image_x = width; + p->image_y = height; + + p->image_surface[0] = p->surface[p->index_xmin]; + p->image_surface[1] = p->surface[p->index_ymin]; + p->image_surface[2] = p->surface[p->index_xmax]; + p->image_surface[3] = p->surface[p->index_ymax]; + + *min_time = time; + + return quality; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_restore_image(Preview *p) +{ + FILE *in; + int quality = 0; + int time = 0; + int level; + + DBG(DBG_proc, "preview_restore_image\n"); + + p->startimage = 0; + + if (p->calibration) + { + char filename[PATH_MAX]; + + DBG(DBG_proc, "calibration mode\n"); + xsane_back_gtk_make_path(sizeof(filename), filename, "xsane", 0, "xsane-calibration", 0, ".pnm", XSANE_PATH_SYSTEM); + in = fopen(filename, "rb"); /* read binary (b for win32) */ + if (in) + { + quality = preview_restore_image_from_file(p, in, -1, &time); + fclose(in); + } + } + else + { + /* See whether there is a saved preview and load it if present: */ + for(level = 2; level >= 0; level--) + { + if (p->filename[level]) + { + in = fopen(p->filename[level], "rb"); /* read binary (b for win32) */ + if (in) + { + quality = preview_restore_image_from_file(p, in, quality, &time); + fclose(in); + } + } + } + + if (quality == 0) /* no image found, read startimage */ + { + char filename[PATH_MAX]; + + DBG(DBG_proc, "no suitable image available, using startimage\n"); + 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) + { + quality = preview_restore_image_from_file(p, in, -1, &time); + fclose(in); + } + else + { + guint16 *imagep; + + DBG(DBG_error0, "ERROR: xsane-startimage not found. Looks like xsane is not installed correct.\n"); + + p->image_width = 1; + p->image_height = 1; + p->params.depth = 16; + + preview_get_memory(p); + + imagep = p->image_data_raw; + *imagep++ = 65535; + *imagep++ = 00000; + *imagep++ = 00000; + + p->image_x = p->image_width; + p->image_y = p->image_height; + + p->image_surface[0] = p->surface[p->index_xmin]; + p->image_surface[1] = p->surface[p->index_ymin]; + p->image_surface[2] = p->surface[p->index_xmax]; + p->image_surface[3] = p->surface[p->index_ymax]; + } + p->startimage = 1; + } + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_hold_event_handler(gpointer data) +{ + Preview *p = data; + + DBG(DBG_proc, "preview_hold_event_handler\n"); + + preview_draw_selection(p); + p->gamma_functions_interruptable = TRUE; + preview_establish_selection(p); + p->gamma_functions_interruptable = FALSE; + + gtk_timeout_remove(p->hold_timer); + p->hold_timer = 0; + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_motion_event_handler(GtkWidget *window, GdkEvent *event, gpointer data) +{ + Preview *p = data; + GdkCursor *cursor; + float preview_selection[4]; + float preview_x, preview_y; + float xscale, yscale; + int cursornr; + + DBG(DBG_proc, "preview_motion_event_handler\n"); + + /* preview selection (device) -> cursor-position (window) */ + preview_transform_coordinates_device_to_window(p, p->selection.coordinate, preview_selection); + + /* cursor-prosition (window) -> preview coordinate (device) */ + preview_transform_coordinate_window_to_device(p, event->button.x, event->button.y, &preview_x, &preview_y); + + preview_get_scale_device_to_window(p, &xscale, &yscale); + + if (!p->scanning) + { + switch (((GdkEventMotion *)event)->state & + GDK_Num_Lock & GDK_Caps_Lock & GDK_Shift_Lock & GDK_Scroll_Lock) /* mask all Locks */ + { + case 256: /* left button */ + + DBG(DBG_info2, "left button\n"); + + 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; + + preview_order_selection(p); + preview_bound_selection(p); + + if (preferences.gtk_update_policy == GTK_UPDATE_CONTINUOUS) + { + if (!p->hold_timer) /* hold timer active? then remove it, we had a motion */ + { + p->hold_timer = gtk_timeout_add(XSANE_CONTINUOUS_HOLD_TIME, preview_hold_event_handler, (gpointer *) p); + } + preview_update_maximum_output_size(p); + preview_draw_selection(p); + } + else if (preferences.gtk_update_policy == GTK_UPDATE_DELAYED) + { + /* call preview_hold_event_hanlder if mouse is not moved for ??? ms */ + if (p->hold_timer) /* hold timer active? then remove it, we had a motion */ + { + gtk_timeout_remove(p->hold_timer); + p->hold_timer = 0; + } + p->hold_timer = gtk_timeout_add(XSANE_HOLD_TIME, preview_hold_event_handler, (gpointer *) p); + preview_update_maximum_output_size(p); + preview_draw_selection(p); + } + else /* discontinuous */ + { + preview_update_maximum_output_size(p); + preview_draw_selection(p); /* only draw selection, do not update backend geometry options */ + } + } + + cursornr = p->cursornr; + + if ( (p->selection_xedge != -1) && (p->selection_yedge != -1) ) /* move corner */ + { + if ( ( (preview_selection[0] - SELECTION_RANGE_OUT < event->button.x) && + (event->button.x < preview_selection[0] + SELECTION_RANGE_IN) ) && /* left */ + ( (preview_selection[1] - SELECTION_RANGE_OUT < event->button.y) && + (event->button.y < preview_selection[1] + SELECTION_RANGE_IN) ) ) /* top */ + { + cursornr = GDK_TOP_LEFT_CORNER; + } + else if ( ( (preview_selection[2] - SELECTION_RANGE_IN < event->button.x) && + (event->button.x < preview_selection[2] + SELECTION_RANGE_OUT) ) && /* right */ + ( (preview_selection[1] - SELECTION_RANGE_OUT < event->button.y) && + (event->button.y < preview_selection[1] + SELECTION_RANGE_IN) ) ) /* top */ + { + cursornr = GDK_TOP_RIGHT_CORNER; + } + else if ( ( (preview_selection[0] - SELECTION_RANGE_OUT < event->button.x) && + (event->button.x < preview_selection[0] + SELECTION_RANGE_IN) ) && /* left */ + ( (preview_selection[3] - SELECTION_RANGE_IN < event->button.y) && + (event->button.y < preview_selection[3] + SELECTION_RANGE_OUT) ) ) /* bottom */ + { + cursornr = GDK_BOTTOM_LEFT_CORNER; + } + else if ( ( (preview_selection[2] - SELECTION_RANGE_IN < event->button.x) && + (event->button.x < preview_selection[2] + SELECTION_RANGE_OUT) ) && /* right */ + ( (preview_selection[3] - SELECTION_RANGE_IN < event->button.y) && + (event->button.y < preview_selection[3] + SELECTION_RANGE_OUT) ) ) /* bottom */ + { + cursornr = GDK_BOTTOM_RIGHT_CORNER; + } + } + else if ( (preview_selection[0] - SELECTION_RANGE_OUT < event->button.x) && + (event->button.x < preview_selection[0] + SELECTION_RANGE_IN) ) /* left */ + { + if (cursornr == GDK_RIGHT_SIDE) + { + cursornr = GDK_LEFT_SIDE; + } + } + else if ( (preview_selection[2] - SELECTION_RANGE_IN < event->button.x) && + (event->button.x < preview_selection[2] + SELECTION_RANGE_OUT) ) /* right */ + { + if (cursornr == GDK_LEFT_SIDE) + { + cursornr = GDK_RIGHT_SIDE; + } + } + else if ( (preview_selection[1] - SELECTION_RANGE_OUT < event->button.y) && + (event->button.y < preview_selection[1] + SELECTION_RANGE_IN) ) /* top */ + { + if (cursornr == GDK_BOTTOM_SIDE) + { + cursornr = GDK_TOP_SIDE; + } + } + else if ( (preview_selection[3] - SELECTION_RANGE_IN < event->button.y) && + (event->button.y < preview_selection[3] + SELECTION_RANGE_OUT) ) /* bottom */ + { + if (cursornr == GDK_TOP_SIDE) + { + cursornr = GDK_BOTTOM_SIDE; + } + } + + if (cursornr != p->cursornr) + { + cursor = gdk_cursor_new(cursornr); /* set curosr */ + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = cursornr; + } + break; + + case 512: /* middle button */ + case 1024: /* right button */ + DBG(DBG_info2, "middle or right button\n"); + + if (p->selection_drag) + { + double dx, dy; + + switch (p->rotation) + { + case 0: /* 0 degree */ + default: + dx = (p->selection_xpos - event->motion.x) / xscale; + dy = (p->selection_ypos - event->motion.y) / yscale; + break; + + case 1: /* 90 degree */ + dx = (event->motion.x - p->selection_xpos) / xscale; + dy = (p->selection_ypos - event->motion.y) / yscale; + break; + + case 2: /* 180 degree */ + dx = (event->motion.x - p->selection_xpos) / xscale; + dy = (event->motion.y - p->selection_ypos) / yscale; + break; + + case 3: /* 270 degree */ + dx = (p->selection_xpos - event->motion.x) / xscale; + dy = (event->motion.y - p->selection_ypos) / yscale; + break; + + case 4: /* 0 degree, x mirror */ + dx = (event->motion.x - p->selection_xpos) / xscale; + dy = (p->selection_ypos - event->motion.y) / yscale; + break; + + case 5: /* 90 degree, x mirror */ + dx = (p->selection_xpos - event->motion.x) / xscale; + dy = (p->selection_ypos - event->motion.y) / yscale; + break; + + case 6: /* 180 degree, x mirror */ + dx = (p->selection_xpos - event->motion.x) / xscale; + dy = (event->motion.y - p->selection_ypos) / yscale; + break; + + case 7: /* 270 degree, x mirror */ + dx = (event->motion.x - p->selection_xpos) / xscale; + dy = (event->motion.y - p->selection_ypos) / yscale; + break; + } + + p->selection_xpos = event->motion.x; + p->selection_ypos = event->motion.y; + + if (dx > p->selection.coordinate[p->index_xmin] - p->scanner_surface[p->index_xmin]) + { + dx = p->selection.coordinate[p->index_xmin] - p->scanner_surface[p->index_xmin]; + } + + if (dy > p->selection.coordinate[p->index_ymin] - p->scanner_surface[p->index_ymin]) + { + dy = p->selection.coordinate[p->index_ymin] - p->scanner_surface[p->index_ymin]; + } + + if (dx < p->selection.coordinate[p->index_xmax] - p->scanner_surface[p->index_xmax]) + { + dx = p->selection.coordinate[p->index_xmax] - p->scanner_surface[p->index_xmax]; + } + + if (dy < p->selection.coordinate[p->index_ymax] - p->scanner_surface[p->index_ymax]) + { + dy = p->selection.coordinate[p->index_ymax] - p->scanner_surface[p->index_ymax]; + } + + p->selection.active = TRUE; + p->selection.coordinate[0] -= dx; + p->selection.coordinate[1] -= dy; + p->selection.coordinate[2] -= dx; + p->selection.coordinate[3] -= dy; + + if (preferences.gtk_update_policy == GTK_UPDATE_CONTINUOUS) + { + if (!p->hold_timer) /* hold timer active? then remove it, we had a motion */ + { + p->hold_timer = gtk_timeout_add(XSANE_CONTINUOUS_HOLD_TIME, preview_hold_event_handler, (gpointer *) p); + } + preview_update_maximum_output_size(p); + preview_draw_selection(p); + } + else if (preferences.gtk_update_policy == GTK_UPDATE_DELAYED) + { + if (p->hold_timer) /* hold timer active? then remove it, we had a motion */ + { + gtk_timeout_remove(p->hold_timer); + p->hold_timer = 0; + } + p->hold_timer = gtk_timeout_add (XSANE_HOLD_TIME, preview_hold_event_handler, (gpointer *) p); + preview_update_maximum_output_size(p); + preview_draw_selection(p); + } + else /* discontinuous */ + { + preview_update_maximum_output_size(p); + preview_draw_selection(p); + } + } + break; + + default: + if ( ( (preview_selection[0] - SELECTION_RANGE_OUT < event->button.x) && + (event->button.x < preview_selection[0] + SELECTION_RANGE_IN) ) && /* left */ + ( (preview_selection[1] - SELECTION_RANGE_OUT < event->button.y) && + (event->button.y < preview_selection[1] + SELECTION_RANGE_IN) ) ) /* top */ + { + cursornr = GDK_TOP_LEFT_CORNER; + } + else if ( ( (preview_selection[2] - SELECTION_RANGE_IN < event->button.x) && + (event->button.x < preview_selection[2] + SELECTION_RANGE_OUT) ) && /* right */ + ( (preview_selection[1] - SELECTION_RANGE_OUT < event->button.y) && + (event->button.y < preview_selection[1] + SELECTION_RANGE_IN) ) ) /* top */ + { + cursornr = GDK_TOP_RIGHT_CORNER; + } + else if ( ( (preview_selection[0] - SELECTION_RANGE_OUT < event->button.x) && + (event->button.x < preview_selection[0] + SELECTION_RANGE_IN) ) && /* left */ + ( (preview_selection[3] - SELECTION_RANGE_IN < event->button.y) && + (event->button.y < preview_selection[3] + SELECTION_RANGE_OUT) ) ) /* bottom */ + { + cursornr = GDK_BOTTOM_LEFT_CORNER; + } + else if ( ( (preview_selection[2] - SELECTION_RANGE_IN < event->button.x) && + (event->button.x < preview_selection[2] + SELECTION_RANGE_OUT) ) && /* right */ + ( (preview_selection[3] - SELECTION_RANGE_IN < event->button.y) && + (event->button.y < preview_selection[3] + SELECTION_RANGE_OUT) ) ) /* bottom */ + { + cursornr = GDK_BOTTOM_RIGHT_CORNER; + } + else if ( ( (preview_selection[0] - SELECTION_RANGE_OUT < event->button.x) && + (event->button.x < preview_selection[0] + SELECTION_RANGE_IN) ) && /* left */ + ( (event->button.y > preview_selection[1]) && (event->button.y < preview_selection[3]) ) ) /* in height */ + { + cursornr = GDK_LEFT_SIDE; + } + else if ( ( (preview_selection[2] - SELECTION_RANGE_IN < event->button.x) && + (event->button.x < preview_selection[2] + SELECTION_RANGE_OUT) ) && /* right */ + ( (event->button.y > preview_selection[1]) && (event->button.y < preview_selection[3]) ) ) /* in height */ + { + cursornr = GDK_RIGHT_SIDE; + } + else if ( ( (preview_selection[1] - SELECTION_RANGE_OUT < event->button.y) && + (event->button.y < preview_selection[1] + SELECTION_RANGE_IN) ) && /* top */ + ( (event->button.x > preview_selection[0]) && (event->button.x < preview_selection[2]) ) ) /* in width */ + { + cursornr = GDK_TOP_SIDE; + } + else if ( ( (preview_selection[3] - SELECTION_RANGE_IN < event->button.y) && + (event->button.y < preview_selection[3] + SELECTION_RANGE_OUT) ) && /* bottom */ + ( (event->button.x > preview_selection[0]) && (event->button.x < preview_selection[2]) ) ) /* in width */ + { + cursornr = GDK_BOTTOM_SIDE; + } + else + { + cursornr = XSANE_CURSOR_PREVIEW; + } + + if ((cursornr != p->cursornr) && (p->cursornr != -1)) + { + cursor = gdk_cursor_new(cursornr); /* set curosr */ + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = cursornr; + } + break; + } + } + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_button_press_event_handler(GtkWidget *window, GdkEvent *event, gpointer data) +{ + Preview *p = data; + GdkCursor *cursor; + float preview_selection[4]; + float preview_x, preview_y; + int cursornr; + + DBG(DBG_proc, "preview_button_press_event_handler\n"); + + /* preview selection (device) -> cursor-position (window) */ + preview_transform_coordinates_device_to_window(p, p->selection.coordinate, preview_selection); + + /* cursor-prosition (window) -> preview coordinate (device) */ + preview_transform_coordinate_window_to_device(p, event->button.x, event->button.y, &preview_x, &preview_y); + + if (!p->scanning) + { + switch (p->mode) + { + case MODE_PIPETTE_WHITE: + { + DBG(DBG_info, "pipette white mode\n"); + if ( ( (((GdkEventButton *)event)->button == 1) || (((GdkEventButton *)event)->button == 2) ) && (p->image_data_raw) ) /* left or middle button */ + { + int r=255, g=255, b=255; /* preset color to white */ + + preview_get_color(p, event->button.x, event->button.y, preferences.preview_pipette_range, &r, &g, &b); + + xsane.slider_gray.value[2] = sqrt( (r*r+g*g+b*b) / 3)/2.55; + + if ( (!xsane.enhancement_rgb_default) && (((GdkEventButton *)event)->button == 2) ) /* middle button */ + { + xsane.slider_red.value[2] = r/2.55; + xsane.slider_green.value[2] = g/2.55; + xsane.slider_blue.value[2] = b/2.55; + } + else + { + xsane.slider_red.value[2] = xsane.slider_gray.value[2]; + xsane.slider_green.value[2] = xsane.slider_gray.value[2]; + xsane.slider_blue.value[2] = xsane.slider_gray.value[2]; + } + + if (xsane.slider_gray.value[2] < 2) + { + xsane.slider_gray.value[2] = 2; + } + if (xsane.slider_gray.value[1] >= xsane.slider_gray.value[2]) + { + xsane.slider_gray.value[1] = xsane.slider_gray.value[2]-1; + if (xsane.slider_gray.value[0] >= xsane.slider_gray.value[1]) + { + xsane.slider_gray.value[0] = xsane.slider_gray.value[1]-1; + } + } + + if (xsane.slider_red.value[2] < 2) + { + xsane.slider_red.value[2] = 2; + } + if (xsane.slider_red.value[1] >= xsane.slider_red.value[2]) + { + xsane.slider_red.value[1] = xsane.slider_red.value[2]-1; + if (xsane.slider_red.value[0] >= xsane.slider_red.value[1]) + { + xsane.slider_red.value[0] = xsane.slider_red.value[1]-1; + } + } + + if (xsane.slider_green.value[2] < 2) + { + xsane.slider_green.value[2] = 2; + } + if (xsane.slider_green.value[1] >= xsane.slider_green.value[2]) + { + xsane.slider_green.value[1] = xsane.slider_green.value[2]-1; + if (xsane.slider_green.value[0] >= xsane.slider_green.value[1]) + { + xsane.slider_green.value[0] = xsane.slider_green.value[1]-1; + } + } + + if (xsane.slider_blue.value[2] < 2) + { + xsane.slider_blue.value[2] = 2; + } + if (xsane.slider_blue.value[1] >= xsane.slider_blue.value[2]) + { + xsane.slider_blue.value[1] = xsane.slider_blue.value[2]-1; + if (xsane.slider_blue.value[0] >= xsane.slider_blue.value[1]) + { + xsane.slider_blue.value[0] = xsane.slider_blue.value[1]-1; + } + } + + xsane_enhancement_by_histogram(TRUE); + } + + p->mode = MODE_NORMAL; + + cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW); + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = XSANE_CURSOR_PREVIEW; + } + break; + + case MODE_PIPETTE_GRAY: + { + DBG(DBG_info, "pipette gray mode\n"); + + if ( ( (((GdkEventButton *)event)->button == 1) || (((GdkEventButton *)event)->button == 2) ) && (p->image_data_raw) ) /* left or middle button */ + { + int r=128, g=128, b=128; /* preset color to gray */ + + preview_get_color(p, event->button.x, event->button.y, preferences.preview_pipette_range, &r, &g, &b); + + xsane.slider_gray.value[1] = sqrt( (r*r+g*g+b*b) / 3)/2.55; + + if ( (!xsane.enhancement_rgb_default) && (((GdkEventButton *)event)->button == 2) ) /* middle button */ + { + xsane.slider_red.value[1] = r/2.55; + xsane.slider_green.value[1] = g/2.55; + xsane.slider_blue.value[1] = b/2.55; + } + else + { + xsane.slider_red.value[1] = xsane.slider_gray.value[1]; + xsane.slider_green.value[1] = xsane.slider_gray.value[1]; + xsane.slider_blue.value[1] = xsane.slider_gray.value[1]; + } + + if (xsane.slider_gray.value[1] == 0) + { + xsane.slider_gray.value[1] += 1; + } + if (xsane.slider_gray.value[1] == 100) + { + xsane.slider_gray.value[1] -= 1; + } + if (xsane.slider_gray.value[1] >= xsane.slider_gray.value[2]) + { + xsane.slider_gray.value[2] = xsane.slider_gray.value[1]+1; + } + if (xsane.slider_gray.value[1] <= xsane.slider_gray.value[0]) + { + xsane.slider_gray.value[0] = xsane.slider_gray.value[1]-1; + } + + if (xsane.slider_red.value[1] == 0) + { + xsane.slider_red.value[1] += 1; + } + if (xsane.slider_red.value[1] == 100) + { + xsane.slider_red.value[1] -= 1; + } + if (xsane.slider_red.value[1] >= xsane.slider_red.value[2]) + { + xsane.slider_red.value[2] = xsane.slider_red.value[1]+1; + } + if (xsane.slider_red.value[1] <= xsane.slider_red.value[0]) + { + xsane.slider_red.value[0] = xsane.slider_red.value[1]-1; + } + + if (xsane.slider_green.value[1] == 0) + { + xsane.slider_green.value[1] += 1; + } + if (xsane.slider_green.value[1] == 100) + { + xsane.slider_green.value[1] -= 1; + } + if (xsane.slider_green.value[1] >= xsane.slider_green.value[2]) + { + xsane.slider_green.value[2] = xsane.slider_green.value[1]+1; + } + if (xsane.slider_green.value[1] <= xsane.slider_green.value[0]) + { + xsane.slider_green.value[0] = xsane.slider_green.value[1]-1; + } + + if (xsane.slider_blue.value[1] == 0) + { + xsane.slider_blue.value[1] += 1; + } + if (xsane.slider_blue.value[1] == 100) + { + xsane.slider_blue.value[1] -= 1; + } + if (xsane.slider_blue.value[1] >= xsane.slider_blue.value[2]) + { + xsane.slider_blue.value[2] = xsane.slider_blue.value[1]+1; + } + if (xsane.slider_blue.value[1] <= xsane.slider_blue.value[0]) + { + xsane.slider_blue.value[0] = xsane.slider_blue.value[1]-1; + } + + xsane_enhancement_by_histogram(TRUE); + } + + p->mode = MODE_NORMAL; + + cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW); + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = XSANE_CURSOR_PREVIEW; + } + break; + + case MODE_PIPETTE_BLACK: + { + DBG(DBG_info, "pipette black mode\n"); + + if ( ( (((GdkEventButton *)event)->button == 1) || (((GdkEventButton *)event)->button == 2) ) && + (p->image_data_raw) ) /* left or middle button */ + { + int r=0, g=0, b=0; /* preset color to black */ + + preview_get_color(p, event->button.x, event->button.y, preferences.preview_pipette_range, &r, &g, &b); + + xsane.slider_gray.value[0] = sqrt( (r*r+g*g+b*b) / 3)/2.55; + + if ( (!xsane.enhancement_rgb_default) && (((GdkEventButton *)event)->button == 2) ) /* middle button */ + { + xsane.slider_red.value[0] = r/2.55; + xsane.slider_green.value[0] = g/2.55; + xsane.slider_blue.value[0] = b/2.55; + } + else + { + xsane.slider_red.value[0] = xsane.slider_gray.value[0]; + xsane.slider_green.value[0] = xsane.slider_gray.value[0]; + xsane.slider_blue.value[0] = xsane.slider_gray.value[0]; + } + + if (xsane.slider_gray.value[0] > 98) + { + xsane.slider_gray.value[0] = 98; + } + if (xsane.slider_gray.value[1] <= xsane.slider_gray.value[0]) + { + xsane.slider_gray.value[1] = xsane.slider_gray.value[0]+1; + if (xsane.slider_gray.value[2] <= xsane.slider_gray.value[1]) + { + xsane.slider_gray.value[2] = xsane.slider_gray.value[1]+1; + } + } + + if (xsane.slider_red.value[0] > 98) + { + xsane.slider_red.value[0] = 98; + } + if (xsane.slider_red.value[1] <= xsane.slider_red.value[0]) + { + xsane.slider_red.value[1] = xsane.slider_red.value[0]+1; + if (xsane.slider_red.value[2] <= xsane.slider_red.value[1]) + { + xsane.slider_red.value[2] = xsane.slider_red.value[1]+1; + } + } + + if (xsane.slider_green.value[0] > 98) + { + xsane.slider_green.value[0] = 98; + } + if (xsane.slider_green.value[1] <= xsane.slider_green.value[0]) + { + xsane.slider_green.value[1] = xsane.slider_green.value[0]+1; + if (xsane.slider_green.value[2] <= xsane.slider_green.value[1]) + { + xsane.slider_green.value[2] = xsane.slider_green.value[1]+1; + } + } + + if (xsane.slider_blue.value[0] > 98) + { + xsane.slider_blue.value[0] = 98; + } + if (xsane.slider_blue.value[1] <= xsane.slider_blue.value[0]) + { + xsane.slider_blue.value[1] = xsane.slider_blue.value[0]+1; + if (xsane.slider_blue.value[2] <= xsane.slider_blue.value[1]) + { + xsane.slider_blue.value[2] = xsane.slider_blue.value[1]+1; + } + } + + xsane_enhancement_by_histogram(TRUE); + } + + p->mode = MODE_NORMAL; + + cursor = gdk_cursor_new(XSANE_CURSOR_PREVIEW); + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = XSANE_CURSOR_PREVIEW; + } + break; + + case MODE_NORMAL: + { + DBG(DBG_info, "normal mode\n"); + + if (p->show_selection) + { + switch (((GdkEventButton *)event)->button) + { + case 1: /* left button: define selection area */ + DBG(DBG_info, "left button\n"); + + p->selection_xedge = -1; + if ( (preview_selection[0] - SELECTION_RANGE_OUT < event->button.x) && + (event->button.x < preview_selection[0] + SELECTION_RANGE_IN) ) /* left */ + { + DBG(DBG_info, "-left\n"); + p->selection_xedge = 0; + } + else if ( (preview_selection[2] - SELECTION_RANGE_IN < event->button.x) && + (event->button.x < preview_selection[2] + SELECTION_RANGE_OUT) ) /* right */ + { + DBG(DBG_info, "-right\n"); + p->selection_xedge = 2; + } + + p->selection_yedge = -1; + if ( (preview_selection[1] - SELECTION_RANGE_OUT < event->button.y) && + (event->button.y < preview_selection[1] + SELECTION_RANGE_IN) ) /* top */ + { + DBG(DBG_info, "-top\n"); + p->selection_yedge = 1; + } + else if ( (preview_selection[3] - SELECTION_RANGE_IN < event->button.y) && + (event->button.y < preview_selection[3] + SELECTION_RANGE_OUT) ) /* bottom */ + { + DBG(DBG_info, "-bottom\n"); + p->selection_yedge = 3; + } + + if ( (p->selection_xedge != -1) && (p->selection_yedge != -1) ) /* move corner */ + { + DBG(DBG_info, "-move corner (%f, %f)\n", preview_x, preview_y); + p->selection_drag_edge = TRUE; + p->selection.coordinate[p->selection_xedge] = preview_x; + p->selection.coordinate[p->selection_yedge] = preview_y; + preview_draw_selection(p); + } + else if ( (p->selection_xedge != -1) && (event->button.y > preview_selection[1]) + && (event->button.y < preview_selection[3]) ) /* move x-edge */ + { + DBG(DBG_info, "-move x-edge %f\n", preview_x); + p->selection_drag_edge = TRUE; + p->selection.coordinate[p->selection_xedge] = preview_x; + preview_draw_selection(p); + } + else if ( (p->selection_yedge != -1) && (event->button.x > preview_selection[0]) + && (event->button.x < preview_selection[2]) ) /* move y-edge */ + { + DBG(DBG_info, "-move y-edge %f\n", preview_y); + p->selection_drag_edge = TRUE; + p->selection.coordinate[p->selection_yedge] = preview_y; + preview_draw_selection(p); + } + else /* select new area */ + { + DBG(DBG_info, "-define new area (%f, %f)\n", preview_x, preview_y); + p->selection_xedge = 2; + p->selection_yedge = 3; + p->selection.coordinate[0] = preview_x; + p->selection.coordinate[1] = preview_y; + p->selection_drag = TRUE; + + cursornr = GDK_CROSS; + cursor = gdk_cursor_new(cursornr); /* set curosr */ + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = cursornr; + } + break; + + case 2: /* middle button */ + case 3: /* right button */ + DBG(DBG_info, "middle or right button\n"); + + if ( (preview_selection[0]-SELECTION_RANGE_OUT < event->button.x) && + (preview_selection[2]+SELECTION_RANGE_OUT > event->button.x) && + (preview_selection[1]-SELECTION_RANGE_OUT < event->button.y) && + (preview_selection[3]+SELECTION_RANGE_OUT > event->button.y) ) + { + DBG(DBG_info, "move selection area\n"); + p->selection_drag = TRUE; + p->selection_xpos = event->button.x; + p->selection_ypos = event->button.y; + + cursornr = GDK_HAND2; + cursor = gdk_cursor_new(cursornr); /* set curosr */ + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = cursornr; + } + break; + + default: + break; + } + } + } + } + } + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_button_release_event_handler(GtkWidget *window, GdkEvent *event, gpointer data) +{ + Preview *p = data; + GdkCursor *cursor; + float preview_selection[4]; + int cursornr; + + DBG(DBG_proc, "preview_button_release_event_handler\n"); + + /* preview selection (device) -> cursor-position (window) */ + preview_transform_coordinates_device_to_window(p, p->selection.coordinate, preview_selection); + + if (!p->scanning) + { + if (p->show_selection) + { + switch (((GdkEventButton *)event)->button) + { + case 1: /* left button */ + case 2: /* middle button */ + case 3: /* right button */ + if (p->selection_drag) + { + DBG(DBG_info, "selection finished\n"); + cursornr = XSANE_CURSOR_PREVIEW; + cursor = gdk_cursor_new(cursornr); /* set curosr */ + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = cursornr; + } + + preview_draw_selection(p); + preview_establish_selection(p); + + p->selection_drag_edge = FALSE; + p->selection_drag = FALSE; + break; + + default: + break; + } + } + } + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ +static int expose_event_selection_active, expose_event_selection_maximum_active; + +static gint preview_expose_event_handler_start(GtkWidget *window, GdkEvent *event, gpointer data) +{ + Preview *p = data; + GdkColor color; + GdkColormap *colormap; + + DBG(DBG_proc, "preview_expose_event_handler_start\n"); + + if (event->type == GDK_EXPOSE) + { + if (!p->gc_selection) + { + DBG(DBG_info, "defining line styles for selection and page frames\n"); + colormap = gdk_window_get_colormap(p->window->window); + + p->gc_selection = gdk_gc_new(p->window->window); + gdk_gc_set_function(p->gc_selection, GDK_INVERT); + gdk_gc_set_line_attributes(p->gc_selection, 1, GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER); + + p->gc_selection_maximum = gdk_gc_new(p->window->window); + gdk_gc_set_function(p->gc_selection_maximum, GDK_XOR); + gdk_gc_set_line_attributes(p->gc_selection_maximum, 1, GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER); + + color.red = 0; + color.green = 65535; + color.blue = 30000; + gdk_color_alloc(colormap, &color); + gdk_gc_set_foreground(p->gc_selection_maximum, &color); + } + else + { + expose_event_selection_active = p->selection.active; + expose_event_selection_maximum_active = p->selection_maximum.active; + p->selection_maximum.active = FALSE; + p->selection.active = FALSE; /* do not draw new selections */ + p->selection_maximum.active = FALSE; + preview_draw_selection(p); /* undraw selections */ + } + } + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_expose_event_handler_end(GtkWidget *window, GdkEvent *event, gpointer data) +{ + Preview *p = data; + GdkColor color; + GdkColormap *colormap; + + DBG(DBG_proc, "preview_expose_event_handler_end\n"); + + if (event->type == GDK_EXPOSE) + { + if (!p->gc_selection) + { + DBG(DBG_info, "defining line styles for selection and page frames\n"); + colormap = gdk_window_get_colormap(p->window->window); + + p->gc_selection = gdk_gc_new(p->window->window); + gdk_gc_set_function(p->gc_selection, GDK_INVERT); + gdk_gc_set_line_attributes(p->gc_selection, 1, GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER); + + p->gc_selection_maximum = gdk_gc_new(p->window->window); + gdk_gc_set_function(p->gc_selection_maximum, GDK_XOR); + gdk_gc_set_line_attributes(p->gc_selection_maximum, 1, GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER); + + color.red = 0; + color.green = 65535; + color.blue = 30000; + gdk_color_alloc(colormap, &color); + gdk_gc_set_foreground(p->gc_selection_maximum, &color); + } + else + { + p->selection.active = expose_event_selection_active; + p->selection_maximum.active = expose_event_selection_maximum_active; + preview_draw_selection(p); /* draw selections again */ + } + } + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_start_button_clicked(GtkWidget *widget, gpointer data) +{ + DBG(DBG_proc, "preview_start_button_clicked\n"); + + preview_scan(data); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_cancel_button_clicked(GtkWidget *widget, gpointer data) +{ + Preview *p = (Preview *) data; + + DBG(DBG_proc, "preview_cancel_button_clicked\n"); + + sane_cancel(xsane.dev); + gtk_widget_set_sensitive(p->cancel, FALSE); /* disable cancel button */ + + /* we have to make sure that xsane does detect that the scan has been cancled */ + /* but the select_fd does not make sure that preview_read_image_data is called */ + /* when the select_fd is closed by the backend, so we have to make sure that */ + /* preview_read_image_data is called */ + preview_read_image_data(p, -1, GDK_INPUT_READ); + + p->scan_incomplete = TRUE; + preview_display_valid(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_create_preset_area_menu(Preview *p, int selection) +{ + int i; + GtkWidget *preset_area_menu, *preset_area_item; + + preset_area_menu = gtk_menu_new(); + + for (i = 0; i < preferences.preset_area_definitions; ++i) + { + 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); + gtk_object_set_data(GTK_OBJECT(preset_area_item), "Selection", (void *) i); + gtk_object_set_data(GTK_OBJECT(preset_area_item), "Preview", (void *) p); + + gtk_widget_show(preset_area_item); + } + + gtk_option_menu_set_menu(GTK_OPTION_MENU(p->preset_area_option_menu), preset_area_menu); + gtk_option_menu_set_history(GTK_OPTION_MENU(p->preset_area_option_menu), selection); + + gtk_widget_show(preset_area_menu); + gtk_widget_queue_draw(p->preset_area_option_menu); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_generate_preview_filenames(Preview *p) +{ + char filename[PATH_MAX]; + char buf[256]; + int error_flag = 0; + int i; + + DBG(DBG_proc, "preview_generate_preview_filenames\n"); + + for(i=0; i<=2; i++) /* create random filenames for previews */ + { + if (preview_make_image_path(p, sizeof(filename), filename, i)>=0) + { + FILE *testfile; + + testfile = fopen(filename, "wb"); + if (testfile) + { + fclose(testfile); + p->filename[i] = strdup(filename);/* store filename */ + DBG(DBG_info, "preview file %s created\n", filename); + } + else + { + p->filename[i] = NULL; /* mark filename does not exist */ + DBG(DBG_error, "ERROR: could not create preview file %s\n", filename); + error_flag = 1; + } + } + else + { + DBG(DBG_error, "ERROR: could not create filename for preview level %d\n", i); + p->filename[i] = NULL; + error_flag = 2; + } + } + + if (error_flag == 1) + { + snprintf(buf, sizeof(buf), ERR_CREATE_PREVIEW_FILE); + xsane_back_gtk_error(buf, TRUE); + } + else if (error_flag == 2) + { + snprintf(buf, sizeof(buf), ERR_CREATE_PREVIEW_FILENAME); + xsane_back_gtk_error(buf, TRUE); + } + + return; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +Preview *preview_new(void) +{ + GtkWidget *table, *frame; + GtkSignalFunc signal_func; + GtkWidgetClass *class; + GtkWidget *vbox, *hbox; + GdkCursor *cursor; + GtkWidget *preset_area_option_menu; + GtkWidget *rotation_option_menu, *rotation_menu, *rotation_item; + GtkWidget *delete_images; + GdkBitmap *mask; + GdkPixmap *pixmap = NULL; + Preview *p; + int i; + char buf[256]; + + DBG(DBG_proc, "preview_new\n"); + + p = malloc(sizeof(*p)); + if (!p) + { + return 0; + } + memset(p, 0, sizeof(*p)); + + p->mode = MODE_NORMAL; /* no pipette functions etc */ + p->calibration = 0; /* do not display calibration image */ + p->input_tag = -1; + p->rotation = 0; + p->gamma_functions_interruptable = FALSE; + + p->index_xmin = 0; + p->index_xmax = 2; + p->index_ymin = 1; + p->index_ymax = 3; + + p->max_scanner_surface[0] = -INF; + p->max_scanner_surface[1] = -INF; + p->max_scanner_surface[2] = INF; + p->max_scanner_surface[3] = INF; + + p->scanner_surface[0] = -INF; + p->scanner_surface[1] = -INF; + p->scanner_surface[2] = INF; + p->scanner_surface[3] = INF; + + p->surface[0] = -INF; + p->surface[1] = -INF; + p->surface[2] = INF; + p->surface[3] = INF; + + gtk_preview_set_gamma(1.0); + gtk_preview_set_install_cmap(preferences.preview_own_cmap); + + preview_generate_preview_filenames(p); + + p->preset_surface[0] = 0; + p->preset_surface[1] = 0; + p->preset_surface[2] = INF; + p->preset_surface[3] = INF; + + p->maximum_output_width = INF; /* full output with */ + p->maximum_output_height = INF; /* full output height */ + + p->preview_colors = -1; + p->invalid = TRUE; /* no valid preview */ + +#ifndef XSERVER_WITH_BUGGY_VISUALS + gtk_widget_push_visual(gtk_preview_get_visual()); +#endif + gtk_widget_push_colormap(gtk_preview_get_cmap()); + + snprintf(buf, sizeof(buf), "%s %s", WINDOW_PREVIEW, xsane.device_text); + 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)); + + /* set the main vbox */ + vbox = gtk_vbox_new(FALSE, 0); + gtk_container_set_border_width(GTK_CONTAINER(vbox), 0); + 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 */ + p->button_box = gtk_hbox_new(FALSE, 1); + gtk_container_set_border_width(GTK_CONTAINER(p->button_box), 1); + gtk_box_pack_start(GTK_BOX(vbox), p->button_box, FALSE, FALSE, 0); + + /* 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); + + /* 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_* */ + + 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 */ + gtk_widget_set_sensitive(p->zoom_undo, FALSE); /* no zoom at this point, so no zoom undo */ + gtk_widget_set_sensitive(p->full_area, FALSE); /* no selection */ + gtk_widget_set_sensitive(p->autoselect, FALSE); /* no selection */ + + + /* select maximum scanarea */ + + 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_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 */ + + + /* select rotation */ + 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); + rot = i; + } + else if (i<8) + { + snprintf(buffer, sizeof(buffer), "%03d |", i*90-360); + rot = i; + } + else + { + snprintf(buffer, sizeof(buffer), "%03d -", i*90-2*360); + rot = (((i & 3) + 2) & 3) + 4; + } + rotation_item = gtk_menu_item_new_with_label(buffer); + gtk_container_add(GTK_CONTAINER(rotation_menu), rotation_item); + gtk_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); + } + + 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_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; + + + gtk_widget_show(p->button_box); + + + + /* 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); + + /* 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); + + /* 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); + + /* 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); + + /* 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); + + /* 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)); + + + 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); + + /* 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); + gtk_widget_show(p->valid_pixmap); + gdk_pixmap_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); + gtk_widget_show(p->scanning_pixmap); + gdk_pixmap_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); + gtk_widget_show(p->incomplete_pixmap); + gdk_pixmap_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); + gtk_widget_show(p->invalid_pixmap); + gdk_pixmap_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 */ + + /* 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 */ + 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); + gtk_widget_show(frame); + gtk_widget_show(table); + 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); + p->cursornr = XSANE_CURSOR_PREVIEW; + + gtk_widget_pop_colormap(); +#ifndef XSERVER_WITH_BUGGY_VISUALS + gtk_widget_pop_visual(); +#endif + + preview_update_surface(p, 0); + + preview_display_valid(p); + + return p; +} + + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_area_correct(Preview *p) +{ + float width, height, max_width, max_height; + float aspect; + + DBG(DBG_proc, "preview_area_correct\n"); + + if ( ((p->rotation & 3) == 0) || ((p->rotation & 3) == 2) || (p->calibration) ) + { + aspect = p->aspect; + } + else + { + aspect = 1.0 / p->aspect; + } + + max_width = p->preview_window_width; + max_height = p->preview_window_height; + + width = max_width; + height = width / aspect; + + if (height > max_height) + { + height = max_height; + width = height * aspect; + } + + p->preview_width = width + 0.5; + p->preview_height = height + 0.5; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_update_surface(Preview *p, int surface_changed) +{ + float val; + float width, height; + float rotated_preset_surface[4]; + const SANE_Option_Descriptor *opt; + int i; + SANE_Value_Type type; + SANE_Unit unit; + double min, max; + int expand_surface = 0; + + DBG(DBG_proc, "preview_update_surface\n"); + + unit = SANE_UNIT_PIXEL; + type = SANE_TYPE_INT; + + preview_update_selection(p); /* make sure preview selection is up to date */ + + p->show_selection = FALSE; /* at first let's say we have no corrdinate selection */ + + for (i = 0; i < 4; ++i) /* test if surface (max vals of scanarea) has changed */ + { +/* val = (i & 2) ? INF : -INF; */ + val = (i & 2) ? INF : 0; + + if (xsane.well_known.coord[i] > 0) + { + opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.coord[i]); + assert(opt->unit == SANE_UNIT_PIXEL || opt->unit == SANE_UNIT_MM); + unit = opt->unit; + type = opt->type; + p->show_selection = TRUE; /* ok, we have a coordinate selection */ + + xsane_get_bounds(opt, &min, &max); + + if (i & 2) + { + val = max; + } + else + { + val = min; + } + } + + if (p->orig_scanner_surface[i] != val) + { + DBG(DBG_info, "preview_update_surface: orig_scanner_surface[%d] has changed\n", i); + surface_changed = 2; + p->orig_scanner_surface[i] = val; + } + } + + if (surface_changed == 2) /* redefine all surface subparts */ + { + DBG(DBG_info, "preview_update_surface: rotating surfaces\n"); + + /* max_scanner_surface are the rotated coordinates of orig_scanner_surface */ + preview_rotate_devicesurface_to_previewsurface(p->rotation, p->orig_scanner_surface, p->max_scanner_surface); + + gtk_widget_set_sensitive(p->zoom_not, TRUE); /* allow unzoom */ + gtk_widget_set_sensitive(p->zoom_undo, FALSE); /* forbid undo zoom */ + + expand_surface = 1; + for (i = 0; i < 4; i++) + { + if (p->surface[i] != p->scanner_surface[i]) + { + expand_surface = 0; + } + } + } + else + { + expand_surface = 0; + } + + + /* scanner_surface are the rotated coordinates of the reduced (preset) surface */ + preview_rotate_devicesurface_to_previewsurface(p->rotation, p->preset_surface, rotated_preset_surface); + for (i = 0; i < 4; i++) + { + val = rotated_preset_surface[i]; + + xsane_bound_float(&val, p->max_scanner_surface[i % 2], p->max_scanner_surface[(i % 2) + 2]); + if (val != p->scanner_surface[i]) + { + surface_changed = 1; + p->scanner_surface[i] = val; + + if (expand_surface) + { + p->surface[i] = val; + } + } + DBG(DBG_info, "preview_update_surface: scanner_surface[%d] = %3.2f\n", i, val); + } + + for (i = 0; i < 4; i++) + { + val = p->surface[i]; + + xsane_bound_float(&val, p->scanner_surface[i % 2], p->scanner_surface[(i % 2) + 2]); + if (val != p->surface[i]) + { + surface_changed = 1; + p->surface[i] = val; + } + DBG(DBG_info, "preview_update_surface: surface[%d] = %3.2f\n", i, val); + } + +/* may be we need to define p->old_surface[i] here too */ + + if (p->surface_unit != unit) + { + surface_changed = 1; + p->surface_unit = unit; + } + + if (p->show_selection) + { + 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->full_area, TRUE); /* enable selection buttons */ + gtk_widget_set_sensitive(p->autoselect, TRUE); + } + else + { + 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_out, FALSE); + gtk_widget_set_sensitive(p->zoom_undo, FALSE); + gtk_widget_set_sensitive(p->zoom_not, FALSE); + gtk_widget_set_sensitive(p->full_area, FALSE); /* no selection */ + gtk_widget_set_sensitive(p->autoselect, FALSE); /* no selection */ + } + + if (p->surface_type != type) + { + surface_changed = 1; + p->surface_type = type; + } + + + if (surface_changed) + { + DBG(DBG_info, "preview_update_surface: surface_changed\n"); + /* guess the initial preview window size: */ + + preview_restore_image(p); /* load scanned image */ + + width = p->surface[p->index_xmax] - p->surface[p->index_xmin]; + height = p->surface[p->index_ymax] - p->surface[p->index_ymin]; + + if ( (p->calibration) || (p->startimage) ) /* predefined image should have constant aspect */ + { + p->aspect = fabs(p->image_width/(float) p->image_height); + } + else if (width >= INF || height >= INF) /* undefined size */ + { + p->aspect = 1.0; + } + else /* we have a surface size that can be used to calculate the aspect ratio */ + { + if (((p->rotation & 3) == 0) || ((p->rotation & 3) == 2)) /* 0 or 180 degree */ + { + p->aspect = width/height; + } + else /* 90 or 270 degree */ + { + p->aspect = height/width; + } + } + } +#if 0 + else if ( (p->image_height) && (p->image_width) ) /* we have an image so let´s calculate the correct aspect ratio */ + { + p->aspect = fabs(p->image_width/(float) p->image_height); + } +#endif + + DBG(DBG_info, "preview_update_surface: aspect = %f\n", p->aspect); + + if ( (surface_changed) && (p->preview_window_width == 0) ) /* window is new */ + { + DBG(DBG_info, "preview_update_surface: defining size of preview window\n"); + + 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); + } + else if (surface_changed) /* establish new surface */ + { + DBG(DBG_info, "preview_update_surface: establish new surface\n"); + preview_area_correct(p); /* calculate preview_width and height */ + preview_area_resize(p); /* correct rulers */ + preview_do_gamma_correction(p); /* draw preview */ + xsane_update_histogram(TRUE /* update raw */); + + p->previous_selection.active = FALSE; + p->previous_selection_maximum.active = FALSE; + preview_bound_selection(p); /* make sure selection is not larger than surface */ + preview_draw_selection(p); /* the selection is overpainted, we have to update it */ + preview_establish_selection(p); /* send selection to backend, it may be changed */ + } + else /* leave everything like it is */ + { + DBG(DBG_info, "preview_update_surface: surface unchanged\n"); + preview_update_selection(p); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_scan(Preview *p) +{ + double min, max, swidth, sheight, width, height, dpi = 0; + const SANE_Option_Descriptor *opt; + gint gwidth, gheight; + int i; + float dsurface[4]; + + DBG(DBG_proc, "preview_scan\n"); + + /* we are overpainting the image, so we do not have any visible selections */ + p->previous_selection.active = FALSE; + p->previous_selection_maximum.active = FALSE; + + xsane.block_update_param = TRUE; /* do not change parameters each time */ + + preview_save_option(p, xsane.well_known.dpi, &p->saved_dpi, &p->saved_dpi_valid); + preview_save_option(p, xsane.well_known.dpi_x, &p->saved_dpi_x, &p->saved_dpi_x_valid); + preview_save_option(p, xsane.well_known.dpi_y, &p->saved_dpi_y, &p->saved_dpi_y_valid); + preview_save_option(p, xsane.well_known.scanmode, &p->saved_scanmode, &p->saved_scanmode_valid); + + for (i = 0; i < 4; ++i) + { + preview_save_option(p, xsane.well_known.coord[i], &p->saved_coord[i], p->saved_coord_valid + i); + } + + 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) + { + float aspect; + + if ( ((p->rotation & 3) == 0) || ((p->rotation & 3) == 2) ) + { + aspect = p->aspect; + } + else + { + aspect = 1.0 / p->aspect; + } + + opt = xsane_get_option_descriptor(xsane.dev, xsane.well_known.dpi); + + gwidth = p->preview_width; + gheight = p->preview_height; + + height = gheight; + width = height * aspect; + + if (width > gwidth) + { + width = gwidth; + height = width / aspect; + } + + swidth = fabs(p->surface[xsane_back_gtk_BR_X] - p->surface[xsane_back_gtk_TL_X]); + + if (swidth < INF) + { + dpi = MM_PER_INCH * width/swidth; + } + else + { + sheight = fabs(p->surface[xsane_back_gtk_BR_Y] - p->surface[xsane_back_gtk_TL_Y]); + if (sheight < INF) + { + dpi = MM_PER_INCH * height/sheight; + } + else + { + dpi = 18.0; + } + } + + dpi = dpi * preferences.preview_oversampling; /* faktor for resolution */ + + xsane_get_bounds(opt, &min, &max); + + if (dpi < min) + { + dpi = min; + } + + if (dpi > max) + { + dpi = max; + } + + xsane_set_resolution(xsane.well_known.dpi, dpi); /* set resolution to dpi or next higher value that is available */ + xsane_set_resolution(xsane.well_known.dpi_x, dpi); /* set resolution to dpi or next higher value that is available */ + 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) + { + preview_set_option_float(p, xsane.well_known.coord[i], dsurface[i]); + } + + preview_set_option_val(p, xsane.well_known.preview, SANE_TRUE); + + if ( (xsane.grayscale_scanmode) && (xsane.param.depth == 1) && (xsane.lineart_mode == XSANE_LINEART_GRAYSCALE) ) + { + preview_set_option(p, xsane.well_known.scanmode, xsane.grayscale_scanmode); + } + +#if 0 + if ( (p->saved_bit_depth == 16) && (p->saved_bit_depth_valid) ) /* don't scan with 16 bpp */ + { + preview_set_option_val(p, xsane.well_known.bit_depth, 8); + } +#endif + + xsane.block_update_param = FALSE; + p->preview_colors = xsane.xsane_colors; + p->scan_incomplete = FALSE; + p->invalid = TRUE; /* no valid preview */ + p->scanning = TRUE; + + preview_display_valid(p); + + + xsane_clear_histogram(&xsane.histogram_raw); + xsane_clear_histogram(&xsane.histogram_enh); + + + /* OK, all set to go */ + preview_scan_start(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_save_image_file(Preview *p, FILE *out) +{ + DBG(DBG_proc, "preview_save_image_file\n"); + + if (out) + { + float dsurface[4]; + + preview_rotate_previewsurface_to_devicesurface(p->rotation, p->surface, dsurface); + + /* always save it as a 16 bit PPM image: */ + fprintf(out, "P6\n" + "# surface: %g %g %g %g %u %u\n" + "# time: %d\n" + "%d %d\n65535\n", + dsurface[0], dsurface[1], dsurface[2], dsurface[3], + p->surface_type, p->surface_unit, + (int) time(NULL), + p->image_width, p->image_height); + + fwrite(p->image_data_raw, 6, p->image_width*p->image_height, out); + fclose(out); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_save_image(Preview *p) +{ + FILE *out; + int level=0; + + DBG(DBG_proc, "preview_save_image\n"); + + if (!p->image_data_raw) + { + return; + } + + if ( GROSSLY_EQUAL(p->max_scanner_surface[0], p->surface[0]) && /* full device surface */ + GROSSLY_EQUAL(p->max_scanner_surface[1], p->surface[1]) && + GROSSLY_EQUAL(p->max_scanner_surface[2], p->surface[2]) && + GROSSLY_EQUAL(p->max_scanner_surface[3], p->surface[3]) ) + { + level = 0; + } + else if ( GROSSLY_EQUAL(p->scanner_surface[0], p->surface[0]) && /* user defined surface */ + GROSSLY_EQUAL(p->scanner_surface[1], p->surface[1]) && + GROSSLY_EQUAL(p->scanner_surface[2], p->surface[2]) && + GROSSLY_EQUAL(p->scanner_surface[3], p->surface[3]) ) + { + level = 1; + } + else /* zoom area */ + { + level = 2; + } + + if (p->filename[level]) + { + /* save preview image */ + out = fopen(p->filename[level], "wb"); /* b = binary mode for win32*/ + + preview_save_image_file(p, out); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_delete_images(Preview *p) +{ + FILE *out; + int level=0; + + DBG(DBG_proc, "preview_delete_images_file\n"); + + for (level = 0; level<3; level++) + { + out = fopen(p->filename[level], "wb"); /* b = binary mode for win32*/ + if (out) + fclose(out); + } + preview_update_surface(p, 1); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_destroy(Preview *p) +{ + int level; + + DBG(DBG_proc, "preview_destroy\n"); + + if (p->scanning) + { + preview_scan_done(p, 0); /* don't save partial window */ + } + + for(level = 0; level <= 2; level++) + { + if (p->filename[level]) + { + remove(p->filename[level]); /* remove existing preview */ + } + } + + if (p->image_data_enh) + { + free(p->image_data_enh); + p->image_data_enh = 0; + } + + if (p->image_data_raw) + { + free(p->image_data_raw); + p->image_data_raw = 0; + } + + if (p->preview_row) + { + free(p->preview_row); + p->preview_row = 0; + } + + if (p->gc_selection) + { + gdk_gc_destroy(p->gc_selection); + } + + if (p->gc_selection_maximum) + { + gdk_gc_destroy(p->gc_selection_maximum); + } + + if (p->top) + { + gtk_widget_destroy(p->top); + } + free(p); + + p = 0; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_zoom_not(GtkWidget *window, gpointer data) +{ + Preview *p=data; + int i; + + DBG(DBG_proc, "preview_zoom_not\n"); + + for (i=0; i<4; i++) + { + p->surface[i] = p->scanner_surface[i]; + } + + preview_update_surface(p, 1); + gtk_widget_set_sensitive(p->zoom_not, FALSE); /* forbid unzoom */ + gtk_widget_set_sensitive(p->zoom_out, FALSE); /* forbid zoom out */ + gtk_widget_set_sensitive(p->zoom_undo,TRUE); /* allow zoom undo */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_zoom_out(GtkWidget *window, gpointer data) +{ + Preview *p=data; + int i; + float delta_width; + float delta_height; + + DBG(DBG_proc, "preview_zoom_out\n"); + + for (i=0; i<4; i++) + { + p->old_surface[i] = p->surface[i]; + } + + delta_width = (p->surface[p->index_xmax] - p->surface[p->index_xmin]) * 0.2; + delta_height = (p->surface[p->index_ymax] - p->surface[p->index_ymin]) * 0.2; + + p->surface[p->index_xmin] -= delta_width; + p->surface[p->index_xmax] += delta_width; + p->surface[p->index_ymin] -= delta_height; + p->surface[p->index_ymax] += delta_height; + + if (p->surface[p->index_xmin] < p->scanner_surface[p->index_xmin]) + { + p->surface[p->index_xmin] = p->scanner_surface[p->index_xmin]; + } + + if (p->surface[p->index_ymin] < p->scanner_surface[p->index_ymin]) + { + p->surface[p->index_ymin] = p->scanner_surface[p->index_ymin]; + } + + if (p->surface[p->index_xmax] > p->scanner_surface[p->index_xmax]) + { + p->surface[p->index_xmax] = p->scanner_surface[p->index_xmax]; + } + + if (p->surface[p->index_ymax] > p->scanner_surface[p->index_ymax]) + { + p->surface[p->index_ymax] = p->scanner_surface[p->index_ymax]; + } + + preview_update_surface(p, 1); + gtk_widget_set_sensitive(p->zoom_not, TRUE); /* allow unzoom */ + gtk_widget_set_sensitive(p->zoom_undo,TRUE); /* allow zoom undo */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_zoom_in(GtkWidget *window, gpointer data) +{ + Preview *p=data; + int i; + + DBG(DBG_proc, "preview_zoom_in\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_undo(GtkWidget *window, gpointer data) +{ + Preview *p=data; + int i; + + DBG(DBG_proc, "preview_zoom_undo\n"); + + for (i=0; i<4; i++) + { + p->surface[i] = p->old_surface[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, FALSE); /* forbid zoom undo */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_get_color(Preview *p, int x, int y, int range, int *red, int *green, int *blue) +{ + int image_x, image_y; + int image_x_min, image_y_min; + int image_x_max, image_y_max; + int offset; + int count = 0; + + DBG(DBG_proc, "preview_get_color\n"); + + if (p->image_data_raw) + { + preview_transform_coordinate_window_to_image(p, x, y, &image_x, &image_y); + + if ( (image_x < p->image_width) && (image_y < p->image_height) ) + { + image_x_min = image_x - range/2; + image_y_min = image_y - range/2; + image_x_max = image_x + range/2; + image_y_max = image_y + range/2; + + 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); + + *red = 0; + *green = 0; + *blue = 0; + + for (image_x = image_x_min; image_x <= image_x_max; image_x++) + { + for (image_y = image_y_min; image_y <= image_y_max; image_y++) + { + count++; + + offset = 3 * (image_y * p->image_width + image_x); + + if (!xsane.negative) /* positive */ + { + *red += (p->image_data_raw[offset ]) >> 8; + *green += (p->image_data_raw[offset + 1]) >> 8; + *blue += (p->image_data_raw[offset + 2]) >> 8; + } + else /* negative */ + { + *red += 255 - (p->image_data_raw[offset ] >> 8); + *green += 255 - (p->image_data_raw[offset + 1] >> 8); + *blue += 255 - (p->image_data_raw[offset + 2] >> 8); + } + } + } + + *red /= count; + *green /= count; + *blue /= count; + } + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_pipette_white(GtkWidget *window, gpointer data) +{ + Preview *p=data; + GdkCursor *cursor; + GdkColor fg; + GdkColor bg; + GdkPixmap *pixmap; + GdkPixmap *mask; + + DBG(DBG_proc, "preview_pipette_white\n"); + + p->mode = MODE_PIPETTE_WHITE; + + pixmap = gdk_bitmap_create_from_data(p->top->window, cursor_pipette_white, CURSOR_PIPETTE_WIDTH, CURSOR_PIPETTE_HEIGHT); + mask = gdk_bitmap_create_from_data(p->top->window, cursor_pipette_mask, CURSOR_PIPETTE_WIDTH, CURSOR_PIPETTE_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_PIPETTE_HOT_X, CURSOR_PIPETTE_HOT_Y); + + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = -1; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_pipette_gray(GtkWidget *window, gpointer data) +{ + Preview *p=data; + GdkCursor *cursor; + GdkColor fg; + GdkColor bg; + GdkPixmap *pixmap; + GdkPixmap *mask; + + DBG(DBG_proc, "preview_pipette_gray\n"); + + p->mode = MODE_PIPETTE_GRAY; + + pixmap = gdk_bitmap_create_from_data(p->top->window, cursor_pipette_gray, CURSOR_PIPETTE_WIDTH, CURSOR_PIPETTE_HEIGHT); + mask = gdk_bitmap_create_from_data(p->top->window, cursor_pipette_mask, CURSOR_PIPETTE_WIDTH, CURSOR_PIPETTE_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_PIPETTE_HOT_X, CURSOR_PIPETTE_HOT_Y); + + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = -1; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_pipette_black(GtkWidget *window, gpointer data) +{ + Preview *p=data; + GdkCursor *cursor; + GdkColor fg; + GdkColor bg; + GdkPixmap *pixmap; + GdkPixmap *mask; + + DBG(DBG_proc, "preview_pipette_black\n"); + + p->mode = MODE_PIPETTE_BLACK; + + pixmap = gdk_bitmap_create_from_data(p->top->window, cursor_pipette_black, CURSOR_PIPETTE_WIDTH, CURSOR_PIPETTE_HEIGHT); + mask = gdk_bitmap_create_from_data(p->top->window, cursor_pipette_mask , CURSOR_PIPETTE_WIDTH, CURSOR_PIPETTE_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_PIPETTE_HOT_X, CURSOR_PIPETTE_HOT_Y); + + gdk_window_set_cursor(p->window->window, cursor); + gdk_cursor_destroy(cursor); + p->cursornr = -1; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_select_full_preview_area(Preview *p) +{ + int i; + + DBG(DBG_proc, "preview_select_full_preview_area\n"); + + p->selection.active = TRUE; + + for (i=0; i<4; i++) + { + p->selection.coordinate[i] = p->surface[i]; + } + + preview_update_maximum_output_size(p); + preview_draw_selection(p); + preview_establish_selection(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_full_preview_area_callback(GtkWidget *widget, gpointer call_data) +{ + Preview *p = call_data; + + DBG(DBG_proc, "preview_full_preview_area_callback\n"); + + preview_select_full_preview_area(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_delete_images_callback(GtkWidget *widget, gpointer call_data) +{ + Preview *p = call_data; + + DBG(DBG_proc, "preview_delete_images_callback\n"); + + preview_delete_images(p); + p->invalid = TRUE; + preview_display_valid(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +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"); + p = (Preview *) gtk_object_get_data(GTK_OBJECT(preset_area_widget), "Preview"); + + DBG(DBG_info ,"rename %s\n", preferences.preset_area[selection]->name); + + 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 */ + { + gtk_option_menu_remove_menu(GTK_OPTION_MENU(p->preset_area_option_menu)); + + if (GTK_IS_WIDGET(old_preset_area_menu)) /* the menu normally is closed when we come here */ + { + gtk_widget_destroy(old_preset_area_menu); + } + + free(preferences.preset_area[selection]->name); + preferences.preset_area[selection]->name = strdup(newname); + DBG(DBG_info, "renaming %s to %s\n", oldname, newname); + + preview_create_preset_area_menu(p, old_selection); + } + + free(oldname); + free(newname); + + gtk_widget_destroy(rename_dialog); + + xsane_set_sensitivity(TRUE); + + return TRUE; /* event is handled */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_preset_area_add_callback(GtkWidget *widget, GtkWidget *preset_area_widget) +{ + int selection, i, old_selection = 0; + Preview *p; + GtkWidget *old_preset_area_menu; + + DBG(DBG_proc, "preview_preset_area_add_callback\n"); + + 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]; + + preferences.preset_area = realloc(preferences.preset_area, (preferences.preset_area_definitions+1) * sizeof(void *)); + + /* shift all items after selection */ + for (i = preferences.preset_area_definitions-1; i > selection; i--) + { + 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])); + 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]->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); + + 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); + } + + return TRUE; /* event is handled */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_preset_area_delete_callback(GtkWidget *widget, GtkWidget *preset_area_widget) +{ + int selection, i, old_selection = 0; + Preview *p; + GtkWidget *old_preset_area_menu; + + DBG(DBG_proc, "preview_preset_area_delete_callback\n"); + + 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) /* full size can not be deleted */ + { + DBG(DBG_info ,"deleting %s\n", preferences.preset_area[selection]->name); + + free(preferences.preset_area[selection]); + + for (i=selection; i<preferences.preset_area_definitions-1; i++) + { + preferences.preset_area[i] = preferences.preset_area[i+1]; + } + + 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 deleting the selected surface */ + { + old_selection = 0; + } + else if (old_selection > selection) /* we are deleting the selected surface */ + { + old_selection--; + } + + gtk_widget_destroy(old_preset_area_menu); + + preview_create_preset_area_menu(p, old_selection); /* build menu and set default to 0=full size */ + } + + return TRUE; /* event is handled */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_preset_area_move_up_callback(GtkWidget *widget, GtkWidget *preset_area_widget) +{ + int selection, old_selection = 0; + Preview *p; + GtkWidget *old_preset_area_menu; + + DBG(DBG_proc, "preview_preset_area_move_up_callback\n"); + + 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 > 1) /* make sure "full area" stays at top */ + { + Preferences_preset_area_t *help_area; + + DBG(DBG_info ,"moving up %s\n", preferences.preset_area[selection]->name); + + help_area = preferences.preset_area[selection-1]; + preferences.preset_area[selection-1] = preferences.preset_area[selection]; + preferences.preset_area[selection] = help_area; + + 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) + { + old_selection--; + } + else if (old_selection == selection-1) + { + old_selection++; + } + + gtk_widget_destroy(old_preset_area_menu); + + preview_create_preset_area_menu(p, old_selection); /* build menu and set default to 0=full size */ + } + + return TRUE; /* event is handled */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_preset_area_move_down_callback(GtkWidget *widget, GtkWidget *preset_area_widget) +{ + int selection, old_selection = 0; + Preview *p; + GtkWidget *old_preset_area_menu; + + DBG(DBG_proc, "preview_preset_area_move_down_callback\n"); + + selection = (int) gtk_object_get_data(GTK_OBJECT(preset_area_widget), "Selection"); + p = (Preview *) gtk_object_get_data(GTK_OBJECT(preset_area_widget), "Preview"); + + /* full size can not moved down */ + if ((selection) && (selection < preferences.preset_area_definitions-1)) + { + Preferences_preset_area_t *help_area; + + DBG(DBG_info ,"moving down %s\n", preferences.preset_area[selection]->name); + + help_area = preferences.preset_area[selection]; + preferences.preset_area[selection] = preferences.preset_area[selection+1]; + preferences.preset_area[selection+1] = help_area; + + 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) + { + old_selection++; + } + else if (old_selection == selection+1) + { + old_selection--; + } + + gtk_widget_destroy(old_preset_area_menu); + + preview_create_preset_area_menu(p, old_selection); /* build menu and set default to 0=full size */ + } + + return TRUE; /* event is handled */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static gint preview_preset_area_context_menu_callback(GtkWidget *widget, GdkEvent *event) +{ + GtkWidget *menu; + GtkWidget *menu_item; + GdkEventButton *event_button; + int selection; + + DBG(DBG_proc, "preview_preset_area_context_menu_callback\n"); + + selection = (int) gtk_object_get_data(GTK_OBJECT(widget), "Selection"); + + if (event->type == GDK_BUTTON_PRESS) + { + event_button = (GdkEventButton *) event; + + if (event_button->button == 3) + { + menu = gtk_menu_new(); + + /** add selection */ + 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); + + /* rename preset area */ + menu_item = gtk_menu_item_new_with_label(MENU_ITEM_PRESET_AREA_RENAME); + 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); + + if (selection) /* not available for "full area" */ + { + /* delete preset area */ + menu_item = gtk_menu_item_new_with_label(MENU_ITEM_PRESET_AREA_DELETE); + 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); + } + + if (selection>1) /* available from 3rd item */ + { + /* move up */ + menu_item = gtk_menu_item_new_with_label(MENU_OTEM_PRESET_AREA_MOVE_UP); + 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); + } + + if ((selection) && (selection < preferences.preset_area_definitions-1)) + { + /* move down */ + menu_item = gtk_menu_item_new_with_label(MENU_OTEM_PRESET_AREA_MOVE_DWN); + 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); + } + + 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 */ + } + } + + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_preset_area_callback(GtkWidget *widget, gpointer call_data) +{ + Preview *p = call_data; + int selection; + + DBG(DBG_proc, "preview_preset_area_callback\n"); + + selection = (int) gtk_object_get_data(GTK_OBJECT(widget), "Selection"); + + p->preset_surface[0] = preferences.preset_area[selection]->xoffset; + p->preset_surface[1] = preferences.preset_area[selection]->yoffset; + p->preset_surface[2] = preferences.preset_area[selection]->xoffset + preferences.preset_area[selection]->width; + p->preset_surface[3] = preferences.preset_area[selection]->yoffset + preferences.preset_area[selection]->height; + + gtk_widget_set_sensitive(p->zoom_not, TRUE); /* allow unzoom */ + gtk_widget_set_sensitive(p->zoom_undo, FALSE); /* forbid undo zoom */ + + preview_update_surface(p, 0); + preview_zoom_not(NULL, p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_rotation_callback(GtkWidget *widget, gpointer call_data) +{ + Preview *p = call_data; + float rotated_surface[4]; + int rot; + + DBG(DBG_proc, "preview_rotation_callback\n"); + + rot = (int) gtk_object_get_data(GTK_OBJECT(widget), "Selection"); + + switch (rot) + { + case 0: /* 0 degree */ + default: + p->index_xmin = 0; + p->index_xmax = 2; + p->index_ymin = 1; + p->index_ymax = 3; + break; + + case 1: /* 90 degree */ + p->index_xmin = 2; + p->index_xmax = 0; + p->index_ymin = 1; + p->index_ymax = 3; + break; + + case 2: /* 180 degree */ + p->index_xmin = 2; + p->index_xmax = 0; + p->index_ymin = 3; + p->index_ymax = 1; + break; + + case 3: /* 270 degree */ + p->index_xmin = 0; + p->index_xmax = 2; + p->index_ymin = 3; + p->index_ymax = 1; + break; + + case 4: /* 0 degree, x mirror */ + p->index_xmin = 2; + p->index_xmax = 0; + p->index_ymin = 1; + p->index_ymax = 3; + break; + + case 5: /* 90 degree, x mirror */ + p->index_xmin = 0; + p->index_xmax = 2; + p->index_ymin = 1; + p->index_ymax = 3; + break; + + case 6: /* 180 degree, x mirror */ + p->index_xmin = 0; + p->index_xmax = 2; + p->index_ymin = 3; + p->index_ymax = 1; + break; + + case 7: /* 270 degree, x mirror */ + p->index_xmin = 2; + p->index_xmax = 0; + p->index_ymin = 3; + p->index_ymax = 1; + } + + /* at first undo mirror function, this is necessary because order does matter */ + if (p->rotation & 4) + { + rotated_surface[0] = p->surface[0]; + rotated_surface[1] = p->surface[1]; + rotated_surface[2] = p->surface[2]; + rotated_surface[3] = p->surface[3]; + preview_rotate_devicesurface_to_previewsurface(4, rotated_surface, p->surface); + } + + /* now rotate the selection area and do mirror function (can be done in one step) */ + rotated_surface[0] = p->surface[0]; + rotated_surface[1] = p->surface[1]; + rotated_surface[2] = p->surface[2]; + rotated_surface[3] = p->surface[3]; + preview_rotate_devicesurface_to_previewsurface(( ( (rot & 3) - (p->rotation & 3) ) & 3 ) + /* rotation */ (rot & 4)/* x mirror */, rotated_surface, p->surface); + + p->rotation = rot; + + preview_update_selection(p); /* read selection from backend: correct rotation */ + preview_update_surface(p, 2); /* rotate surfaces */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +static void preview_autoselect_scanarea_callback(GtkWidget *window, gpointer data) +{ + Preview *p=data; + + preview_autoselect_scanarea(p, p->selection.coordinate); /* get autoselection coordinates */ + preview_draw_selection(p); + preview_establish_selection(p); + xsane_update_histogram(TRUE /* update raw */); /* update histogram (necessary because overwritten by preview_update_surface */ +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_do_gamma_correction(Preview *p) +{ + int x,y; + int offset; + u_char *image_data_enhp; + guint16 *image_data_rawp; + int rotate = 16 - preview_gamma_input_bits; + + DBG(DBG_proc, "preview_do_gamma_correction\n"); + + if ((p->image_data_raw) && (p->params.depth > 1) && (preview_gamma_data_red)) + { + if ( (xsane.param.format == SANE_FRAME_RGB) || /* color preview */ + (xsane.param.format == SANE_FRAME_RED) || + (xsane.param.format == SANE_FRAME_GREEN) || + (xsane.param.format == SANE_FRAME_BLUE) ) + { + for (y=0; y < p->image_height; y++) + { + offset = 3 * (y * p->image_width); + + image_data_rawp = p->image_data_raw + offset; + image_data_enhp = p->image_data_enh + offset; + + for (x=0; x < p->image_width; x++) + { + *image_data_enhp++ = preview_gamma_data_red [(*image_data_rawp++) >> rotate]; + *image_data_enhp++ = preview_gamma_data_green[(*image_data_rawp++) >> rotate]; + *image_data_enhp++ = preview_gamma_data_blue [(*image_data_rawp++) >> rotate]; + } + + if (p->gamma_functions_interruptable) + { + while (gtk_events_pending()) + { + DBG(DBG_info, "preview_do_gamma_correction: calling gtk_main_iteration\n"); + gtk_main_iteration(); + } + } + } + } + else /* grayscale preview */ + { + int level; + + for (y=0; y < p->image_height; y++) + { + offset = 3 * (y * p->image_width); + + image_data_rawp = p->image_data_raw + offset; + image_data_enhp = p->image_data_enh + offset; + + for (x=0; x < p->image_width; x++) + { + level = ((*image_data_rawp++) + (*image_data_rawp++) + (*image_data_rawp++)) / 3; + level >>= rotate; + *image_data_enhp++ = preview_gamma_data_red [level]; /* use 12 bit gamma table */ + *image_data_enhp++ = preview_gamma_data_green[level]; + *image_data_enhp++ = preview_gamma_data_blue [level]; + } + + if (p->gamma_functions_interruptable) + { + while (gtk_events_pending()) + { + DBG(DBG_info, "preview_read_image_data (raw): calling gtk_main_iteration\n"); + gtk_main_iteration(); + } + } + } + } + } + + if (p->image_data_enh) + { + preview_display_partial_image(p); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_calculate_raw_histogram(Preview *p, SANE_Int *count_raw, SANE_Int *count_raw_red, SANE_Int *count_raw_green, SANE_Int *count_raw_blue) +{ + int x, y; + int offset; + SANE_Int red_raw, green_raw, blue_raw; + SANE_Int min_x, max_x, min_y, max_y; + float xscale, yscale; + guint16 *image_data_rawp; + + DBG(DBG_proc, "preview_calculate_raw_histogram\n"); + + preview_get_scale_device_to_image(p, &xscale, &yscale); + + switch (p->rotation) + { + case 0: /* 0 degree */ + default: + min_x = (p->selection.coordinate[0] - p->surface[0]) * xscale; + min_y = (p->selection.coordinate[1] - p->surface[1]) * yscale; + max_x = (p->selection.coordinate[2] - p->surface[0]) * xscale; + max_y = (p->selection.coordinate[3] - p->surface[1]) * yscale; + break; + + case 1: /* 90 degree */ + min_x = (p->selection.coordinate[1] - p->surface[1]) * xscale; + min_y = (p->selection.coordinate[2] - p->surface[2]) * xscale; + max_x = (p->selection.coordinate[3] - p->surface[1]) * xscale; + max_y = (p->selection.coordinate[0] - p->surface[2]) * xscale; + break; + + case 2: /* 180 degree */ + min_x = (p->selection.coordinate[2] - p->surface[2]) * xscale; + min_y = (p->selection.coordinate[3] - p->surface[3]) * yscale; + max_x = (p->selection.coordinate[0] - p->surface[2]) * xscale; + max_y = (p->selection.coordinate[1] - p->surface[3]) * yscale; + break; + + case 3: /* 270 degree */ + min_x = (p->selection.coordinate[3] - p->surface[3]) * xscale; + min_y = (p->selection.coordinate[0] - p->surface[0]) * yscale; + max_x = (p->selection.coordinate[1] - p->surface[3]) * xscale; + max_y = (p->selection.coordinate[2] - p->surface[0]) * yscale; + break; + + case 4: /* 0 degree, x mirror */ + min_x = (p->selection.coordinate[2] - p->surface[2]) * xscale; + min_y = (p->selection.coordinate[1] - p->surface[1]) * yscale; + max_x = (p->selection.coordinate[0] - p->surface[2]) * xscale; + max_y = (p->selection.coordinate[3] - p->surface[1]) * yscale; + break; + + case 5: /* 90 degree, x mirror */ + min_x = (p->selection.coordinate[1] - p->surface[1]) * xscale; + min_y = (p->selection.coordinate[0] - p->surface[0]) * yscale; + max_x = (p->selection.coordinate[3] - p->surface[1]) * xscale; + max_y = (p->selection.coordinate[2] - p->surface[0]) * yscale; + break; + + case 6: /* 180 degree, x mirror */ + min_x = (p->selection.coordinate[0] - p->surface[0]) * xscale; + min_y = (p->selection.coordinate[3] - p->surface[3]) * yscale; + max_x = (p->selection.coordinate[2] - p->surface[0]) * xscale; + max_y = (p->selection.coordinate[1] - p->surface[3]) * yscale; + break; + + case 7: /* 270 degree, x mirror */ + min_x = (p->selection.coordinate[3] - p->surface[3]) * xscale; + min_y = (p->selection.coordinate[2] - p->surface[2]) * yscale; + max_x = (p->selection.coordinate[1] - p->surface[3]) * xscale; + max_y = (p->selection.coordinate[0] - p->surface[2]) * yscale; + break; + } + + if (min_x < 0) + { + min_x = 0; + } + + if (max_x >= p->image_width) + { + max_x = p->image_width-1; + } + + if (min_y < 0) + { + min_y = 0; + } + + if (max_y >= p->image_height) + { + max_y = p->image_height-1; + } + + if ((p->image_data_raw) && (p->params.depth > 1) && (preview_gamma_data_red)) + { + for (y = min_y; y <= max_y; y++) + { + offset = 3 * (y * p->image_width + min_x); + image_data_rawp = p->image_data_raw + offset; + + if (!histogram_medium_gamma_data_red) /* no medium gamma table for histogran */ + { + for (x = min_x; x <= max_x; x++) + { + red_raw = (*image_data_rawp++) >> 8; /* reduce from 16 to 8 bits */ + green_raw = (*image_data_rawp++) >> 8; + blue_raw = (*image_data_rawp++) >> 8; + + count_raw [(u_char) ((red_raw + green_raw + blue_raw)/3)]++; + count_raw_red [red_raw]++; + count_raw_green[green_raw]++; + count_raw_blue [blue_raw]++; + } + } + else /* use medium gamma table for raw histogram */ + { + int rotate = 16 - preview_gamma_input_bits; + + for (x = min_x; x <= max_x; x++) + { + red_raw = histogram_medium_gamma_data_red [(*image_data_rawp++) >> rotate]; + green_raw = histogram_medium_gamma_data_green[(*image_data_rawp++) >> rotate]; + blue_raw = histogram_medium_gamma_data_blue [(*image_data_rawp++) >> rotate]; + + count_raw [(u_char) ((red_raw + green_raw + blue_raw)/3)]++; + count_raw_red [red_raw]++; + count_raw_green[green_raw]++; + count_raw_blue [blue_raw]++; + } + } + + if (p->gamma_functions_interruptable) + { + while (gtk_events_pending()) + { + DBG(DBG_info, "preview_calculate_raw_histogram: calling gtk_main_iteration\n"); + gtk_main_iteration(); + } + } + } + } + else /* no preview image => all colors = 1 */ + { + int i; + + for (i = 1; i <= 254; i++) + { + count_raw [i] = 0; + count_raw_red [i] = 0; + count_raw_green[i] = 0; + count_raw_blue [i] = 0; + } + + count_raw [0] = 10; + count_raw_red [0] = 10; + count_raw_green[0] = 10; + count_raw_blue [0] = 10; + + count_raw [255] = 10; + count_raw_red [255] = 10; + count_raw_green[255] = 10; + count_raw_blue [255] = 10; + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_calculate_enh_histogram(Preview *p, SANE_Int *count, SANE_Int *count_red, SANE_Int *count_green, SANE_Int *count_blue) +{ + int x, y; + int offset; + u_char red, green, blue; + SANE_Int min_x, max_x, min_y, max_y; + float xscale, yscale; + guint16 *image_data_rawp; + int rotate = 16 - preview_gamma_input_bits; + + DBG(DBG_proc, "preview_calculate_enh_histogram\n"); + + preview_get_scale_device_to_image(p, &xscale, &yscale); + + switch (p->rotation) + { + case 0: /* 0 degree */ + default: + min_x = (p->selection.coordinate[0] - p->surface[0]) * xscale; + min_y = (p->selection.coordinate[1] - p->surface[1]) * yscale; + max_x = (p->selection.coordinate[2] - p->surface[0]) * xscale; + max_y = (p->selection.coordinate[3] - p->surface[1]) * yscale; + break; + + case 1: /* 90 degree */ + min_x = (p->selection.coordinate[1] - p->surface[1]) * xscale; + min_y = (p->selection.coordinate[2] - p->surface[2]) * xscale; + max_x = (p->selection.coordinate[3] - p->surface[1]) * xscale; + max_y = (p->selection.coordinate[0] - p->surface[2]) * xscale; + break; + + case 2: /* 180 degree */ + min_x = (p->selection.coordinate[2] - p->surface[2]) * xscale; + min_y = (p->selection.coordinate[3] - p->surface[3]) * yscale; + max_x = (p->selection.coordinate[0] - p->surface[2]) * xscale; + max_y = (p->selection.coordinate[1] - p->surface[3]) * yscale; + break; + + case 3: /* 270 degree */ + min_x = (p->selection.coordinate[3] - p->surface[3]) * xscale; + min_y = (p->selection.coordinate[0] - p->surface[0]) * yscale; + max_x = (p->selection.coordinate[1] - p->surface[3]) * xscale; + max_y = (p->selection.coordinate[2] - p->surface[0]) * yscale; + break; + + case 4: /* 0 degree, x mirror */ + min_x = (p->selection.coordinate[2] - p->surface[2]) * xscale; + min_y = (p->selection.coordinate[1] - p->surface[1]) * yscale; + max_x = (p->selection.coordinate[0] - p->surface[2]) * xscale; + max_y = (p->selection.coordinate[3] - p->surface[1]) * yscale; + break; + + case 5: /* 90 degree, x mirror */ + min_x = (p->selection.coordinate[1] - p->surface[1]) * xscale; + min_y = (p->selection.coordinate[0] - p->surface[0]) * yscale; + max_x = (p->selection.coordinate[3] - p->surface[1]) * xscale; + max_y = (p->selection.coordinate[2] - p->surface[0]) * yscale; + break; + + case 6: /* 180 degree, x mirror */ + min_x = (p->selection.coordinate[0] - p->surface[0]) * xscale; + min_y = (p->selection.coordinate[3] - p->surface[3]) * yscale; + max_x = (p->selection.coordinate[2] - p->surface[0]) * xscale; + max_y = (p->selection.coordinate[1] - p->surface[3]) * yscale; + break; + + case 7: /* 270 degree, x mirror */ + min_x = (p->selection.coordinate[3] - p->surface[3]) * xscale; + min_y = (p->selection.coordinate[2] - p->surface[2]) * yscale; + max_x = (p->selection.coordinate[1] - p->surface[3]) * xscale; + max_y = (p->selection.coordinate[0] - p->surface[2]) * yscale; + break; + } + + if (min_x < 0) + { + min_x = 0; + } + + if (max_x >= p->image_width) + { + max_x = p->image_width-1; + } + + if (min_y < 0) + { + min_y = 0; + } + + if (max_y >= p->image_height) + { + max_y = p->image_height-1; + } + + if ((p->image_data_raw) && (p->params.depth > 1) && (preview_gamma_data_red)) + { + for (y = min_y; y <= max_y; y++) + { + offset = 3 * (y * p->image_width + min_x); + image_data_rawp = p->image_data_raw + offset; + + for (x = min_x; x <= max_x; x++) + { + red = histogram_gamma_data_red [(*image_data_rawp++) >> rotate]; + green = histogram_gamma_data_green[(*image_data_rawp++) >> rotate]; + blue = histogram_gamma_data_blue [(*image_data_rawp++) >> rotate]; + + count [(u_char) ((red + green + blue)/3)]++; + count_red [red]++; + count_green[green]++; + count_blue [blue]++; + } + + if (p->gamma_functions_interruptable) + { + while (gtk_events_pending()) + { + DBG(DBG_info, "preview_calculate_enh_histogram: calling gtk_main_iteration\n"); + gtk_main_iteration(); + } + } + } + } + else /* no preview image => all colors = 1 */ + { + int i; + + for (i = 1; i <= 254; i++) + { + count [i] = 0; + count_red [i] = 0; + count_green[i] = 0; + count_blue [i] = 0; + } + + count [0] = 10; + count_red [0] = 10; + count_green[0] = 10; + count_blue [0] = 10; + + count [255] = 10; + count_red [255] = 10; + count_green[255] = 10; + count_blue [255] = 10; + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_gamma_correction(Preview *p, int gamma_input_bits, + u_char *gamma_red, u_char *gamma_green, u_char *gamma_blue, + u_char *gamma_red_hist, u_char *gamma_green_hist, u_char *gamma_blue_hist, + u_char *medium_gamma_red_hist, u_char *medium_gamma_green_hist, u_char *medium_gamma_blue_hist) +{ + DBG(DBG_proc, "preview_gamma_correction\n"); + + preview_gamma_data_red = gamma_red; + preview_gamma_data_green = gamma_green; + preview_gamma_data_blue = gamma_blue; + + histogram_gamma_data_red = gamma_red_hist; + histogram_gamma_data_green = gamma_green_hist; + histogram_gamma_data_blue = gamma_blue_hist; + + histogram_medium_gamma_data_red = medium_gamma_red_hist; + histogram_medium_gamma_data_green = medium_gamma_green_hist; + histogram_medium_gamma_data_blue = medium_gamma_blue_hist; + + preview_gamma_input_bits = gamma_input_bits; + + preview_do_gamma_correction(p); + preview_draw_selection(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_area_resize(Preview *p) +{ + float min_x, max_x, delta_x; + float min_y, max_y, delta_y; + float xscale, yscale; + + DBG(DBG_proc, "preview_area_resize\n"); + + p->preview_window_width = p->window->allocation.width; + p->preview_window_height = p->window->allocation.height; + + p->preview_width = p->window->allocation.width; + p->preview_height = p->window->allocation.height; + + preview_area_correct(p); /* set preview dimensions (with right aspect) that it fits into the window */ + + if (p->preview_row) /* make sure preview_row is large enough for one line of the new size */ + { + p->preview_row = realloc(p->preview_row, 3 * p->preview_window_width); + } + else + { + p->preview_row = malloc(3 * p->preview_window_width); + } + + /* set the ruler ranges: */ + + min_x = p->surface[xsane_back_gtk_TL_X]; + max_x = p->surface[xsane_back_gtk_BR_X]; + min_y = p->surface[xsane_back_gtk_TL_Y]; + max_y = p->surface[xsane_back_gtk_BR_Y]; + + + if (min_x <= -INF) + { + min_x = 0.0; + } + if (min_x >= INF) + { + min_x = p->image_width - 1; + } + + if (max_x <= -INF) + { + max_x = 0.0; + } + if (max_x >= INF) + { + max_x = p->image_width - 1; + } + + if (min_y <= -INF) + { + min_y = 0.0; + } + if (min_y >= INF) + { + min_y = p->image_height - 1; + } + + if (max_y <= -INF) + { + max_y = 0.0; + } + if (max_y >= INF) + { + max_y = p->image_height - 1; + } + + /* convert mm to inches if that's what the user wants: */ + + if (p->surface_unit == SANE_UNIT_MM) + { + double factor = 1.0/preferences.length_unit; + + min_x *= factor; + max_x *= factor; + min_y *= factor; + max_y *= factor; + } + + preview_get_scale_window_to_image(p, &xscale, &yscale); + + delta_x = max_x - min_x; + + gtk_ruler_set_range(GTK_RULER(p->hruler), min_x, min_x + delta_x*p->preview_window_width/p->preview_width, min_x, /* max_size */ 20); + + delta_y = max_y - min_y; + + gtk_ruler_set_range(GTK_RULER(p->vruler), min_y, min_y + delta_y*p->preview_window_height/p->preview_height, min_y, /* max_size */ 20); + + gtk_label_set_text(GTK_LABEL(p->unit_label), xsane_back_gtk_unit_string(p->surface_unit)); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +gint preview_area_resize_handler(GtkWidget *widget, GdkEvent *event, gpointer data) +{ + Preview *p = (Preview *) data; + DBG(DBG_proc, "preview_area_resize_handler\n"); + + preview_area_resize(p); + preview_paint_image(p); + return FALSE; +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ +#if 0 +void preview_update_maximum_output_size(Preview *p) +{ + DBG(DBG_proc, "preview_update_maximum_output_size\n"); + + if ( (p->maximum_output_width >= INF) || (p->maximum_output_height >= INF) ) + { + if (p->selection_maximum.active) + { + p->selection_maximum.active = FALSE; + } + } + else + { + 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]) + { + p->selection_maximum.coordinate[0] = p->max_scanner_surface[0]; + } + + if (p->selection_maximum.coordinate[1] < p->max_scanner_surface[1]) + { + p->selection_maximum.coordinate[1] = p->max_scanner_surface[1]; + } + + if (p->selection_maximum.coordinate[2] > p->max_scanner_surface[2]) + { + p->selection_maximum.coordinate[2] = p->max_scanner_surface[2]; + } + + if (p->selection_maximum.coordinate[3] > p->max_scanner_surface[3]) + { + p->selection_maximum.coordinate[3] = p->max_scanner_surface[3]; + } + + 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]) ) + { + if (p->selection.coordinate[0] < p->selection_maximum.coordinate[0]) + { + p->selection.coordinate[0] = p->selection_maximum.coordinate[0]; + } + + if (p->selection.coordinate[1] < p->selection_maximum.coordinate[1]) + { + p->selection.coordinate[1] = p->selection_maximum.coordinate[1]; + } + + if (p->selection.coordinate[2] > p->selection_maximum.coordinate[2]) + { + p->selection.coordinate[2] = p->selection_maximum.coordinate[2]; + } + + if (p->selection.coordinate[3] > p->selection_maximum.coordinate[3]) + { + p->selection.coordinate[3] = p->selection_maximum.coordinate[3]; + } + preview_draw_selection(p); + preview_establish_selection(p); + } + } +} +#endif + +void preview_update_maximum_output_size(Preview *p) +{ + if ( (p->maximum_output_width >= INF) || (p->maximum_output_height >= INF) ) + { + if (p->selection_maximum.active) + { + p->selection_maximum.active = FALSE; + } + } + 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; + + if (p->selection_maximum.coordinate[p->index_xmax] > p->max_scanner_surface[p->index_xmax]) + { + p->selection_maximum.coordinate[p->index_xmax] = p->max_scanner_surface[p->index_xmax]; + } + + if (p->selection_maximum.coordinate[p->index_ymax] > p->max_scanner_surface[p->index_ymax]) + { + p->selection_maximum.coordinate[p->index_ymax] = p->max_scanner_surface[p->index_ymax]; + } + + 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[p->index_xmax] > p->selection_maximum.coordinate[p->index_xmax]) + { + p->selection.coordinate[p->index_xmax] = p->selection_maximum.coordinate[p->index_xmax]; + } + + if (p->selection.coordinate[p->index_ymax] > p->selection_maximum.coordinate[p->index_ymax]) + { + p->selection.coordinate[p->index_ymax] = p->selection_maximum.coordinate[p->index_ymax]; + } + 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_update_maximum_output_size(p); + preview_draw_selection(p); +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_autoselect_scanarea(Preview *p, float *autoselect_coord) +{ + int x, y; + int offset; + float color; + int top, bottom, left, right; + float xscale, yscale; + long bright_sum = 0; + int brightness; + int background_white; + + DBG(DBG_proc, "preview_autoselect_scanarea\n"); + + /* try to find out background color */ + /* add color values at the margins */ + /* and see if it is more black or more white */ + + /* upper line */ + for (x = 0; x < p->image_width; x++) + { + offset = 3 * x; + bright_sum += (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + } + + /* lower line */ + for (x = 0; x < p->image_width; x++) + { + offset = 3 * ( (p->image_height-1) * p->image_width + x); + bright_sum += (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + } + + /* left line */ + for (y = 0; y < p->image_height; y++) + { + offset = 3 * y * p->image_width; + bright_sum += (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + } + + /* right line */ + for (y = 0; y < p->image_height; y++) + { + offset = 3 * (y * p->image_width + p->image_width - 1); + bright_sum += (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + } + + brightness = bright_sum / (2 * (p->image_width + p->image_height) ); + DBG(DBG_info, "preview_autoselect_scanarea: average margin brightness is %d\n", brightness); + + if ( brightness > 128 ) + { + DBG(DBG_info, "preview_autoselect_scanarea: background is white\n"); + background_white = 1; + } + else + { + DBG(DBG_info, "preview_autoselect_scanarea: background is black\n"); + background_white = 0; + } + + + /* search top */ + top = 0; + for (y = 0; y < p->image_height; y++) + { + for (x = 0; x < p->image_width; x++) + { + offset = 3 * (y * p->image_width + x); + color = (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + if (background_white) + { + if (color < 200) + { + top = y; + break; + } + } + + else if (color > 55 ) + { + top = y; + break; + } + } + if (top) + { + break; + } + } + + + /* search bottom */ + bottom = 0; + for (y = p->image_height-1; y > top; y--) + { + for (x = 0; x < p->image_width; x++) + { + offset = 3 * (y * p->image_width + x); + color = (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + if (background_white) + { + if (color < 200) + { + bottom = y; + break; + } + } + else if (color > 55 ) + { + bottom = y; + break; + } + } + if (bottom) + { + break; + } + } + + + /* search left */ + left = 0; + for (x = 0; x < p->image_width; x++) + { + for (y = 0; y < p->image_height; y++) + { + offset = 3 * (y * p->image_width + x); + color = (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + if (background_white) + { + if (color < 200) + { + left = x; + break; + } + } + else if (color > 55 ) + { + left = x; + break; + } + } + if (left) + { + break; + } + } + + + /* search right */ + right = 0; + for (x = p->image_width-1; x > left; x--) + { + for (y = 0; y < p->image_height; y++) + { + offset = 3 * (y * p->image_width + x); + color = (p->image_data_enh[offset + 0] + p->image_data_enh[offset + 1] + p->image_data_enh[offset + 2]) / 3.0; + if (background_white) + { + if (color < 200) + { + right = x; + break; + } + } + else if (color > 55 ) + { + right = x; + break; + } + } + if (right) + { + break; + } + } + + preview_get_scale_device_to_image(p, &xscale, &yscale); + + 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; + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ + +void preview_display_valid(Preview *p) +{ + DBG(DBG_proc, "preview_display_valid\n"); + + if (p->scanning)/* we are just scanning the preview */ + { + DBG(DBG_info, "preview scanning\n"); + + gtk_widget_show(p->scanning_pixmap); + gtk_widget_hide(p->incomplete_pixmap); + gtk_widget_hide(p->valid_pixmap); + gtk_widget_hide(p->invalid_pixmap); + } + else if ((xsane.medium_changed) || (xsane.xsane_colors != p->preview_colors) || (p->invalid) ) /* preview is not valid */ + { + DBG(DBG_info, "preview not vaild\n"); + + gtk_widget_show(p->invalid_pixmap); + gtk_widget_hide(p->scanning_pixmap); + gtk_widget_hide(p->incomplete_pixmap); + gtk_widget_hide(p->valid_pixmap); + } + else if (p->scan_incomplete)/* preview scan has been cancled */ + { + DBG(DBG_info, "preview incomplete\n"); + + gtk_widget_show(p->incomplete_pixmap); + gtk_widget_hide(p->scanning_pixmap); + gtk_widget_hide(p->valid_pixmap); + gtk_widget_hide(p->invalid_pixmap); + } + else /* preview is valid */ + { + DBG(DBG_info, "preview vaild\n"); + + gtk_widget_show(p->valid_pixmap); + gtk_widget_hide(p->scanning_pixmap); + gtk_widget_hide(p->incomplete_pixmap); + gtk_widget_hide(p->invalid_pixmap); + } +} + +/* ---------------------------------------------------------------------------------------------------------------------- */ |