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

Start of GtkWidgets migration

merge-requests/6/head
Ordissimo 2022-05-12 23:00:34 +02:00
rodzic 4c234b1512
commit 9d087040c2
6 zmienionych plików z 202 dodań i 243 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

287
src/gtkglue.c
Wyświetl plik

@ -88,13 +88,15 @@ unit_string (SANE_Unit unit)
static void
set_tooltip (GtkTooltips * tooltips, GtkWidget * widget, const char *desc)
{
/*
if (desc && desc[0])
#ifdef HAVE_GTK_TOOLTIPS_SET_TIPS
/* pre 0.99.4: */
// pre 0.99.4:
gtk_tooltips_set_tips (tooltips, widget, (char *) desc);
#else
gtk_tooltips_set_tip (tooltips, widget, desc, 0);
#endif
*/
}
int
@ -246,12 +248,12 @@ gsg_message (gchar * title, gchar * message)
return;
}
gsg_message_dialog_active = 1;
message_dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_position (GTK_WINDOW (message_dialog), GTK_WIN_POS_MOUSE);
message_dialog = gtk_window_new ();
gtk_window_set_title (GTK_WINDOW (message_dialog), title);
/* create the main vbox */
main_vbox = gtk_vbox_new (TRUE, 5);
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_widget_show (main_vbox);
@ -264,8 +266,8 @@ gsg_message (gchar * title, gchar * message)
/* the confirmation button */
button = gtk_button_new_with_label ("OK");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gsg_close_dialog_callback,
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gsg_close_dialog_callback),
message_dialog);
gtk_container_add (GTK_CONTAINER (main_vbox), button);
@ -285,13 +287,6 @@ gsg_warning (gchar * warning)
gsg_message ("Warning", warning);
}
static void
get_filename_button_clicked (GtkWidget * w, gpointer data)
{
int *clicked = data;
*clicked = 1;
}
int
gsg_get_filename (const char *label, const char *default_name,
size_t max_len, char *filename)
@ -299,37 +294,24 @@ gsg_get_filename (const char *label, const char *default_name,
int cancel = 0, ok = 0;
GtkWidget *filesel;
filesel = gtk_file_selection_new ((char *) label);
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,
NULL);
gtk_window_set_modal (GTK_WINDOW (filesel), TRUE);
gtk_signal_connect (GTK_OBJECT
(GTK_FILE_SELECTION (filesel)->cancel_button),
"clicked", (GtkSignalFunc) get_filename_button_clicked,
&cancel);
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filesel)->ok_button),
"clicked", (GtkSignalFunc) get_filename_button_clicked,
&ok);
if (default_name)
gtk_file_selection_set_filename (GTK_FILE_SELECTION (filesel),
(char *) default_name);
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filesel),
(char *) default_name);
gtk_widget_show (filesel);
while (!cancel && !ok)
{
if (!gtk_events_pending ())
usleep (100000);
gtk_main_iteration ();
}
if (ok)
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
size_t len, cwd_len;
char *cwd;
strncpy (filename,
gtk_file_selection_get_filename (GTK_FILE_SELECTION (filesel)),
gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filesel)),
max_len - 1);
filename[max_len - 1] = '\0';
@ -357,7 +339,7 @@ autobutton_update (GtkWidget * widget, GSGDialogElement * elem)
char buf[256];
opt = sane_get_option_descriptor (dialog->dev, opt_num);
if (GTK_TOGGLE_BUTTON (widget)->active)
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
set_option (dialog, opt_num, 0, SANE_ACTION_SET_AUTO);
else
{
@ -379,22 +361,20 @@ static void
autobutton_new (GtkWidget * parent, GSGDialogElement * elem,
GtkWidget * label, GtkTooltips * tooltips)
{
GtkWidget *button, *alignment;
GtkWidget *button;
button = gtk_check_button_new ();
gtk_container_border_width (GTK_CONTAINER (button), 0);
gtk_widget_set_usize (button, 20, 20);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
(GtkSignalFunc) autobutton_update, elem);
gtk_container_set_border_width (GTK_CONTAINER (button), 0);
gtk_widget_set_size_request (button, 20, 20);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (autobutton_update), elem);
set_tooltip (tooltips, button, "Turns on automatic mode.");
alignment = gtk_alignment_new (0.0, 1.0, 0.5, 0.5);
gtk_container_add (GTK_CONTAINER (alignment), button);
// alignment = gtk_alignment_new (0.0, 1.0, 0.5, 0.5); // => button
gtk_box_pack_end (GTK_BOX (parent), label, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (parent), alignment, FALSE, FALSE, 2);
gtk_box_pack_end (GTK_BOX (parent), button, FALSE, FALSE, 2);
gtk_widget_show (alignment);
gtk_widget_show (button);
}
@ -403,11 +383,9 @@ button_update (GtkWidget * widget, GSGDialogElement * elem)
{
GSGDialog *dialog = elem->dialog;
int opt_num = elem - dialog->element;
// const SANE_Option_Descriptor *opt;
SANE_Word val = SANE_FALSE;
// opt = sane_get_option_descriptor (dialog->dev, opt_num);
if (GTK_TOGGLE_BUTTON (widget)->active)
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
val = SANE_TRUE;
set_option (dialog, opt_num, &val, SANE_ACTION_SET_VALUE);
return FALSE;
@ -421,9 +399,9 @@ button_new (GtkWidget * parent, const char *name, SANE_Word val,
GtkWidget *button;
button = gtk_check_button_new_with_label ((char *) name);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), val);
gtk_signal_connect (GTK_OBJECT (button), "toggled",
(GtkSignalFunc) button_update, elem);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), val);
gtk_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)
gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE);
@ -505,7 +483,7 @@ 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"): */
gtk_signal_emit_by_name (GTK_OBJECT (adj_data), "value_changed");
g_signal_emit (G_OBJECT (adj_data), "value_changed", 0);
return;
}
@ -517,15 +495,17 @@ scale_new (GtkWidget * parent, const char *name, gfloat val,
{
GtkWidget *hbox, *label, *scale;
hbox = gtk_hbox_new (FALSE, 2);
gtk_container_border_width (GTK_CONTAINER (hbox), 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
gtk_box_pack_start (GTK_BOX (parent), hbox, FALSE, FALSE, 0);
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_hscale_new (GTK_ADJUSTMENT (elem->data));
scale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,
GTK_ADJUSTMENT (elem->data));
set_tooltip (tooltips, scale, desc);
gtk_widget_set_usize (scale, 200, 0);
@ -534,7 +514,6 @@ scale_new (GtkWidget * parent, const char *name, gfloat val,
else
gtk_box_pack_end (GTK_BOX (hbox), scale, FALSE, FALSE, 0);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_CONTINUOUS);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
if (quant - (int) quant == 0.0)
gtk_scale_set_digits (GTK_SCALE (scale), 0);
@ -542,8 +521,8 @@ scale_new (GtkWidget * parent, const char *name, gfloat val,
/* one place behind decimal point */
gtk_scale_set_digits (GTK_SCALE (scale), 1);
gtk_signal_connect (elem->data, "value_changed",
(GtkSignalFunc) scale_update, elem);
g_signal_connect (G_OBJECT (elem->data), "value_changed",
G_CALLBACK (scale_update), elem);
gtk_widget_show (label);
gtk_widget_show (scale);
@ -575,8 +554,7 @@ option_menu_lookup (GSGMenuItem menu_items[], const char *string)
return i;
}
static void
option_menu_callback (GtkWidget * widget, gpointer data)
static void option_menu_callback (GtkWidget * widget, gpointer data)
{
GSGMenuItem *menu_item = data;
GSGDialogElement *elem = menu_item->elem;
@ -612,58 +590,37 @@ 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, GtkTooltips * tooltips, const char *desc, gint is_settable)
{
GtkWidget *hbox, *label, *option_menu, *menu, *item;
GSGMenuItem *menu_items;
int i, num_items;
hbox = gtk_hbox_new (FALSE, 2);
gtk_container_border_width (GTK_CONTAINER (hbox), 0);
gtk_box_pack_start (GTK_BOX (parent), hbox, FALSE, FALSE, 0);
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);
menu_items = malloc (num_items * sizeof (menu_items[0]));
menu = gtk_menu_new ();
for (i = 0; i < num_items; ++i)
{
item = gtk_menu_item_new_with_label (str_list[i]);
gtk_container_add (GTK_CONTAINER (menu), item);
gtk_signal_connect (GTK_OBJECT (item), "activate",
(GtkSignalFunc) option_menu_callback,
menu_items + i);
gtk_widget_show (item);
menu_items[i].label = str_list[i];
menu_items[i].elem = elem;
menu_items[i].index = i;
}
option_menu = gtk_option_menu_new ();
gtk_box_pack_end (GTK_BOX (hbox), option_menu, FALSE, FALSE, 2);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu),
option_menu_lookup (menu_items, val));
set_tooltip (tooltips, option_menu, desc);
gtk_widget_show (label);
gtk_widget_show (option_menu);
if (!is_settable)
gtk_widget_set_sensitive (GTK_WIDGET (hbox), FALSE);
gtk_widget_show (hbox);
elem->widget = option_menu;
elem->menu_size = num_items;
elem->menu = menu_items;
}
GtkWidget *hbox, *label, *option_menu, *menu, *item;
GSGMenuItem *menu_items;
int i, num_items, selected = 0;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
// gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
gtk_box_pack_start (GTK_BOX (parent), hbox, FALSE, FALSE, 0);
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 ()
for (i = 0; i < num_items; ++i)
{
gtk_combo_box_append_text (GTK_COMBO_BOX (option_menu), str_list[i]);
if (val && !strcmp(str_list[i], val))
selected = i;
}
gtk_box_pack_end (GTK_BOX (hbox), option_menu, FALSE, FALSE, 2);
gtk_combo_box_set_active (GTK_COMBO_BOX (hbox), selected);
set_tooltip (tooltips, option_menu, desc);
gtk_widget_show (label);
gtk_widget_show (option_menu);
if (!is_settable)
gtk_widget_set_sensitive (GTK_WIDGET (hbox), FALSE);
gtk_widget_show (hbox);
elem->widget = option_menu;
elem->menu_size = num_items;
elem->menu = menu_items;
}
static void
text_entry_callback (GtkWidget * w, gpointer data)
@ -681,7 +638,7 @@ text_entry_callback (GtkWidget * w, gpointer data)
buf = alloca (opt->size);
buf[0] = '\0';
text = gtk_entry_get_text (GTK_ENTRY (elem->widget));
text = gtk_editable_get_text (GTK_EDITABLE (elem->widget));
if (text)
strncpy (buf, text, opt->size);
buf[opt->size - 1] = '\0';
@ -690,7 +647,7 @@ text_entry_callback (GtkWidget * w, gpointer data)
if (strcmp (buf, text) != 0)
/* the backend modified the option value; update widget: */
gtk_entry_set_text (GTK_ENTRY (elem->widget), buf);
gtk_editable_set_text (GTK_EDITABLE (elem->widget), buf);
}
static void
@ -700,18 +657,18 @@ text_entry_new (GtkWidget * parent, const char *name, const char *val,
{
GtkWidget *hbox, *text, *label;
hbox = gtk_hbox_new (FALSE, 2);
gtk_container_border_width (GTK_CONTAINER (hbox), 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (parent), hbox, FALSE, FALSE, 0);
label = gtk_label_new ((char *) name);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
text = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (text), (char *) val);
gtk_editable_set_text (GTK_EDITABLE (text), (char *) val);
gtk_box_pack_start (GTK_BOX (hbox), text, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (text), "changed",
(GtkSignalFunc) text_entry_callback, elem);
g_signal_connect (G_OBJECT (text), "changed",
G_CALLBACK (text_entry_callback), elem);
set_tooltip (tooltips, text, desc);
gtk_widget_show (hbox);
@ -729,13 +686,13 @@ group_new (GtkWidget * parent, const char *title)
GtkWidget *frame, *vbox;
frame = gtk_frame_new ((char *) title);
gtk_container_border_width (GTK_CONTAINER (frame), 4);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
// gtk_container_border_width (GTK_CONTAINER (frame), 4);
gtk_box_pack_start (GTK_BOX (parent), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 4);
gtk_container_border_width (GTK_CONTAINER (vbox), 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_frame_set_child (GTK_FRAME (frame), vbox);
gtk_widget_show (vbox);
return vbox;
}
@ -743,6 +700,7 @@ group_new (GtkWidget * parent, const char *title)
static GtkWidget *
curve_new (GSGDialog * dialog, int optnum)
{
/*
const SANE_Option_Descriptor *opt;
gfloat fmin, fmax, val, *vector;
SANE_Word *optval, min, max;
@ -823,6 +781,8 @@ curve_new (GSGDialog * dialog, int optnum)
gtk_widget_set_sensitive (gamma, FALSE);
return gamma;
*/
return NULL;
}
static void
@ -833,7 +793,6 @@ vector_new (GSGDialog * dialog, GtkWidget * vbox, int num_vopts, int *vopts)
int i;
notebook = gtk_notebook_new ();
gtk_container_border_width (GTK_CONTAINER (notebook), 4);
gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
for (i = 0; i < num_vopts; ++i)
@ -841,14 +800,15 @@ 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_vbox_new ( /* homogeneous */ FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
gtk_widget_show (vbox);
gtk_widget_show (label);
curve = curve_new (dialog, vopts[i]);
gtk_container_border_width (GTK_CONTAINER (curve), 4);
gtk_box_pack_start (GTK_BOX (vbox), curve, TRUE, TRUE, 0);
if (curve)
gtk_box_pack_start (GTK_BOX (vbox), curve, TRUE, TRUE, 0);
gtk_widget_show (curve);
dialog->element[vopts[i]].widget = curve;
@ -863,16 +823,8 @@ panel_destroy (GSGDialog * dialog)
GSGDialogElement *elem;
int i, j;
#ifdef HAVE_GTK_TOOLTIPS_SET_TIPS
/* pre 0.99.4: */
gtk_tooltips_unref (dialog->tooltips);
#else
# if GTK_MAJOR_VERSION == 2
gtk_object_sink (GTK_OBJECT (dialog->tooltips));
# else
gtk_object_unref (GTK_OBJECT (dialog->tooltips));
# endif /* GTK_MAJOR_VERSION == 2 */
#endif
g_object_unref (G_OBJECT (dialog->tooltips));
gtk_widget_destroy (dialog->main_hbox);
/* free the menu labels of integer/fix-point word-lists: */
@ -915,52 +867,51 @@ panel_build (GSGDialog * dialog)
int num_vector_opts = 0, *vector_opts;
SANE_Bool val_in_list;
main_hbox = gtk_hbox_new (FALSE, 2);
main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (main_hbox), FALSE);
if (dialog->twocolumn)
{
option_vbox = gtk_hbox_new (FALSE, 2); /* two column display */
option_vbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); /* two column display */
}
else
{
option_vbox = gtk_vbox_new (FALSE, 2); /* one column display */
option_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); /* one column display */
}
gtk_box_set_homogeneous (GTK_BOX (option_vbox), FALSE);
gtk_box_pack_start (GTK_BOX (main_hbox), option_vbox, FALSE, FALSE, 0);
gtk_widget_show (option_vbox);
/* standard options vbox */
standard_vbox = gtk_vbox_new ( /* homogeneous */ FALSE, 0);
standard_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); /* one column display */
gtk_box_set_homogeneous (GTK_BOX (standard_vbox), FALSE);
gtk_widget_show (standard_vbox);
gtk_box_pack_start (GTK_BOX (option_vbox), standard_vbox, FALSE, FALSE, 0);
/* advanced options page */
advanced_vbox = gtk_vbox_new ( /* homogeneous */ FALSE, 0);
advanced_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (advanced_vbox), FALSE);
gtk_box_pack_start (GTK_BOX (option_vbox), advanced_vbox, TRUE, TRUE, 0);
/* use black as foreground: */
/*
// use black as foreground:
dialog->tooltips = gtk_tooltips_new ();
dialog->tooltips_fg.red = 0;
dialog->tooltips_fg.green = 0;
dialog->tooltips_fg.blue = 0;
/* postit yellow (khaki) as background: */
// postit yellow (khaki) as background:
gdk_color_alloc (gtk_widget_get_colormap (main_hbox), &dialog->tooltips_fg);
dialog->tooltips_bg.red = 61669;
dialog->tooltips_bg.green = 59113;
dialog->tooltips_bg.blue = 35979;
gdk_color_alloc (gtk_widget_get_colormap (main_hbox), &dialog->tooltips_bg);
/* GTK2 doesn't have the function (seems like it's not needed with GTK2 anyway) */
#if GTK_MAJOR_VERSION < 2
gtk_tooltips_set_colors (dialog->tooltips,
&dialog->tooltips_bg, &dialog->tooltips_fg);
#endif /* GTK_MAJOR_VERSION < 2 */
gsg_set_tooltips (dialog, preferences.tooltips_enabled);
gtk_container_add (GTK_CONTAINER (dialog->window), main_hbox);
*/
gtk_window_set_child (GTK_WINDOW (dialog->window), main_hbox);
dialog->main_hbox = main_hbox;
dialog->advanced_vbox = advanced_vbox;
@ -1037,7 +988,7 @@ panel_build (GSGDialog * dialog)
button_new (parent, title, val, elem, dialog->tooltips, opt->desc,
SANE_OPTION_IS_SETTABLE (opt->cap));
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
case SANE_TYPE_INT:
@ -1068,7 +1019,7 @@ panel_build (GSGDialog * dialog)
(opt->cap & SANE_CAP_AUTOMATIC), elem,
dialog->tooltips, opt->desc,
SANE_OPTION_IS_SETTABLE (opt->cap));
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
case SANE_CONSTRAINT_WORD_LIST:
@ -1096,7 +1047,7 @@ panel_build (GSGDialog * dialog)
dialog->tooltips, opt->desc,
SANE_OPTION_IS_SETTABLE (opt->cap));
free (str_list);
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
case SANE_CONSTRAINT_NONE:
@ -1148,7 +1099,7 @@ panel_build (GSGDialog * dialog)
(opt->cap & SANE_CAP_AUTOMATIC), elem,
dialog->tooltips, opt->desc,
SANE_OPTION_IS_SETTABLE (opt->cap));
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
case SANE_CONSTRAINT_WORD_LIST:
@ -1167,7 +1118,7 @@ panel_build (GSGDialog * dialog)
dialog->tooltips, opt->desc,
SANE_OPTION_IS_SETTABLE (opt->cap));
free (str_list);
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
case SANE_CONSTRAINT_NONE:
@ -1204,14 +1155,14 @@ panel_build (GSGDialog * dialog)
(char **) opt->constraint.string_list, buf,
elem, dialog->tooltips, opt->desc,
SANE_OPTION_IS_SETTABLE (opt->cap));
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
case SANE_CONSTRAINT_NONE:
text_entry_new (parent, title, buf, elem,
dialog->tooltips, opt->desc,
SANE_OPTION_IS_SETTABLE (opt->cap));
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
default:
@ -1226,8 +1177,10 @@ panel_build (GSGDialog * dialog)
if ((opt->cap & SANE_CAP_ADVANCED) && !dialog->advanced)
break;
button = gtk_button_new ();
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) push_button_callback, elem);
g_signal_connect (G_OBJECT (button),
"clicked",
G_CALLBACK (push_button_callback),
elem);
set_tooltip (dialog->tooltips, button, opt->desc);
label = gtk_label_new (title);
@ -1239,7 +1192,7 @@ panel_build (GSGDialog * dialog)
gtk_widget_show (button);
elem->widget = button;
gtk_widget_show (parent->parent);
gtk_widget_show (gtk_widget_get_parent (parent));
break;
default:
@ -1420,18 +1373,14 @@ gsg_sync (GSGDialog * dialog)
if (!SANE_OPTION_IS_ACTIVE (opt->cap))
continue;
if ((opt->type != SANE_TYPE_INT) && (opt->type != SANE_TYPE_FIXED))
if (opt->type != SANE_TYPE_INT && opt->type != SANE_TYPE_FIXED)
continue;
if (opt->size == sizeof (SANE_Word))
continue;
// If curves is hidden (advanced option perhaps) then nothing to do.
if (!dialog->element[i].widget)
continue;
/* ok, we're dealing with an active vector */
/*
optlen = opt->size / sizeof (SANE_Word);
optval = alloca (optlen * sizeof (optval[0]));
vector = alloca (optlen * sizeof (vector[0]));
@ -1449,6 +1398,7 @@ gsg_sync (GSGDialog * dialog)
set_option (dialog, i, optval, SANE_ACTION_SET_VALUE);
}
*/
}
void
@ -1463,11 +1413,12 @@ gsg_set_tooltips (GSGDialog * dialog, int enable)
{
if (!dialog->tooltips)
return;
/*
if (enable)
gtk_tooltips_enable (dialog->tooltips);
else
gtk_tooltips_disable (dialog->tooltips);
*/
}
void

