mirror
/
sane-project-frontends
kopia lustrzana https://gitlab.com/sane-project/frontends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Migrate to gtk3

merge-requests/6/head
Ordissimo 2022-05-13 13:52:43 +02:00
rodzic 9d087040c2
commit 58527b3cf6
8 zmienionych plików z 236 dodań i 222 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

63
src/gtkglue.c
Wyświetl plik

@ -86,7 +86,7 @@ unit_string (SANE_Unit unit)
}
static void
set_tooltip (GtkTooltips * tooltips, GtkWidget * widget, const char *desc)
set_tooltip (GtkTooltip * tooltips, GtkWidget * widget, const char *desc)
{
/*
if (desc && desc[0])
@ -248,13 +248,13 @@ gsg_message (gchar * title, gchar * message)
return;
}
gsg_message_dialog_active = 1;
message_dialog = gtk_window_new ();
message_dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (message_dialog), title);
/* create the main vbox */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous (GTK_BOX (main_vbox), TRUE);
gtk_container_border_width (GTK_CONTAINER (main_vbox), 5);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5);
gtk_widget_show (main_vbox);
gtk_container_add (GTK_CONTAINER (message_dialog), main_vbox);
@ -295,8 +295,8 @@ gsg_get_filename (const char *label, const char *default_name,
GtkWidget *filesel;
filesel = gtk_file_chooser_dialog_new ((char*) label, NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
"Ok", GTK_RESPONSE_ACCEPT,
"Cancel", GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_modal (GTK_WINDOW (filesel), TRUE);
@ -305,7 +305,7 @@ gsg_get_filename (const char *label, const char *default_name,
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filesel),
(char *) default_name);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
if (gtk_dialog_run (GTK_DIALOG (filesel)) == GTK_RESPONSE_ACCEPT)
{
size_t len, cwd_len;
char *cwd;
@ -359,7 +359,7 @@ autobutton_update (GtkWidget * widget, GSGDialogElement * elem)
static void
autobutton_new (GtkWidget * parent, GSGDialogElement * elem,
GtkWidget * label, GtkTooltips * tooltips)
GtkWidget * label, GtkTooltip * tooltips)
{
GtkWidget *button;
@ -393,14 +393,14 @@ button_update (GtkWidget * widget, GSGDialogElement * elem)
static void
button_new (GtkWidget * parent, const char *name, SANE_Word val,
GSGDialogElement * elem, GtkTooltips * tooltips, const char *desc,
GSGDialogElement * elem, GtkTooltip * tooltips, const char *desc,
gint is_settable)
{
GtkWidget *button;
button = gtk_check_button_new_with_label ((char *) name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), val);
gtk_signal_connect (G_OBJECT (button), "toggled",
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (button_update), elem);
gtk_box_pack_start (GTK_BOX (parent), button, FALSE, TRUE, 0);
if (!is_settable)
@ -431,11 +431,11 @@ scale_update (GtkAdjustment * adj_data, GSGDialogElement * elem)
switch (opt->type)
{
case SANE_TYPE_INT:
val = adj_data->value + 0.5;
val = gtk_adjustment_get_value (adj_data) + 0.5;
break;
case SANE_TYPE_FIXED:
d = adj_data->value;
d = gtk_adjustment_get_value (adj_data);
if (opt->unit == SANE_UNIT_MM)
d *= preferences.length_unit;
val = SANE_FIX (d);
@ -467,14 +467,14 @@ value_changed:
switch (opt->type)
{
case SANE_TYPE_INT:
adj_data->value = val;
gtk_adjustment_set_value (adj_data, val);
break;
case SANE_TYPE_FIXED:
d = SANE_UNFIX (val);
if (opt->unit == SANE_UNIT_MM)
d /= preferences.length_unit;
adj_data->value = d;
gtk_adjustment_set_value (adj_data, d);
break;
default:
@ -483,14 +483,14 @@ value_changed:
/* Let widget know that value changed _again_. This must converge
quickly---otherwise things would get very slow very quickly (as
in "infinite recursion"): */
g_signal_emit (G_OBJECT (adj_data), "value_changed", 0);
g_signal_emit (G_OBJECT (adj_data), 1 /*"value_changed"*/, 0);
return;
}
static void
scale_new (GtkWidget * parent, const char *name, gfloat val,
gfloat min, gfloat max, gfloat quant, int automatic,
GSGDialogElement * elem, GtkTooltips * tooltips, const char *desc,
GSGDialogElement * elem, GtkTooltip * tooltips, const char *desc,
gint is_settable)
{
GtkWidget *hbox, *label, *scale;
@ -503,11 +503,12 @@ scale_new (GtkWidget * parent, const char *name, gfloat val,
label = gtk_label_new ((char *) name);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
elem->data = gtk_adjustment_new (val, min, max, quant, 1.0, 0.0);
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
GTK_ADJUSTMENT (elem->data));
// elem->data = gtk_adjustment_new (val, min, max, quant, 1.0, 0.0);
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, min, max, quant);
elem->data = gtk_range_get_adjustment (GTK_RANGE (scale));
gtk_scale_set_value_pos (GTK_SCALE (scale), val);
set_tooltip (tooltips, scale, desc);
gtk_widget_set_usize (scale, 200, 0);
gtk_widget_set_size_request (scale, 200, 0);
if (automatic)
autobutton_new (hbox, elem, scale, tooltips);
@ -590,7 +591,7 @@ static void option_menu_callback (GtkWidget * widget, gpointer data)
set_option (dialog, opt_num, valp, SANE_ACTION_SET_VALUE);
}
static void option_menu_new (GtkWidget * parent, const char *name, char *str_list[], const char *val, GSGDialogElement * elem, GtkTooltips * tooltips, const char *desc, gint is_settable)
static void option_menu_new (GtkWidget * parent, const char *name, char *str_list[], const char *val, GSGDialogElement * elem, GtkTooltip * tooltips, const char *desc, gint is_settable)
{
GtkWidget *hbox, *label, *option_menu, *menu, *item;
GSGMenuItem *menu_items;
@ -602,10 +603,10 @@ static void option_menu_new (GtkWidget * parent, const char *name, char *str_lis
label = gtk_label_new ((char *) name);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
for (num_items = 0; str_list[num_items]; ++num_items);
option_menu = gtk_combo_box_text_new ()
option_menu = gtk_combo_box_text_new ();
for (i = 0; i < num_items; ++i)
{
gtk_combo_box_append_text (GTK_COMBO_BOX (option_menu), str_list[i]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), str_list[i]);
if (val && !strcmp(str_list[i], val))
selected = i;
}
@ -638,7 +639,7 @@ text_entry_callback (GtkWidget * w, gpointer data)
buf = alloca (opt->size);
buf[0] = '\0';
text = gtk_editable_get_text (GTK_EDITABLE (elem->widget));
text = gtk_entry_get_text (GTK_ENTRY (elem->widget));
if (text)
strncpy (buf, text, opt->size);
buf[opt->size - 1] = '\0';
@ -647,13 +648,13 @@ text_entry_callback (GtkWidget * w, gpointer data)
if (strcmp (buf, text) != 0)
/* the backend modified the option value; update widget: */
gtk_editable_set_text (GTK_EDITABLE (elem->widget), buf);
gtk_entry_set_text (GTK_ENTRY (elem->widget), buf);
}
static void
text_entry_new (GtkWidget * parent, const char *name, const char *val,
GSGDialogElement * elem,
GtkTooltips * tooltips, const char *desc, gint is_settable)
GtkTooltip * tooltips, const char *desc, gint is_settable)
{
GtkWidget *hbox, *text, *label;
@ -665,7 +666,7 @@ text_entry_new (GtkWidget * parent, const char *name, const char *val,
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
text = gtk_entry_new ();
gtk_editable_set_text (GTK_EDITABLE (text), (char *) val);
gtk_entry_set_text (GTK_ENTRY (text), (char *) val);
gtk_box_pack_start (GTK_BOX (hbox), text, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (text), "changed",
G_CALLBACK (text_entry_callback), elem);
@ -689,10 +690,10 @@ group_new (GtkWidget * parent, const char *title)
// gtk_container_border_width (GTK_CONTAINER (frame), 4);
gtk_box_pack_start (GTK_BOX (parent), frame, FALSE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICTAL, 4);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_frame_set_child (GTK_FRAME (frame), vbox);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
return vbox;
}
@ -800,7 +801,7 @@ vector_new (GSGDialog * dialog, GtkWidget * vbox, int num_vopts, int *vopts)
opt = sane_get_option_descriptor (dialog->dev, vopts[i]);
label = gtk_label_new ((char *) opt->title);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICTAL, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
gtk_widget_show (vbox);
@ -911,7 +912,7 @@ panel_build (GSGDialog * dialog)
gsg_set_tooltips (dialog, preferences.tooltips_enabled);
*/
gtk_window_set_child (GTK_WINDOW (dialog->window), main_hbox);
gtk_container_add (GTK_CONTAINER (dialog->window), main_hbox);
dialog->main_hbox = main_hbox;
dialog->advanced_vbox = advanced_vbox;
@ -1334,7 +1335,7 @@ gsg_update_scan_window (GSGDialog * dialog)
GTK_ADJUSTMENT (elem->data)->value = new_val;
}
if (old_val != new_val)
gtk_signal_emit_by_name (GTK_OBJECT (elem->data),
gtk_signal_emit_by_name (G_OBJECT (elem->data),
"value_changed");
break;

8
src/gtkglue.h
Wyświetl plik

@ -1,5 +1,5 @@
#ifndef gtkglue_h
#define gtkglue_h
#ifndef __GTKGLUE_H__
#define __GTKGLUE_H__
#include <sys/types.h>
@ -44,7 +44,7 @@ typedef struct GSGDialogElement
struct GSGDialog *dialog; /* wasteful, but is there a better solution? */
GtkWidget *automatic; /* auto button for options that support this */
GtkWidget *widget;
GtkObject *data;
GtkAdjustment *data;
int menu_size; /* # of items in menu (if any) */
GSGMenuItem *menu;
}
@ -56,7 +56,7 @@ typedef struct GSGDialog
GtkWidget *main_hbox;
GtkWidget *advanced_vbox;
int twocolumn;
GtkTooltips *tooltips;
GtkTooltip *tooltips;
GdkColor tooltips_fg;
GdkColor tooltips_bg;
SANE_Handle *dev;

154
src/preview.c
Wyświetl plik

@ -112,6 +112,8 @@
#endif
/* forward declarations */
/*
static void scan_start (Preview * p);
static void scan_done (Preview * p);
@ -141,7 +143,7 @@ static void
draw_selection (Preview * p)
{
if (!p->gc)
/* window isn't mapped yet */
// window isn't mapped yet
return;
if (p->previous_selection.active)
@ -251,12 +253,12 @@ paint_image (Preview * p)
memset (p->preview_row, 0xff, 3 * gwidth);
/* don't draw last line unless it's complete: */
// don't draw last line unless it's complete:
height = p->image_y;
if (p->image_x == 0 && height < p->image_height)
++height;
/* for now, use simple nearest-neighbor interpolation: */
// for now, use simple nearest-neighbor interpolation:
src_offset = 0;
src_x = src_y = 0.0;
for (dst_y = 0; dst_y < gheight; ++dst_y)
@ -339,7 +341,7 @@ preview_area_resize (GtkWidget * widget)
float min_x, max_x, min_y, max_y, xscale, yscale, f;
Preview *p;
p = gtk_object_get_data (GTK_OBJECT (widget), "PreviewPointer");
p = gtk_object_get_data (G_OBJECT (widget), "PreviewPointer");
p->preview_width = widget->allocation.width;
p->preview_height = widget->allocation.height;
@ -349,7 +351,7 @@ preview_area_resize (GtkWidget * widget)
else
p->preview_row = malloc (3 * p->preview_width);
/* set the ruler ranges: */
// set the ruler ranges:
min_x = p->surface[GSG_TL_X];
if (min_x <= -INF)
@ -367,7 +369,7 @@ preview_area_resize (GtkWidget * widget)
if (max_y >= INF)
max_y = p->preview_height - 1;
/* convert mm to inches if that's what the user wants: */
// convert mm to inches if that's what the user wants:
if (p->surface_unit == SANE_UNIT_MM)
{
@ -387,7 +389,7 @@ preview_area_resize (GtkWidget * widget)
else
f = 1.0;
gtk_ruler_set_range (GTK_RULER (p->hruler), f * min_x, f * max_x, f * min_x,
/* max_size */ 20);
20); // max_size
if (p->surface_unit == SANE_UNIT_PIXEL)
f = 1.0 / yscale;
@ -396,7 +398,7 @@ preview_area_resize (GtkWidget * widget)
else
f = 1.0;
gtk_ruler_set_range (GTK_RULER (p->vruler), f * min_y, f * max_y, f * min_y,
/* max_size */ 20);
20); // max_size
paint_image (p);
update_selection (p);
@ -610,7 +612,7 @@ input_available (gpointer data, gint source, GdkInputCondition cond)
scan_done (p);
return;
}
if (!len) /* out of data for now */
if (!len) // out of data for now
{
if (p->input_tag < 0)
{
@ -708,7 +710,7 @@ input_available (gpointer data, gint source, GdkInputCondition cond)
{
if (increment_image_y (p) < 0)
return;
break; /* skip padding bits */
break; // skip padding bits
}
}
}
@ -873,7 +875,7 @@ scan_start (Preview * p)
gsg_set_sensitivity (p->dialog, FALSE);
gtk_widget_set_sensitive (p->dialog->window->parent->parent->parent, FALSE);
/* clear old preview: */
// clear old preview:
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,
@ -908,7 +910,7 @@ scan_start (Preview * p)
#ifdef HAVE_SYS_TIME_H
gettimeofday (&current, NULL);
/* we assume that warming up won't exceed 60 seconds */
// we assume that warming up won't exceed 60 seconds
progress_update (progress,
(current.tv_sec - start.tv_sec) / (gfloat) 60);
#endif
@ -919,7 +921,7 @@ scan_start (Preview * p)
}
progress_free (progress);
}
#endif /* SANE_STATUS_WARMING_UP */
#endif // SANE_STATUS_WARMING_UP
if (status != SANE_STATUS_GOOD)
{
snprintf (buf, sizeof (buf),
@ -959,14 +961,14 @@ scan_start (Preview * p)
if (!p->image_data || p->params.pixels_per_line != p->image_width
|| (p->params.lines >= 0 && p->params.lines != p->image_height))
{
/* image size changed */
// image size changed
if (p->image_data)
free (p->image_data);
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... */
p->image_height = 32; // may have to adjust as we go...
p->image_data = malloc (p->image_width * p->image_height * 3);
if (!p->image_data)
@ -1045,7 +1047,7 @@ restore_preview_image (Preview * p)
size_t nread;
FILE *in;
/* See whether there is a saved preview and load it if present: */
// See whether there is a saved preview and load it if present:
if (make_preview_image_path (p, sizeof (filename), filename) < 0)
return;
@ -1054,8 +1056,8 @@ restore_preview_image (Preview * p)
if (!in)
return;
/* Be careful about consuming too many bytes after the final newline
(e.g., consider an image whose first image byte is 13 (`\r'). */
// Be careful about consuming too many bytes after the final newline
// (e.g., consider an image whose first image byte is 13 (`\r').
if (fscanf (in, "P6\n# surface: %g %g %g %g %u %u\n%d %d\n255%*[\n]",
psurface + 0, psurface + 1, psurface + 2, psurface + 3,
&psurface_type, &psurface_unit, &width, &height) != 8)
@ -1066,7 +1068,7 @@ restore_preview_image (Preview * p)
|| GROSSLY_DIFFERENT (psurface[2], p->surface[2])
|| GROSSLY_DIFFERENT (psurface[3], p->surface[3])
|| psurface_type != p->surface_type || psurface_unit != p->surface_unit)
/* ignore preview image that was acquired for/with a different surface */
// ignore preview image that was acquired for/with a different surface
return;
p->image_width = width;
@ -1083,7 +1085,7 @@ restore_preview_image (Preview * p)
p->image_x = nread % width;
}
/* This is executed _after_ the gtkpreview's expose routine. */
// This is executed _after_ the gtkpreview's expose routine.
static gint
expose_handler (GtkWidget * window, GdkEvent * event, gpointer data)
{
@ -1201,13 +1203,14 @@ top_destroyed (GtkWidget * widget, gpointer call_data)
p->top = NULL;
}
*/
Preview *
preview_new (GSGDialog * dialog)
{
/*
static int first_time = 1;
GtkWidget *table, *frame;
GtkSignalFunc signal_func;
GCallback signal_func;
GtkWidgetClass *class;
GtkBox *vbox, *hbox;
Preview *p;
@ -1233,37 +1236,36 @@ preview_new (GSGDialog * dialog)
gtk_widget_push_colormap (gtk_preview_get_cmap ());
p->top = gtk_dialog_new ();
gtk_signal_connect (GTK_OBJECT (p->top), "destroy",
GTK_SIGNAL_FUNC (top_destroyed), p);
g_signal_connect (G_OBJECT (p->top), "destroy",
G_CALLBACK (top_destroyed), p);
gtk_window_set_title (GTK_WINDOW (p->top), "xscanimage preview");
vbox = GTK_BOX (GTK_DIALOG (p->top)->vbox);
hbox = GTK_BOX (GTK_DIALOG (p->top)->action_area);
/* construct the preview area (table with sliders & preview window) */
table = gtk_table_new (2, 2, /* homogeneous */ FALSE);
// construct the preview area (table with sliders & preview window)
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
gtk_container_border_width (GTK_CONTAINER (table), 2);
gtk_box_pack_start (vbox, table, /* expand */ TRUE, /* fill */ TRUE,
/* padding */ 0);
gtk_box_pack_start (vbox, table, TRUE, TRUE, 0);
/* the empty box in the top-left corner */
frame = gtk_frame_new ( /* label */ 0);
// the empty box in the top-left corner
frame = gtk_frame_new ( 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 horizontal ruler */
// 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 */
// 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 */
// the preview area
p->window = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_set_expand (GTK_PREVIEW (p->window), TRUE);
@ -1272,36 +1274,36 @@ preview_new (GSGDialog * dialog)
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_signal_connect (GTK_OBJECT (p->window), "event",
(GtkSignalFunc) event_handler, p);
gtk_signal_connect_after (GTK_OBJECT (p->window), "expose_event",
(GtkSignalFunc) expose_handler, p);
gtk_signal_connect_after (GTK_OBJECT (p->window), "size_allocate",
(GtkSignalFunc) preview_area_resize, 0);
gtk_object_set_data (GTK_OBJECT (p->window), "PreviewPointer", p);
g_signal_connect (G_OBJECT (p->window), "event",
G_CALLBACK (event_handler), p);
g_signal_connect_after (G_OBJECT (p->window), "expose_event",
G_CALLBACK (expose_handler), p);
g_signal_connect_after (G_OBJECT (p->window), "size_allocate",
G_CALLBACK ( preview_area_resize), 0);
gtk_object_set_data (G_OBJECT (p->window), "PreviewPointer", p);
/* Connect the motion-notify events of the preview area with the
rulers. Nifty stuff! */
// Connect the motion-notify events of the preview area with the
// rulers. Nifty stuff!
#if GTK_MAJOR_VERSION == 2
class = GTK_WIDGET_CLASS (GTK_OBJECT_GET_CLASS (GTK_OBJECT (p->hruler)));
class = GTK_WIDGET_CLASS (G_OBJECT_GET_CLASS (G_OBJECT (p->hruler)));
#else
class = GTK_WIDGET_CLASS (GTK_OBJECT (p->hruler)->klass);
#endif /* GTK_MAJOR_VERSION == 2 */
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 (G_OBJECT (p->hruler)->klass);
#endif /. GTK_MAJOR_VERSION == 2
signal_func = G_CALLBACK (class->motion_notify_event);
g_signal_connect_object (G_OBJECT (p->window), "motion_notify_event",
signal_func, G_OBJECT (p->hruler));
#if GTK_MAJOR_VERSION == 2
class = GTK_WIDGET_CLASS (GTK_OBJECT_GET_CLASS (GTK_OBJECT (p->vruler)));
class = GTK_WIDGET_CLASS (G_OBJECT_GET_CLASS (G_OBJECT (p->vruler)));
#else
class = GTK_WIDGET_CLASS (GTK_OBJECT (p->vruler)->klass);
#endif /* GTK_MAJOR_VERSION == 2 */
signal_func = (GtkSignalFunc) class->motion_notify_event;
gtk_signal_connect_object (GTK_OBJECT (p->window), "motion_notify_event",
signal_func, GTK_OBJECT (p->vruler));
class = GTK_WIDGET_CLASS (G_OBJECT (p->vruler)->klass);
#endif // GTK_MAJOR_VERSION == 2
signal_func = G_CALLBACK (class->motion_notify_event);
g_signal_connect_object (G_OBJECT (p->window), "motion_notify_event",
signal_func, G_OBJECT (p->vruler));
p->viewport = gtk_frame_new ( /* label */ 0);
p->viewport = gtk_frame_new ( 0);
gtk_frame_set_shadow_type (GTK_FRAME (p->viewport), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (p->viewport), p->window);
@ -1311,19 +1313,19 @@ preview_new (GSGDialog * dialog)
preview_update (p);
/* fill in action area: */
// fill in action area:
/* Preview button */
// Preview button
p->preview = gtk_button_new_with_label ("Acquire Preview");
gtk_signal_connect (GTK_OBJECT (p->preview), "clicked",
(GtkSignalFunc) start_button_clicked, p);
g_signal_connect (G_OBJECT (p->preview), "clicked",
G_CALLBACK (start_button_clicked), p);
gtk_box_pack_start (GTK_BOX (hbox), p->preview, TRUE, TRUE, 0);
gtk_widget_show (p->preview);
/* Cancel button */
// Cancel button
p->cancel = gtk_button_new_with_label ("Cancel Preview");
gtk_signal_connect (GTK_OBJECT (p->cancel), "clicked",
(GtkSignalFunc) cancel_button_clicked, p);
g_signal_connect (G_OBJECT (p->cancel), "clicked",
G_CALLBACK (cancel_button_clicked), p);
gtk_box_pack_start (GTK_BOX (hbox), p->cancel, TRUE, TRUE, 0);
gtk_widget_set_sensitive (p->cancel, FALSE);
@ -1341,11 +1343,14 @@ preview_new (GSGDialog * dialog)
gtk_widget_pop_visual ();
#endif
return p;
*/
return NULL;
}
void
preview_update (Preview * p)
{
/*
float val, width, height, max_width, max_height;
const SANE_Option_Descriptor *opt;
int i, surface_changed;
@ -1397,7 +1402,7 @@ preview_update (Preview * p)
p->image_height = 0;
}
/* guess the initial preview window size: */
// guess the initial preview window size:
width = p->surface[GSG_BR_X] - p->surface[GSG_TL_X];
height = p->surface[GSG_BR_Y] - p->surface[GSG_TL_Y];
@ -1450,7 +1455,7 @@ preview_update (Preview * p)
height = max_height;
}
/* re-adjust so we maintain aspect without exceeding max size: */
// re-adjust so we maintain aspect without exceeding max size:
if (width / height != p->aspect)
{
if (p->aspect > 1.0)
@ -1463,7 +1468,7 @@ preview_update (Preview * p)
p->preview_height = height + 0.5;
if (surface_changed)
{
gtk_widget_set_usize (GTK_WIDGET (p->window),
gtk_widget_set_size_request (GTK_WIDGET (p->window),
p->preview_width, p->preview_height);
if (GTK_WIDGET_DRAWABLE (p->window))
preview_area_resize (p->window);
@ -1472,11 +1477,13 @@ preview_update (Preview * p)
restore_preview_image (p);
}
update_selection (p);
*/
}
void
preview_scan (Preview * p)
{
/*
float min, max, swidth, sheight, width, height, dpi = 0;
const SANE_Option_Descriptor *opt;
gint gwidth, gheight;
@ -1490,7 +1497,7 @@ preview_scan (Preview * p)
save_option (p, p->dialog->well_known.coord[i],
&p->saved_coord[i], p->saved_coord_valid + i);
/* determine dpi, if necessary: */
// determine dpi, if necessary:
if (p->dialog->well_known.dpi > 0)
{
@ -1529,32 +1536,34 @@ preview_scan (Preview * p)
return;
}
/* set the scan window (necessary since backends may default to
non-maximum size): */
// set the scan window (necessary since backends may default to
// non-maximum size):
for (i = 0; i < 4; ++i)
set_option_float (p, p->dialog->well_known.coord[i], p->surface[i]);
set_option_bool (p, p->dialog->well_known.preview, SANE_TRUE);
/* OK, all set to go */
// OK, all set to go
scan_start (p);
*/
}
void
preview_destroy (Preview * p)
{
/*
char filename[PATH_MAX];
FILE *out;
if (p->scanning)
scan_done (p); /* don't save partial window */
scan_done (p); // don't save partial window
else if (preferences.preserve_preview && p->image_data
&& make_preview_image_path (p, sizeof (filename), filename) >= 0)
{
/* save preview image */
// save preview image
out = fopen (filename, "w");
if (out)
{
/* always save it as a PPM image: */
// always save it as a PPM image:
fprintf (out, "P6\n# surface: %g %g %g %g %u %u\n%d %d\n255\n",
p->surface[0], p->surface[1], p->surface[2], p->surface[3],
p->surface_type, p->surface_unit,
@ -1572,4 +1581,5 @@ preview_destroy (Preview * p)
if (p->top)
gtk_widget_destroy (p->top);
free (p);
*/
}

2
src/preview.h
Wyświetl plik

@ -53,7 +53,7 @@ typedef struct
int image_height;
u_char *image_data; /* 3 * image_width * image_height bytes */
GdkGC *gc;
// GdkGC *gc;
int selection_drag;
struct
{

10
src/progress.c
Wyświetl plik

@ -37,7 +37,7 @@ progress_cancel (GtkWidget * widget, gpointer data)
Progress_t *
progress_new (char *title, char *text, GtkWindow * parent,
GtkSignalFunc callback, gpointer callback_data)
GCallback callback, gpointer callback_data)
{
GtkWidget *button, *label;
GtkBox *vbox, *hbox;
@ -68,7 +68,7 @@ progress_new (char *title, char *text, GtkWindow * parent,
gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
p->pbar = gtk_progress_bar_new ();
gtk_widget_set_usize (p->pbar, 200, 20);
gtk_widget_set_size_request (p->pbar, 200, 20);
gtk_box_pack_start (vbox, p->pbar, TRUE, TRUE, 0);
#ifdef HAVE_SYS_TIME_H
@ -81,8 +81,8 @@ progress_new (char *title, char *text, GtkWindow * parent,
if (callback != NULL)
{
button = gtk_toggle_button_new_with_label ("Cancel");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) progress_cancel, p);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (progress_cancel), p);
gtk_box_pack_start (hbox, button, TRUE, TRUE, 0);
}
@ -166,7 +166,7 @@ progress_update (Progress_t * p, gfloat newval)
snprintf (buff, sizeof (buff), ETA_LABEL ": %d sec", remaining);
}
gtk_label_set_text (GTK_LABEL (p->etaIndicator), buff);
gtk_label_set_text_text (GTK_LABEL (p->etaIndicator), buff);
}
#endif
}

4
src/progress.h
Wyświetl plik

@ -22,7 +22,7 @@
typedef struct Progress_t
{
GtkSignalFunc callback;
GCallback callback;
gpointer callback_data;
GtkWidget *shell;
GtkWidget *pbar;
@ -34,7 +34,7 @@ typedef struct Progress_t
Progress_t;
extern Progress_t * progress_new (char *title, char *text, GtkWindow *parent,
GtkSignalFunc callback, gpointer callback_data);
GCallback callback, gpointer callback_data);
extern void progress_free (Progress_t *p);
extern void progress_update (Progress_t *p, gfloat newval);

72
src/xcam.c
Wyświetl plik

@ -246,9 +246,9 @@ stop_camera (void)
win.playing = FALSE;
win.gdk_input_tag = -1;
if (!win.playing)
gtk_label_set (GTK_LABEL (win.play_stop_label), " Play ");
gtk_label_set_text (GTK_LABEL (win.play_stop_label), " Play ");
else
gtk_label_set (GTK_LABEL (win.play_stop_label), " Stop ");
gtk_label_set_text (GTK_LABEL (win.play_stop_label), " Stop ");
DBG (DBG_debug, "xcam: stop_camera: exit\n");
}
@ -274,7 +274,7 @@ switch_device (const SANE_Device * dev)
if (dialog)
sprintf (buf, "%s %s %s", dev->vendor, dev->model, dev->type);
gtk_label_set (GTK_LABEL (win.device_info_label), buf);
gtk_label_set_text (GTK_LABEL (win.device_info_label), buf);
DBG (DBG_debug, "xcam: switch_device: exit\n");
}
@ -471,7 +471,7 @@ update_param (GSGDialog * dialog, void *arg)
}
else
snprintf (buf, sizeof (buf), "Invalid parameters.");
gtk_label_set (GTK_LABEL (win.info_label), buf);
gtk_label_set_text (GTK_LABEL (win.info_label), buf);
DBG (DBG_debug, "xcam: update_param: exit\n");
}
@ -645,14 +645,14 @@ prompt_for_device_name (GtkWidget * widget, gpointer data)
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) device_name_dialog_ok, text);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) device_name_dialog_cancel, dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_widget_show (button);
@ -754,7 +754,7 @@ build_files_menu (void)
item = gtk_menu_item_new_with_label ("Exit");
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) exit_callback, 0);
gtk_widget_show (item);
@ -796,7 +796,7 @@ build_device_menu (void)
{
item = gtk_menu_item_new_with_label ((char *) device[i]->name);
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) device_activate_callback,
(gpointer) device[i]);
gtk_widget_show (item);
@ -807,13 +807,13 @@ build_device_menu (void)
gtk_widget_show (item);
item = gtk_menu_item_new_with_label ("Refresh device list...");
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) rescan_devices, 0);
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_widget_show (item);
item = gtk_menu_item_new_with_label ("Specify device name...");
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) prompt_for_device_name, 0);
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_widget_show (item);
@ -858,7 +858,7 @@ build_preferences_menu (GSGDialog * dialog)
preferences.advanced);
gtk_menu_append (GTK_MENU (menu), item);
gtk_widget_show (item);
gtk_signal_connect (GTK_OBJECT (item), "toggled",
g_signal_connect (G_OBJECT (item), "toggled",
(GtkSignalFunc) pref_toggle_advanced, 0);
/* tooltips submenu: */
@ -868,7 +868,7 @@ build_preferences_menu (GSGDialog * dialog)
preferences.tooltips_enabled);
gtk_menu_append (GTK_MENU (menu), item);
gtk_widget_show (item);
gtk_signal_connect (GTK_OBJECT (item), "toggled",
g_signal_connect (G_OBJECT (item), "toggled",
(GtkSignalFunc) pref_toggle_tooltips, 0);
/* twocolumn submenu: */
@ -878,7 +878,7 @@ build_preferences_menu (GSGDialog * dialog)
preferences.twocolumn_enabled);
gtk_menu_append (GTK_MENU (menu), item);
gtk_widget_show (item);
gtk_signal_connect (GTK_OBJECT (item), "toggled",
g_signal_connect (G_OBJECT (item), "toggled",
(GtkSignalFunc) pref_toggle_twocolumn, 0);
item = gtk_menu_item_new ();
@ -887,13 +887,13 @@ build_preferences_menu (GSGDialog * dialog)
item = gtk_menu_item_new_with_label ("Save as default settings");
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) save_defaults_callback, 0);
gtk_widget_show (item);
item = gtk_menu_item_new_with_label ("Load default settings");
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) load_defaults_callback, 0);
gtk_widget_show (item);
@ -903,13 +903,13 @@ build_preferences_menu (GSGDialog * dialog)
item = gtk_menu_item_new_with_label ("Save settings as...");
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) save_as_callback, 0);
gtk_widget_show (item);
item = gtk_menu_item_new_with_label ("Load settings from...");
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
g_signal_connect (G_OBJECT (item), "activate",
(GtkSignalFunc) load_from_callback, 0);
gtk_widget_show (item);
@ -1270,7 +1270,7 @@ next_frame (void)
gdk_image_new (image_type,
gdk_window_get_visual (win.canvas.preview->window),
win.params.pixels_per_line, win.params.lines);
gtk_widget_set_usize (win.canvas.preview,
gtk_widget_set_size_request (win.canvas.preview,
win.params.pixels_per_line, win.params.lines);
}
win.data = win.canvas.gdk_image->mem;
@ -1303,13 +1303,13 @@ play_stop_button (GtkWidget * widget, gpointer client_data,
if (win.playing)
{
win.playing = FALSE;
gtk_label_set (GTK_LABEL (win.play_stop_label), " Play ");
gtk_label_set_text (GTK_LABEL (win.play_stop_label), " Play ");
DBG (DBG_debug, "xcam: wait for play button to be pushed\n");
}
else if (win.gdk_input_tag < 0)
{
win.playing = TRUE;
gtk_label_set (GTK_LABEL (win.play_stop_label), " Stop ");
gtk_label_set_text (GTK_LABEL (win.play_stop_label), " Stop ");
DBG (DBG_debug, "xcam: wait for stop button to be pushed\n");
next_frame ();
}
@ -1333,7 +1333,7 @@ save_frame_button (GtkWidget * widget, gpointer client_data,
else if (win.gdk_input_tag < 0)
{
win.saving = TRUE;
gtk_label_set (GTK_LABEL (win.save_frame_label), "Saving started");
gtk_label_set_text (GTK_LABEL (win.save_frame_label), "Saving started");
/* ------------------------------------------ */
/* test for pnm formats */
@ -1368,7 +1368,7 @@ save_frame_button (GtkWidget * widget, gpointer client_data,
save_frame ();
buttons_enable ();
gsg_sync (dialog);
gtk_label_set (GTK_LABEL (win.save_frame_label), "Save\nFrame");
gtk_label_set_text (GTK_LABEL (win.save_frame_label), "Save\nFrame");
DBG (DBG_debug, "xcam: save_frame_button: exit\n");
}
@ -1384,12 +1384,12 @@ txt_button (GtkWidget * widget, gpointer client_data, gpointer call_data)
{
win.saving = FALSE;
win.value_txt = 0;
gtk_label_set (GTK_LABEL (win.txt_label), " TXT \n OFF ");
gtk_label_set_text (GTK_LABEL (win.txt_label), " TXT \n OFF ");
}
else if (win.gdk_input_tag < 0)
{
win.saving = TRUE;
gtk_label_set (GTK_LABEL (win.txt_label), " TXT \n ON ");
gtk_label_set_text (GTK_LABEL (win.txt_label), " TXT \n ON ");
win.value_txt = 1;
}
gsg_sync (dialog);
@ -1408,12 +1408,12 @@ rgb_bgr_button (GtkWidget * widget, gpointer client_data, gpointer call_data)
{
win.saving = FALSE;
win.value_rgb = 0;
gtk_label_set (GTK_LABEL (win.rgb_bgr_label), "RGB");
gtk_label_set_text (GTK_LABEL (win.rgb_bgr_label), "RGB");
}
else if (win.gdk_input_tag < 0)
{
win.saving = TRUE;
gtk_label_set (GTK_LABEL (win.rgb_bgr_label), "BGR");
gtk_label_set_text (GTK_LABEL (win.rgb_bgr_label), "BGR");
win.value_rgb = 1;
}
gsg_sync (dialog);
@ -1668,8 +1668,8 @@ main (int argc, char **argv)
win.gdk_input_tag = -1;
win.shell = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win.shell), (char *) prog_name);
gtk_signal_connect (GTK_OBJECT (win.shell), "delete_event",
GTK_SIGNAL_FUNC (xcam_win_delete), NULL);
g_signal_connect (G_OBJECT (win.shell), "delete_event",
G_CALLBACK (xcam_win_delete), NULL);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (vbox), 0);
@ -1739,7 +1739,7 @@ main (int argc, char **argv)
win.canvas.preview = gtk_drawing_area_new ();
gtk_drawing_area_size (GTK_DRAWING_AREA (win.canvas.preview), 320, 200);
gtk_widget_set_events (win.canvas.preview, CANVAS_EVENT_MASK);
gtk_signal_connect (GTK_OBJECT (win.canvas.preview), "event",
g_signal_connect (G_OBJECT (win.canvas.preview), "event",
(GtkSignalFunc) canvas_events, 0);
gtk_container_add (GTK_CONTAINER (frame), win.canvas.preview);
@ -1809,7 +1809,7 @@ main (int argc, char **argv)
&& (sane_get_parameters (gsg_dialog_get_device (dialog), &win.params)
== SANE_STATUS_GOOD))
{
gtk_widget_set_usize (win.canvas.preview,
gtk_widget_set_size_request (win.canvas.preview,
win.params.pixels_per_line, win.params.lines);
}
@ -1850,7 +1850,7 @@ main (int argc, char **argv)
/* The TXT button */
button = gtk_button_new_with_label (" TXT ");
win.txt_label = GTK_BIN (button)->child;
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) txt_button, dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
@ -1859,7 +1859,7 @@ main (int argc, char **argv)
/* The RGB-BGR button */
button = gtk_button_new_with_label ("RGB");
win.rgb_bgr_label = GTK_BIN (button)->child;
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) rgb_bgr_button, dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
@ -1869,7 +1869,7 @@ main (int argc, char **argv)
/* The Play button */
button = gtk_button_new_with_label (" Play ");
win.play_stop_label = GTK_BIN (button)->child;
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) play_stop_button, dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
@ -1879,7 +1879,7 @@ main (int argc, char **argv)
/* The Save Frame button */
button = gtk_button_new_with_label ("Save\nFrame");
win.save_frame_label = GTK_BIN (button)->child;
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) save_frame_button, dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
@ -1902,14 +1902,14 @@ main (int argc, char **argv)
text = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (text), (char *) preferences.filename);
gtk_box_pack_start (GTK_BOX (hbox), text, TRUE, TRUE, 2);
gtk_signal_connect (GTK_OBJECT (text), "changed",
g_signal_connect (G_OBJECT (text), "changed",
(GtkSignalFunc) filename_changed_callback, 0);
win.filename_entry = text;
button = gtk_button_new_with_label ("Browse");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) browse_filename_callback, 0);
gtk_widget_show (button);

145
src/xscanimage.c
Wyświetl plik

@ -39,7 +39,7 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <glib.h>
#include <sys/stat.h>
#include <sane/sane.h>
@ -536,7 +536,7 @@ update_param (GSGDialog * dialog, void *arg)
}
else
snprintf (buf, sizeof (buf), "Invalid parameters.");
gtk_label_set (GTK_LABEL (scan_win.info_label), buf);
gtk_label_set_text (GTK_LABEL (scan_win.info_label), buf);
if (scan_win.preview)
preview_update (scan_win.preview);
@ -630,7 +630,7 @@ scan_win_delete (GtkWidget * w, gpointer data)
static void
preview_window_destroyed (GtkWidget * widget, gpointer call_data)
{
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (call_data), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (call_data), FALSE);
}
/* Invoked when the preview button is pressed. */
@ -646,12 +646,12 @@ scan_preview (GtkWidget * widget, gpointer call_data)
{
scan_win.preview = preview_new (dialog);
if (scan_win.preview && scan_win.preview->top)
gtk_signal_connect (GTK_OBJECT (scan_win.preview->top),
g_signal_connect (G_OBJECT (scan_win.preview->top),
"destroy",
GTK_SIGNAL_FUNC (preview_window_destroyed),
G_CALLBACK (preview_window_destroyed),
widget);
else
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
if (scan_win.progress)
gtk_widget_set_sensitive (scan_win.preview->preview, FALSE);
}
@ -745,8 +745,8 @@ write_swapped_words (FILE * f, char *buf, guint len)
DBG (DBG_debug, "write_swapped_words: finished\n");
}
static void
input_available (gpointer data, gint source, GdkInputCondition cond)
static gboolean
input_available (gpointer data, gint source, GIOCondition cond)
{
SANE_Handle dev = gsg_dialog_get_device (dialog);
static char buf[32768];
@ -771,7 +771,7 @@ input_available (gpointer data, gint source, GdkInputCondition cond)
}
else
{
gdk_input_remove (scan_win.input_tag);
g_source_remove (scan_win.input_tag);
scan_win.input_tag = -1;
}
scan_start ();
@ -785,7 +785,7 @@ input_available (gpointer data, gint source, GdkInputCondition cond)
gsg_error (buf);
}
scan_done ();
return;
return FALSE;
}
if (!len) /* out of data for now */
{
@ -955,11 +955,11 @@ input_available (gpointer data, gint source, GdkInputCondition cond)
fprintf (stderr, "%s.input_available: bad frame format %d\n",
prog_name, scan_win.param.format);
scan_done ();
return;
return FALSE;
}
}
DBG (DBG_debug, "input_available: finished\n");
return;
return TRUE;
#ifdef HAVE_LIBGIMP_GIMP_H
bad_depth:
@ -967,7 +967,7 @@ bad_depth:
scan_win.param.depth);
gsg_error (buf);
scan_done ();
return;
return FALSE;
#endif
}
@ -983,7 +983,7 @@ scan_done (void)
if (scan_win.input_tag >= 0)
{
gdk_input_remove (scan_win.input_tag);
g_source_remove (scan_win.input_tag);
scan_win.input_tag = -1;
}
@ -1098,7 +1098,7 @@ scan_start (void)
progress_free (scan_win.progress);
snprintf (buf, sizeof (buf), "Scanner is warming up.");
scan_win.progress = progress_new ("Warming up ...", buf, scan_win.shell,
(GtkSignalFunc) cancel_action, NULL);
G_CALLBACK (cancel_action), NULL);
#ifdef HAVE_SYS_TIME_H
struct timeval start, current;
gettimeofday(&start,NULL);
@ -1288,19 +1288,22 @@ scan_start (void)
if (scan_win.progress)
progress_free (scan_win.progress);
scan_win.progress = progress_new ("Scanning", buf, GTK_WINDOW(scan_win.shell),
(GtkSignalFunc) cancel_action, 0);
G_CALLBACK (cancel_action), 0);
scan_win.input_tag = -1;
if (sane_set_io_mode (dev, SANE_TRUE) == SANE_STATUS_GOOD
&& sane_get_select_fd (dev, &fd) == SANE_STATUS_GOOD)
{
GIOChannel *chan = g_io_channel_unix_new (fd);
scan_win.input_tag =
gdk_input_add (fd, GDK_INPUT_READ | GDK_INPUT_EXCEPTION,
input_available, 0);
g_io_add_watch (chan, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_PRI,
(GIOFunc) input_available, 0);
}
else
{
while (gtk_events_pending ())
gtk_main_iteration ();
input_available (0, -1, GDK_INPUT_READ);
input_available (0, -1, G_IO_IN);
}
DBG (DBG_debug, "scan_start: finished\n");
}
@ -1397,8 +1400,8 @@ files_build_menu (void)
item = gtk_menu_item_new_with_label ("Exit");
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
(GtkSignalFunc) files_exit_callback, 0);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (files_exit_callback), 0);
gtk_widget_show (item);
DBG (DBG_debug, "files_build_menu: finished\n");
@ -1509,10 +1512,10 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
hbox = gtk_hbox_new ( /* homogeneous */ FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
button = gtk_check_button_new_with_label ("Preserve preview image");
gtk_signal_connect (GTK_OBJECT (button), "toggled",
(GtkSignalFunc) update_int_callback,
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (update_int_callback),
&preferences.preserve_preview);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button),
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
preferences.preserve_preview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
@ -1524,10 +1527,10 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
hbox = gtk_hbox_new ( /* homogeneous */ FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
button = gtk_check_button_new_with_label ("Use private colormap");
gtk_signal_connect (GTK_OBJECT (button), "toggled",
(GtkSignalFunc) update_int_callback,
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (update_int_callback),
&preferences.preview_own_cmap);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button),
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
preferences.preview_own_cmap);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
@ -1548,8 +1551,8 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
text = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (text), buf);
gtk_box_pack_start (GTK_BOX (hbox), text, TRUE, TRUE, 2);
gtk_signal_connect (GTK_OBJECT (text), "changed",
(GtkSignalFunc) update_double_callback,
g_signal_connect (G_OBJECT (text), "changed",
G_CALLBACK (update_double_callback),
&preferences.preview_gamma);
gtk_widget_show (text);
@ -1558,15 +1561,15 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
button = gtk_button_new_with_label ("OK");
gtk_widget_set_can_default (button, TRUE);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) preview_options_ok_callback, dialog);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (preview_options_ok_callback), dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) preview_options_cancel_callback,
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (preview_options_cancel_callback),
dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
@ -1660,8 +1663,8 @@ pref_build_menu (void)
preferences.advanced);
gtk_menu_append (GTK_MENU (menu), item);
gtk_widget_show (item);
gtk_signal_connect (GTK_OBJECT (item), "toggled",
(GtkSignalFunc) pref_toggle_advanced, 0);
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_advanced), 0);
/* tooltips submenu: */
@ -1670,8 +1673,8 @@ pref_build_menu (void)
preferences.tooltips_enabled);
gtk_menu_append (GTK_MENU (menu), item);
gtk_widget_show (item);
gtk_signal_connect (GTK_OBJECT (item), "toggled",
(GtkSignalFunc) pref_toggle_tooltips, 0);
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_tooltips), 0);
/* two column submenu: */
@ -1680,8 +1683,8 @@ pref_build_menu (void)
preferences.twocolumn_enabled);
gtk_menu_append (GTK_MENU (menu), item);
gtk_widget_show (item);
gtk_signal_connect (GTK_OBJECT (item), "toggled",
(GtkSignalFunc) pref_toggle_twocolumn, 0);
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_twocolumn), 0);
/* length unit submenu: */
@ -1715,12 +1718,12 @@ pref_build_menu (void)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (unit_mm), TRUE);
preferences.length_unit = 1.0;
}
gtk_signal_connect (GTK_OBJECT (unit_mm), "toggled",
(GtkSignalFunc) pref_set_unit_callback, "mm");
gtk_signal_connect (GTK_OBJECT (unit_cm), "toggled",
(GtkSignalFunc) pref_set_unit_callback, "cm");
gtk_signal_connect (GTK_OBJECT (unit_in), "toggled",
(GtkSignalFunc) pref_set_unit_callback, "in");
g_signal_connect (G_OBJECT (unit_mm), "toggled",
G_CALLBACK (pref_set_unit_callback), "mm");
g_signal_connect (G_OBJECT (unit_cm), "toggled",
G_CALLBACK (pref_set_unit_callback), "cm");
g_signal_connect (G_OBJECT (unit_in), "toggled",
G_CALLBACK (pref_set_unit_callback), "in");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
@ -1728,8 +1731,8 @@ pref_build_menu (void)
item = gtk_menu_item_new_with_label ("Preview options...");
gtk_menu_append (GTK_MENU (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
(GtkSignalFunc) preview_options_dialog, 0);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (preview_options_dialog), 0);
gtk_widget_show (item);
/* insert separator: */
@ -1739,14 +1742,14 @@ pref_build_menu (void)
item = gtk_menu_item_new_with_label ("Save device settings");
gtk_menu_append (GTK_MENU (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
(GtkSignalFunc) pref_device_save, 0);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (pref_device_save), 0);
gtk_widget_show (item);
item = gtk_menu_item_new_with_label ("Restore device settings");
gtk_menu_append (GTK_MENU (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
(GtkSignalFunc) pref_device_restore, 0);
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (pref_device_restore), 0);
gtk_widget_show (item);
DBG (DBG_debug, "pref_build_menu: finished\n");
@ -1803,8 +1806,8 @@ device_dialog (void)
gtk_window_set_title (GTK_WINDOW (scan_win.shell), (char *) devname);
gtk_window_set_policy (GTK_WINDOW (scan_win.shell), FALSE, TRUE, TRUE);
gtk_window_set_default_size (GTK_WINDOW (scan_win.shell), 400, 400);
gtk_signal_connect (GTK_OBJECT (scan_win.shell), "delete_event",
GTK_SIGNAL_FUNC (scan_win_delete), NULL);
g_signal_connect (G_OBJECT (scan_win.shell), "delete_event",
G_CALLBACK (scan_win_delete), NULL);
/* create the main vbox */
vbox = gtk_dialog_get_content_area(GTK_DIALOG (scan_win.shell));
@ -1848,15 +1851,15 @@ device_dialog (void)
text = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (text), (char *) preferences.filename);
gtk_box_pack_start (GTK_BOX (hbox), text, TRUE, TRUE, 2);
gtk_signal_connect (GTK_OBJECT (text), "changed",
(GtkSignalFunc) filename_changed_callback, 0);
g_signal_connect (G_OBJECT (text), "changed",
G_CALLBACK (filename_changed_callback), 0);
scan_win.filename_entry = text;
button = gtk_button_new_with_label ("Browse");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 2);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) browse_filename_callback, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (browse_filename_callback), 0);
gtk_widget_show (button);
gtk_widget_show (label);
@ -1911,30 +1914,30 @@ device_dialog (void)
/* The Scan button */
scan_win.scan_button = gtk_button_new_with_label ("Scan");
gtk_signal_connect (GTK_OBJECT (scan_win.scan_button), "clicked",
(GtkSignalFunc) scan_dialog, NULL);
g_signal_connect (G_OBJECT (scan_win.scan_button), "clicked",
G_CALLBACK (scan_dialog), NULL);
gtk_box_pack_start (GTK_BOX (hbox), scan_win.scan_button, TRUE, TRUE, 0);
gtk_widget_show (scan_win.scan_button);
/* The Preview button */
scan_win.preview_button =
gtk_toggle_button_new_with_label ("Preview Window");
gtk_signal_connect (GTK_OBJECT (scan_win.preview_button), "clicked",
(GtkSignalFunc) scan_preview, NULL);
g_signal_connect (G_OBJECT (scan_win.preview_button), "clicked",
G_CALLBACK (scan_preview), NULL);
gtk_box_pack_start (GTK_BOX (hbox), scan_win.preview_button, TRUE, TRUE, 0);
gtk_widget_show (scan_win.preview_button);
#if 0
/* The Zoom in button */
button = gtk_button_new_with_label ("Zoom");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) zoom_in_preview, NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
/* The Zoom out button */
button = gtk_button_new_with_label ("Zoom out");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
g_signal_connect (G_OBJECT (button), "clicked",
(GtkSignalFunc) zoom_out_preview, NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
@ -1974,8 +1977,8 @@ choose_device (void)
DBG (DBG_debug, "choose_device\n");
choose_device_dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (choose_device_dialog), "Select device");
gtk_signal_connect (GTK_OBJECT (choose_device_dialog), "delete_event",
GTK_SIGNAL_FUNC (files_exit_callback), NULL);
g_signal_connect (G_OBJECT (choose_device_dialog), "delete_event",
G_CALLBACK (files_exit_callback), NULL);
main_vbox = gtk_dialog_get_content_area(GTK_DIALOG (choose_device_dialog));
@ -1992,8 +1995,8 @@ choose_device (void)
adev = devlist[i];
button = gtk_radio_button_new_with_label (owner, (char *) adev->name);
gtk_signal_connect (GTK_OBJECT (button), "button_press_event",
(GtkSignalFunc) select_device_callback,
g_signal_connect (G_OBJECT (button), "button_press_event",
G_CALLBACK (select_device_callback),
(void *) (long) i);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
@ -2008,16 +2011,16 @@ choose_device (void)
/* The OK button */
button = gtk_button_new_with_label ("OK");
gtk_widget_set_can_default (button, TRUE);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) ok_choose_dialog_callback, NULL);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (ok_choose_dialog_callback), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
gtk_widget_show (button);
/* The Cancel button */
button = gtk_button_new_with_label ("Cancel");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) files_exit_callback, NULL);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (files_exit_callback), NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);