27
src/preview.c
Wyświetl plik

@ -602,9 +602,10 @@ input_available (gpointer data, gint source, GdkInputCondition cond)
}
else
{
snprintf (buf, sizeof (buf), "Error during read: %s.",
char errbuf[100];
snprintf (errbuf, sizeof (errbuf), "Error during read: %s.",
sane_strstatus (status));
gsg_error (buf);
gsg_error (errbuf);
}
scan_done (p);
return;
@ -822,9 +823,13 @@ input_available (gpointer data, gint source, GdkInputCondition cond)
return;
bad_depth:
snprintf (buf, sizeof (buf), "Preview cannot handle depth %d.",
p->params.depth);
gsg_error (buf);
{
char errbuf[100];
snprintf (errbuf, sizeof (errbuf), "Preview cannot handle depth %d.",
p->params.depth);
gsg_error (errbuf);
}
scan_done (p);
return;
}
@ -862,10 +867,6 @@ scan_start (Preview * p)
SANE_Status status;
char buf[256];
int fd, y;
Progress_t *progress;
#ifdef HAVE_SYS_TIME_H
struct timeval start, current;
#endif
gtk_widget_set_sensitive (p->cancel, TRUE);
gtk_widget_set_sensitive (p->preview, FALSE);
@ -887,23 +888,31 @@ scan_start (Preview * p)
gsg_sync (p->dialog);
status = sane_start (dev);
#ifdef SANE_STATUS_WARMING_UP
Progress_t *progress;
if (status == SANE_STATUS_WARMING_UP)
{
snprintf (buf, sizeof (buf), "Scanner is warming up.");
progress =
progress_new ("Warming up ...", buf, GTK_WINDOW(p->top), NULL, 0);
#ifdef HAVE_SYS_TIME_H
struct timeval start, current;
gettimeofday (&start, NULL);
#endif
while (status == SANE_STATUS_WARMING_UP)
{
#ifdef HAVE_SYS_TIME_H
gettimeofday (&current, NULL);
/* we assume that warming up won't exceed 60 seconds */
progress_update (progress,
(current.tv_sec - start.tv_sec) / (gfloat) 60);
#endif
while (gtk_events_pending ())
gtk_main_iteration ();
status = sane_start (dev);

7
src/progress.c
Wyświetl plik

@ -58,8 +58,8 @@ progress_new (char *title, char *text, GtkWindow * parent,
gtk_window_set_transient_for (GTK_WINDOW (p->shell), parent);
#endif
gtk_window_set_title (GTK_WINDOW (p->shell), title);
vbox = GTK_BOX (GTK_DIALOG (p->shell)->vbox);
hbox = GTK_BOX (GTK_DIALOG (p->shell)->action_area);
vbox = GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (p->shell)));
hbox = GTK_BOX (gtk_dialog_get_action_area(GTK_DIALOG (p->shell)));
gtk_container_border_width (GTK_CONTAINER (vbox), 7);
@ -114,7 +114,7 @@ progress_update (Progress_t * p, gfloat newval)
#ifdef HAVE_SYS_TIME_H
struct timeval tv;
int now;
char buff[40];
char buff[100];
int remaining;
#endif
@ -126,6 +126,7 @@ progress_update (Progress_t * p, gfloat newval)
gtk_progress_bar_update (GTK_PROGRESS_BAR (p->pbar), newval);
#ifdef HAVE_SYS_TIME_H
gettimeofday (&tv, NULL);
now = tv.tv_sec * 1000 + tv.tv_usec / 1000;

58
src/scanadf.c
Wyświetl plik

@ -1,6 +1,6 @@
/* saneadf - a SANE front end for document scanning
/* saneadf - a SANE front end for document scanning
based on
bnhscan by tummy.com and
bnhscan by tummy.com and
scanimage by Andreas Beck and David Mosberger
Copyright (C) 1999 Tom Martone
@ -123,7 +123,7 @@ static struct option basic_options[] =
{"help", no_argument, NULL, 'h'},
{"verbose", no_argument, NULL, 'v'},
{"version", no_argument, NULL, 'V'},
{"no-overwrite", no_argument, NULL, 'N'},
{"no-overwrite", no_argument, NULL, 'N'},
{ "output-file", required_argument, 0, 'o' },
{ "start-count", required_argument, 0, 's' },
@ -299,9 +299,9 @@ print_option (SANE_Device *device, int opt_num, char short_name)
break;
}
}
if (opt->type == SANE_TYPE_STRING ||
opt->type == SANE_TYPE_BOOL ||
opt->type == SANE_TYPE_INT ||
if (opt->type == SANE_TYPE_STRING ||
opt->type == SANE_TYPE_BOOL ||
opt->type == SANE_TYPE_INT ||
opt->type == SANE_TYPE_FIXED)
{
/* print current option value */
@ -913,23 +913,23 @@ get_resolution(SANE_Device *device)
{
opt = sane_get_option_descriptor (device, resolution_opt);
sane_control_option (device, resolution_opt,
sane_control_option (device, resolution_opt,
SANE_ACTION_GET_VALUE, &val, 0);
switch (opt->type)
{
case SANE_TYPE_INT:
res = val;
break;
case SANE_TYPE_FIXED:
res = (SANE_Int) SANE_UNFIX(val);
break;
case SANE_TYPE_STRING:
case SANE_TYPE_BOOL:
default:
if (verbose)
fprintf(stderr,
fprintf(stderr,
"Peculiar option data type for resolution, "
"using default value.\n");
break;
@ -1002,9 +1002,9 @@ exec_script (const char *script, const char* fname, SANE_Bool use_pipe,
}
/*signal(SIGCHLD, SIG_IGN);*/
switch ((pid = fork()))
switch ((pid = fork()))
{
case -1:
case -1:
/* fork failed */
fprintf(stderr, "Error forking: %s (%d)\n", strerror(errno), errno);
break;
@ -1017,9 +1017,9 @@ exec_script (const char *script, const char* fname, SANE_Bool use_pipe,
sprintf(cmd, "%s '%s'", script, fname);
execle(script, script, fname, NULL, environ);
exit(0);
default:
if (verbose)
if (verbose)
fprintf(stderr, "Started script `%s' as pid=%d\n", script, pid);
break;
}
@ -1149,7 +1149,7 @@ scan_it_raw (const char *fname, SANE_Bool raw, const char *script,
}
else
{
write_pnm_header_to_file (fp, parm.format,
write_pnm_header_to_file (fp, parm.format,
parm.pixels_per_line,
parm.lines, parm.depth);
}
@ -1174,7 +1174,7 @@ scan_it_raw (const char *fname, SANE_Bool raw, const char *script,
#endif
default:
/* Default action for unknown frametypes; write them out
/* Default action for unknown frametypes; write them out
* without a header; issue a warning in verbose mode.
* Since we're not writing a header, there's no need to
* buffer.
@ -1210,7 +1210,7 @@ scan_it_raw (const char *fname, SANE_Bool raw, const char *script,
else
image.height = 0;
image.Bpp = 3;
if (parm.format == SANE_FRAME_GRAY ||
if (parm.format == SANE_FRAME_GRAY ||
!sane_isbasicframe(parm.format))
image.Bpp = 1;
image.x = image.width - 1;
@ -1226,7 +1226,7 @@ scan_it_raw (const char *fname, SANE_Bool raw, const char *script,
offset = parm.format - SANE_FRAME_RED;
image.x = image.y = 0;
}
while (1)
{
status = sane_read (device, buffer, sizeof (buffer), &len);
@ -1309,13 +1309,13 @@ scan_it_raw (const char *fname, SANE_Bool raw, const char *script,
if (raw == SANE_FALSE)
{
/* if we're writing raw, we skip the header */
write_pnm_header_to_file (fp, parm.format, image.width,
write_pnm_header_to_file (fp, parm.format, image.width,
image.height, parm.depth);
}
fwrite (image.data, image.Bpp, image.height * image.width, fp);
}
if (fp)
if (fp)
{
fclose(fp);
fp = NULL;
@ -1340,7 +1340,7 @@ cleanup:
return status;
}
static SANE_Int
static SANE_Int
scan_docs (int start, int end, int no_overwrite, SANE_Bool raw,
const char *outfmt, const char *script, SANE_Bool use_pipe)
{
@ -1350,27 +1350,27 @@ scan_docs (int start, int end, int no_overwrite, SANE_Bool raw,
struct stat statbuf;
int res;
while (end < 0 || start <= end)
while (end < 0 || start <= end)
{
snprintf(fname, sizeof (fname), outfmt, start);
/* does the filename already exist? */
if (no_overwrite)
if (no_overwrite)
{
res = stat (fname, &statbuf);
if (res == 0)
if (res == 0)
{
status = SANE_STATUS_INVAL;
fprintf (stderr, "Filename %s already exists; will not overwrite\n", fname);
}
}
/* Scan the document */
if (status == SANE_STATUS_GOOD)
if (status == SANE_STATUS_GOOD)
status = scan_it_raw(fname, raw, script, use_pipe);
/* Any scan errors? */
if (status == SANE_STATUS_NO_DOCS)
if (status == SANE_STATUS_NO_DOCS)
{
/* out of paper in the hopper; this is our normal exit */
status = SANE_STATUS_GOOD;
@ -1384,7 +1384,7 @@ scan_docs (int start, int end, int no_overwrite, SANE_Bool raw,
scannedPages++;
start++;
}
else
else
{
/* unexpected error */
fprintf(stderr, "%s\n", sane_strstatus(status));
@ -1709,11 +1709,9 @@ List of available devices:", prog_name);
sane_cancel (device);
sane_close (device);
sane_exit();
if (scriptWait)
while (wait(NULL) != -1);
return (status == SANE_STATUS_GOOD) ? 0 : 1;
}

35
src/xcam.c
Wyświetl plik

@ -1,9 +1,9 @@
/* xcam -- X-based camera frontend
Uses the SANE library.
Copyright (C) 1997 David Mosberger and Tristan Tarrant
Update 2005 Gerard Klaver
The add_text routine and font_6x11.h file are taken from the (GPLed)
The add_text routine and font_6x11.h file are taken from the (GPLed)
webcam.c file, part of xawtv, (c) 1998-2002 Gerd Knorr.
add_text was modified for this program (xcam_add_text).
Update 2008 Gerard Klaver
@ -326,9 +326,9 @@ save_settings (const char *filename)
}
#define MSG_MAXLEN 45
#define CHAR_HEIGHT 11
#define CHAR_WIDTH 6
#define CHAR_START 4
#define TEXT_HEIGHT 11
#define TEXT_WIDTH 6
#define TEXT_START 4
static SANE_Status
xcam_add_text (SANE_Byte * image, int width, int height, char *txt)
@ -359,16 +359,16 @@ xcam_add_text (SANE_Byte * image, int width, int height, char *txt)
{
case SANE_FRAME_RGB:
for (y = 0; y < CHAR_HEIGHT; y++)
for (y = 0; y < TEXT_HEIGHT; y++)
{
ptr = image + 3 * width * (height - CHAR_HEIGHT - 2 + y) + 12;
ptr = image + 3 * width * (height - TEXT_HEIGHT - 2 + y) + 12;
for (x = 0; x < len; x++)
{
f = fontdata[line[x] * CHAR_HEIGHT + y];
for (i = CHAR_WIDTH - 1; i >= 0; i--)
f = fontdata[line[x] * TEXT_HEIGHT + y];
for (i = TEXT_WIDTH - 1; i >= 0; i--)
{
if (f & (CHAR_START << i))
if (f & (TEXT_START << i))
{
ptr[0] = 255;
ptr[1] = 255;
@ -381,29 +381,32 @@ xcam_add_text (SANE_Byte * image, int width, int height, char *txt)
break;
case SANE_FRAME_GRAY:
for (y = 0; y < CHAR_HEIGHT; y++)
for (y = 0; y < TEXT_HEIGHT; y++)
{
ptr = image + width * (height - CHAR_HEIGHT - 2 + y) + 12;
ptr = image + width * (height - TEXT_HEIGHT - 2 + y) + 12;
for (x = 0; x < len; x++)
{
f = fontdata[line[x] * CHAR_HEIGHT + y];
for (i = CHAR_WIDTH - 1; i >= 0; i--)
f = fontdata[line[x] * TEXT_HEIGHT + y];
for (i = TEXT_WIDTH - 1; i >= 0; i--)
{
if (f & (CHAR_START << i))
if (f & (TEXT_START << i))
{
ptr[0] = 255;
}
ptr += 1;
} /* for i */
} /* for x */
} /* for y */
} /* for y */
break;
case SANE_FRAME_RED:
case SANE_FRAME_GREEN:
case SANE_FRAME_BLUE:
snprintf (buf, sizeof (buf),
"Time stamp for separate channel transfers are not supported");
break;
default:
snprintf (buf, sizeof (buf),
"Unsupported image format %d", win.params.format);

31
src/xscanimage.c
Wyświetl plik

@ -640,7 +640,7 @@ scan_preview (GtkWidget * widget, gpointer call_data)
{
DBG (DBG_debug, "scan_preview\n");
if (GTK_TOGGLE_BUTTON (widget)->active)
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget)))
{
if (!scan_win.preview)
{
@ -1043,10 +1043,6 @@ scan_start (void)
SANE_Word resolution;
#endif /* HAVE_LIBGIMP_GIMP_H */
#ifdef HAVE_SYS_TIME_H
struct timeval start, current;
#endif
const char *frame_type = 0;
char buf[256];
int fd;
@ -1104,6 +1100,7 @@ scan_start (void)
scan_win.progress = progress_new ("Warming up ...", buf, scan_win.shell,
(GtkSignalFunc) cancel_action, NULL);
#ifdef HAVE_SYS_TIME_H
struct timeval start, current;
gettimeofday(&start,NULL);
#endif
while (status == SANE_STATUS_WARMING_UP)
@ -1436,7 +1433,7 @@ update_int_callback (GtkWidget * widget, gpointer data)
{
int *valuep = data;
*valuep = (GTK_TOGGLE_BUTTON (widget)->active != 0);
*valuep = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget)) != 0);
}
static void
@ -1505,7 +1502,7 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
sprintf (buf, "%s preview options", prog_name);
gtk_window_set_title (GTK_WINDOW (dialog), buf);
vbox = GTK_DIALOG (dialog)->vbox;
vbox = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
/* preserve preview image: */
@ -1557,10 +1554,10 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
gtk_widget_show (text);
/* fill in action area: */
hbox = GTK_DIALOG (dialog)->action_area;
hbox = gtk_dialog_get_action_area(GTK_DIALOG (dialog));
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_set_can_default (button, TRUE);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) preview_options_ok_callback, dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
@ -1625,7 +1622,7 @@ pref_device_restore (void)
static void
pref_toggle_advanced (GtkWidget * widget, gpointer data)
{
preferences.advanced = (GTK_CHECK_MENU_ITEM (widget)->active != 0);
preferences.advanced = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (widget));
gsg_set_advanced (dialog, preferences.advanced);
pref_xscanimage_save ();
}
@ -1633,7 +1630,7 @@ pref_toggle_advanced (GtkWidget * widget, gpointer data)
static void
pref_toggle_tooltips (GtkWidget * widget, gpointer data)
{
preferences.tooltips_enabled = (GTK_CHECK_MENU_ITEM (widget)->active != 0);
preferences.tooltips_enabled = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (widget));
gsg_set_tooltips (dialog, preferences.tooltips_enabled);
pref_xscanimage_save ();
}
@ -1641,7 +1638,7 @@ pref_toggle_tooltips (GtkWidget * widget, gpointer data)
static void
pref_toggle_twocolumn (GtkWidget * widget, gpointer data)
{
preferences.twocolumn_enabled = (GTK_CHECK_MENU_ITEM (widget)->active != 0);
preferences.twocolumn_enabled = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (widget));
gsg_set_twocolumn (dialog, preferences.twocolumn_enabled);
pref_xscanimage_save ();
}
@ -1810,7 +1807,7 @@ device_dialog (void)
GTK_SIGNAL_FUNC (scan_win_delete), NULL);
/* create the main vbox */
vbox = GTK_DIALOG (scan_win.shell)->vbox;
vbox = gtk_dialog_get_content_area(GTK_DIALOG (scan_win.shell));
/* create the menubar */
@ -1910,7 +1907,7 @@ device_dialog (void)
update_param (dialog, 0);
/* The bottom row of buttons */
hbox = GTK_DIALOG (scan_win.shell)->action_area;
hbox = gtk_dialog_get_action_area(GTK_DIALOG (scan_win.shell));
/* The Scan button */
scan_win.scan_button = gtk_button_new_with_label ("Scan");
@ -1980,7 +1977,7 @@ choose_device (void)
gtk_signal_connect (GTK_OBJECT (choose_device_dialog), "delete_event",
GTK_SIGNAL_FUNC (files_exit_callback), NULL);
main_vbox = GTK_DIALOG (choose_device_dialog)->vbox;
main_vbox = gtk_dialog_get_content_area(GTK_DIALOG (choose_device_dialog));
/* The list of drivers */
vbox = gtk_vbox_new (FALSE, 5);
@ -2006,11 +2003,11 @@ choose_device (void)
}
/* The bottom row of buttons */
hbox = GTK_DIALOG (choose_device_dialog)->action_area;
hbox = gtk_dialog_get_action_area(GTK_DIALOG (choose_device_dialog));
/* The OK button */
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_set_can_default (button, TRUE);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) ok_choose_dialog_callback, NULL);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);