kopia lustrzana https://gitlab.com/sane-project/frontends
1926 wiersze
50 KiB
C
1926 wiersze
50 KiB
C
/* 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)
|
|
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
|
|
Added add_text routine to gray images.
|
|
|
|
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. */
|
|
|
|
#include "../include/sane/config.h"
|
|
|
|
#include "../include/lalloca.h"
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <getopt.h>
|
|
#include <limits.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
|
|
/* for xcam_add-text routine */
|
|
#include "font_6x11.h"
|
|
/*-----------------------*/
|
|
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include "gtkglue.h"
|
|
#include "preferences.h"
|
|
|
|
#include <sane/sane.h>
|
|
#include <sane/saneopts.h>
|
|
#include "../include/sane/sanei.h"
|
|
|
|
#define BACKEND_NAME xcam
|
|
#include "../include/sane/sanei_debug.h"
|
|
|
|
#ifndef PATH_MAX
|
|
# define PATH_MAX 1024
|
|
#endif
|
|
|
|
#define OUTFILENAME "out.pnm"
|
|
|
|
#define MAX_LUM 64 /* how many graylevels for 8 bit displays */
|
|
|
|
#ifndef HAVE_ATEXIT
|
|
# define atexit(func) on_exit(func, 0) /* works for SunOS, at least */
|
|
#endif
|
|
|
|
typedef struct Canvas
|
|
{
|
|
GtkWidget *preview;
|
|
GdkGC *gc;
|
|
GdkImage *gdk_image;
|
|
GdkColormap *graylevel_cmap; /* for 8 bit displays */
|
|
guint32 graylevel[MAX_LUM]; /* graylevel pixels */
|
|
GdkColormap *cube_cmap;
|
|
GdkColor cube_colors[5 * 6 * 5];
|
|
}
|
|
Canvas;
|
|
|
|
static const char *prog_name;
|
|
static const SANE_Device **device;
|
|
static GSGDialog *dialog;
|
|
static char device_settings_filename[1024] = "device.rc";
|
|
|
|
#define DBG_fatal 0
|
|
#define DBG_error 1
|
|
#define DBG_warning 2
|
|
#define DBG_info 3
|
|
#define DBG_debug 4
|
|
|
|
static struct
|
|
{
|
|
GtkWidget *shell;
|
|
GtkWidget *dialog_box;
|
|
GtkWidget *play_stop_label;
|
|
GtkWidget *info_label;
|
|
GtkWidget *device_info_label;
|
|
GtkWidget *save_frame_label;
|
|
GtkWidget *rgb_bgr_label;
|
|
GtkWidget *txt_label;
|
|
struct
|
|
{
|
|
GtkWidget *item; /* the menu bar item */
|
|
GtkWidget *menu; /* the associated menu */
|
|
}
|
|
devices;
|
|
Canvas canvas;
|
|
gint gdk_input_tag; /* tag returned by gdk_input_add () */
|
|
int playing; /* are we playing video? */
|
|
int saving; /* are we saving to file */
|
|
|
|
SANE_Byte *buf;
|
|
size_t buf_backend_size;
|
|
size_t remaining;
|
|
SANE_Parameters params;
|
|
gpointer data; /* image data */
|
|
int x, y; /* x and y position */
|
|
int input_tag;
|
|
/* for standalone mode: */
|
|
GtkWidget *filename_entry;
|
|
FILE *out;
|
|
long header_size;
|
|
gboolean have_odd_byte;
|
|
guint8 odd_byte;
|
|
|
|
int num_bytes;
|
|
int bytes_read;
|
|
char picmsg_ps[50];
|
|
int value_rgb;
|
|
int value_txt;
|
|
|
|
double fps;
|
|
double fps_av;
|
|
double fps_old1;
|
|
double fps_old2;
|
|
double fps_old3;
|
|
long f_count;
|
|
time_t time1;
|
|
time_t time2;
|
|
int i_time;
|
|
}
|
|
win;
|
|
|
|
/* forward declarations: */
|
|
int main (int argc, char **argv);
|
|
|
|
static void rescan_devices (GtkWidget * widget, gpointer client_data,
|
|
gpointer call_data);
|
|
static void next_frame (void);
|
|
|
|
static void save_frame (void);
|
|
|
|
static void update_param (GSGDialog * dialog, void *arg);
|
|
|
|
static void load_defaults (int silent);
|
|
|
|
static struct option long_options[] = {
|
|
{"help", no_argument, NULL, 'h'},
|
|
{"version", no_argument, NULL, 'V'},
|
|
{"buffersize", no_argument, NULL, 'B'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
/* Test if this machine is little endian (from coolscan.c) */
|
|
/* static gboolean
|
|
calc_little_endian (void)
|
|
{
|
|
SANE_Int testvalue = 255;
|
|
u_int8_t *firstbyte = (u_int8_t *) & testvalue;
|
|
|
|
if (*firstbyte == 255)
|
|
return TRUE;
|
|
return FALSE;
|
|
} */
|
|
|
|
#define CANVAS_EVENT_MASK GDK_BUTTON1_MOTION_MASK | \
|
|
GDK_EXPOSURE_MASK | \
|
|
GDK_BUTTON_PRESS_MASK | \
|
|
GDK_ENTER_NOTIFY_MASK
|
|
|
|
static void
|
|
display_image (Canvas * canvas)
|
|
{
|
|
if (canvas->gdk_image)
|
|
{
|
|
gdk_draw_image (canvas->preview->window, canvas->gc, canvas->gdk_image,
|
|
0, 0, 0, 0,
|
|
canvas->gdk_image->width, canvas->gdk_image->height);
|
|
gdk_flush ();
|
|
}
|
|
}
|
|
|
|
static gint
|
|
canvas_events (GtkWidget * widget, GdkEvent * event)
|
|
{
|
|
Canvas *canvas = &win.canvas;
|
|
if (!canvas)
|
|
return FALSE;
|
|
|
|
switch (event->type)
|
|
{
|
|
case GDK_EXPOSE:
|
|
if (!canvas->gc)
|
|
canvas->gc = gdk_gc_new (canvas->preview->window);
|
|
display_image (canvas);
|
|
break;
|
|
|
|
case GDK_BUTTON_PRESS:
|
|
break;
|
|
|
|
case GDK_BUTTON_RELEASE:
|
|
break;
|
|
|
|
case GDK_MOTION_NOTIFY:
|
|
break;
|
|
|
|
case GDK_ENTER_NOTIFY:
|
|
#if 0
|
|
gdk_colors_store (win.canvas.cube_cmap, win.canvas.cube_colors,
|
|
NELEMS (win.canvas.cube_colors));
|
|
#endif
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
stop_camera (void)
|
|
{
|
|
DBG (DBG_debug, "xcam: stop_camera: enter\n");
|
|
|
|
if (dialog)
|
|
sane_cancel (gsg_dialog_get_device (dialog));
|
|
if (win.gdk_input_tag >= 0)
|
|
{
|
|
gdk_input_remove (win.gdk_input_tag);
|
|
}
|
|
else
|
|
win.playing = FALSE;
|
|
win.gdk_input_tag = -1;
|
|
if (!win.playing)
|
|
gtk_label_set (GTK_LABEL (win.play_stop_label), " Play ");
|
|
else
|
|
gtk_label_set (GTK_LABEL (win.play_stop_label), " Stop ");
|
|
|
|
DBG (DBG_debug, "xcam: stop_camera: exit\n");
|
|
}
|
|
|
|
static void
|
|
switch_device (const SANE_Device * dev)
|
|
{
|
|
char buf[512];
|
|
|
|
DBG (DBG_debug, "xcam: switch_device: enter\n");
|
|
if (win.playing)
|
|
{
|
|
win.playing = FALSE;
|
|
stop_camera ();
|
|
}
|
|
|
|
if (dialog)
|
|
gsg_destroy_dialog (dialog);
|
|
|
|
dialog = gsg_create_dialog (GTK_WIDGET (win.dialog_box), dev->name,
|
|
0, 0, 0, 0);
|
|
buf[0] = '\0';
|
|
|
|
if (dialog)
|
|
sprintf (buf, "%s %s %s", dev->vendor, dev->model, dev->type);
|
|
gtk_label_set (GTK_LABEL (win.device_info_label), buf);
|
|
DBG (DBG_debug, "xcam: switch_device: exit\n");
|
|
}
|
|
|
|
static void
|
|
switch_device_by_name (const char *device_name)
|
|
{
|
|
SANE_Device dev_info;
|
|
int i;
|
|
|
|
DBG (DBG_debug, "xcam: switch_device_by_name: enter\n");
|
|
for (i = 0; device[i]; ++i)
|
|
if (strcmp (device[i]->name, device_name) == 0)
|
|
{
|
|
switch_device (device[i]);
|
|
return;
|
|
}
|
|
|
|
/* the backends don't know about this device yet---make up an entry: */
|
|
dev_info.name = device_name;
|
|
dev_info.vendor = "Unknown";
|
|
dev_info.model = "";
|
|
dev_info.type = "";
|
|
switch_device (&dev_info);
|
|
DBG (DBG_debug, "xcam: switch_device_by_name: exit\n");
|
|
}
|
|
|
|
static void
|
|
save_settings (const char *filename)
|
|
{
|
|
int fd;
|
|
|
|
DBG (DBG_debug, "xcam: save_settings: enter\n");
|
|
|
|
fd = open (filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
|
if (fd < 0)
|
|
{
|
|
char buf[256];
|
|
|
|
snprintf (buf, sizeof (buf), "Failed to create file: %s.",
|
|
strerror (errno));
|
|
gsg_error (buf);
|
|
return;
|
|
}
|
|
write (fd, dialog->dev_name, strlen (dialog->dev_name));
|
|
write (fd, "\n", 1);
|
|
sanei_save_values (fd, dialog->dev);
|
|
close (fd);
|
|
DBG (DBG_debug, "xcam: save_settings: exit\n");
|
|
}
|
|
|
|
#define MSG_MAXLEN 45
|
|
#define CHAR_HEIGHT 11
|
|
#define CHAR_WIDTH 6
|
|
#define CHAR_START 4
|
|
|
|
static SANE_Status
|
|
xcam_add_text (SANE_Byte * image, int width, int height, char *txt)
|
|
{
|
|
SANE_Status status;
|
|
time_t t;
|
|
struct tm *tm;
|
|
char line[MSG_MAXLEN + 1];
|
|
SANE_Byte *ptr;
|
|
int i, x, y, f, len;
|
|
char fmtstring[25] = " %Y-%m-%d %H:%M:%S";
|
|
char fmttxt[46];
|
|
char buf[100];
|
|
|
|
|
|
DBG (DBG_debug, "xcam_add_text: enter\n");
|
|
time (&t);
|
|
tm = localtime (&t);
|
|
if (strlen (txt) > (MSG_MAXLEN - 23))
|
|
strncpy (fmttxt, txt, (MSG_MAXLEN - 23));
|
|
else
|
|
strcpy (fmttxt, txt);
|
|
strcat (fmttxt, fmtstring);
|
|
|
|
len = strftime (line, MSG_MAXLEN, fmttxt, tm);
|
|
|
|
switch (win.params.format)
|
|
{
|
|
case SANE_FRAME_RGB:
|
|
|
|
for (y = 0; y < CHAR_HEIGHT; y++)
|
|
{
|
|
ptr = image + 3 * width * (height - CHAR_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--)
|
|
{
|
|
if (f & (CHAR_START << i))
|
|
{
|
|
ptr[0] = 255;
|
|
ptr[1] = 255;
|
|
ptr[2] = 255;
|
|
}
|
|
ptr += 3;
|
|
} /* for i */
|
|
} /* for x */
|
|
} /* for y */
|
|
break;
|
|
case SANE_FRAME_GRAY:
|
|
|
|
for (y = 0; y < CHAR_HEIGHT; y++)
|
|
{
|
|
ptr = image + width * (height - CHAR_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--)
|
|
{
|
|
if (f & (CHAR_START << i))
|
|
{
|
|
ptr[0] = 255;
|
|
}
|
|
ptr += 1;
|
|
} /* for i */
|
|
} /* for x */
|
|
} /* for y */
|
|
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);
|
|
DBG (DBG_error, "xcam_add_text: unsupported image format %d\n",
|
|
win.params.format);
|
|
status = SANE_STATUS_INVAL;
|
|
}
|
|
DBG (DBG_debug, "xcam_add_text: exit vw=%d, vh=%d\n", width, height);
|
|
status = SANE_STATUS_GOOD;
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
/* Update the info line with the latest size information. */
|
|
static void
|
|
update_param (GSGDialog * dialog, void *arg)
|
|
{
|
|
gchar buf[200];
|
|
|
|
DBG (DBG_debug, "xcam: update_param: enter\n");
|
|
|
|
if (dialog == NULL)
|
|
return;
|
|
|
|
if (!win.info_label)
|
|
return;
|
|
|
|
if (sane_get_parameters (gsg_dialog_get_device (dialog), &win.params)
|
|
== SANE_STATUS_GOOD)
|
|
{
|
|
double size =
|
|
(double) win.params.bytes_per_line * (double) win.params.lines;
|
|
const char *unit = "B";
|
|
|
|
if (win.params.lines == -1)
|
|
{
|
|
snprintf (buf, sizeof (buf), "%dxunknown: unknown size",
|
|
win.params.pixels_per_line);
|
|
}
|
|
else
|
|
{
|
|
if (win.params.format >= SANE_FRAME_RED
|
|
&& win.params.format <= SANE_FRAME_BLUE)
|
|
size *= 3;
|
|
|
|
if (size >= 1024 * 1024)
|
|
{
|
|
size /= 1024 * 1024;
|
|
unit = "MByte";
|
|
}
|
|
else if (size >= 1024)
|
|
{
|
|
size /= 1024;
|
|
unit = "kByte";
|
|
}
|
|
snprintf (buf, sizeof (buf),
|
|
"%dx%d %1.1f %s \n%6ld f_count\n%2.2f fps %2.2f fps_av",
|
|
win.params.pixels_per_line, win.params.lines, size, unit,
|
|
win.f_count, win.fps, win.fps_av);
|
|
}
|
|
}
|
|
else
|
|
snprintf (buf, sizeof (buf), "Invalid parameters.");
|
|
gtk_label_set (GTK_LABEL (win.info_label), buf);
|
|
|
|
DBG (DBG_debug, "xcam: update_param: exit\n");
|
|
}
|
|
|
|
static void
|
|
pref_xcam_save (void)
|
|
{
|
|
char filename[PATH_MAX];
|
|
int fd;
|
|
|
|
DBG (DBG_debug, "xcam: pref_xcam_save: enter\n");
|
|
/* first save xcam-specific preferences: */
|
|
gsg_make_path (sizeof (filename), filename, "xcam", "xcam", 0, ".rc");
|
|
fd = open (filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
|
if (fd < 0)
|
|
{
|
|
char buf[256];
|
|
|
|
snprintf (buf, sizeof (buf), "Failed to create file: %s.",
|
|
strerror (errno));
|
|
gsg_error (buf);
|
|
return;
|
|
}
|
|
preferences_save (fd);
|
|
close (fd);
|
|
DBG (DBG_debug, "xcam: pref_xcam_save: exit\n");
|
|
}
|
|
|
|
static void
|
|
pref_xcam_restore (void)
|
|
{
|
|
char filename[PATH_MAX];
|
|
int fd;
|
|
|
|
DBG (DBG_debug, "xcam: pref_xcam_restore: enter\n");
|
|
gsg_make_path (sizeof (filename), filename, "xcam", "xcam", 0, ".rc");
|
|
fd = open (filename, O_RDONLY);
|
|
if (fd >= 0)
|
|
{
|
|
preferences_restore (fd);
|
|
close (fd);
|
|
}
|
|
if (!preferences.filename)
|
|
preferences.filename = strdup (OUTFILENAME);
|
|
DBG (DBG_debug, "xcam: pref_xcam_restore: exit\n");
|
|
}
|
|
|
|
|
|
static void
|
|
load_settings (const char *filename, int silent)
|
|
{
|
|
char buf[2 * PATH_MAX];
|
|
char *end;
|
|
int fd;
|
|
|
|
DBG (DBG_debug, "xcam: load_settings: enter\n");
|
|
|
|
fd = open (filename, O_RDONLY);
|
|
if (fd < 0)
|
|
{
|
|
if (!silent)
|
|
{
|
|
snprintf (buf, sizeof (buf), "Failed to open file %s: %s.",
|
|
filename, strerror (errno));
|
|
gsg_error (buf);
|
|
}
|
|
return; /* fail silently */
|
|
}
|
|
|
|
/* first, read off the devicename that these settings are for: */
|
|
read (fd, buf, sizeof (buf));
|
|
buf[sizeof (buf) - 1] = '\0';
|
|
end = strchr (buf, '\n');
|
|
if (!end)
|
|
{
|
|
if (!silent)
|
|
{
|
|
snprintf (buf, sizeof (buf), "File %s is malformed.", filename);
|
|
gsg_error (buf);
|
|
}
|
|
return;
|
|
}
|
|
*end = '\0';
|
|
if (strcmp (dialog->dev_name, buf) != 0)
|
|
switch_device_by_name (buf);
|
|
|
|
/* position right behind device name: */
|
|
lseek (fd, strlen (buf) + 1, SEEK_SET);
|
|
|
|
sanei_load_values (fd, dialog->dev);
|
|
close (fd);
|
|
|
|
gsg_refresh_dialog (dialog);
|
|
|
|
DBG (DBG_debug, "xcam: load_settings: exit\n");
|
|
}
|
|
|
|
static int
|
|
make_default_filename (size_t buf_size, char *buf, const char *dev_name)
|
|
{
|
|
return gsg_make_path (buf_size, buf, "xcam", 0, dev_name, ".rc");
|
|
}
|
|
|
|
static void
|
|
load_defaults (int silent)
|
|
{
|
|
char filename[PATH_MAX];
|
|
|
|
DBG (DBG_debug, "xcam, load_defaults: enter\n");
|
|
if (make_default_filename (sizeof (filename), filename, dialog->dev_name)
|
|
< 0)
|
|
return;
|
|
|
|
load_settings (filename, silent);
|
|
|
|
DBG (DBG_debug, "xcam, load_defaults: exit\n");
|
|
}
|
|
|
|
void
|
|
device_name_dialog_cancel (GtkWidget * widget, gpointer data)
|
|
{
|
|
gtk_widget_destroy (data);
|
|
}
|
|
|
|
void
|
|
device_name_dialog_ok (GtkWidget * widget, gpointer data)
|
|
{
|
|
GtkWidget *text = data;
|
|
const char *name;
|
|
|
|
name = gtk_entry_get_text (GTK_ENTRY (text));
|
|
if (!name)
|
|
return; /* huh? how come? */
|
|
switch_device_by_name (name);
|
|
|
|
gtk_widget_destroy (gtk_widget_get_toplevel (text));
|
|
}
|
|
|
|
static void
|
|
prompt_for_device_name (GtkWidget * widget, gpointer data)
|
|
{
|
|
GtkWidget *vbox, *hbox, *label, *text;
|
|
GtkWidget *button, *dialog;
|
|
|
|
DBG (DBG_debug, "xcam: prompt_for_device_name: enter\n");
|
|
|
|
dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
|
gtk_window_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
gtk_window_set_title (GTK_WINDOW (dialog), "Device name");
|
|
|
|
/* create the main vbox */
|
|
vbox = gtk_vbox_new (TRUE, 5);
|
|
gtk_container_border_width (GTK_CONTAINER (vbox), 5);
|
|
gtk_container_add (GTK_CONTAINER (dialog), vbox);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 0);
|
|
gtk_container_add (GTK_CONTAINER (vbox), hbox);
|
|
|
|
label = gtk_label_new ("Device name:");
|
|
gtk_container_add (GTK_CONTAINER (hbox), label);
|
|
gtk_widget_show (label);
|
|
|
|
text = gtk_entry_new ();
|
|
gtk_container_add (GTK_CONTAINER (hbox), text);
|
|
|
|
gtk_widget_show (hbox);
|
|
|
|
/* the confirmation button */
|
|
hbox = gtk_hbox_new (FALSE, 0);
|
|
gtk_container_add (GTK_CONTAINER (vbox), hbox);
|
|
|
|
button = gtk_button_new_with_label ("OK");
|
|
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
|
|
gtk_signal_connect (GTK_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",
|
|
(GtkSignalFunc) device_name_dialog_cancel, dialog);
|
|
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_show (hbox);
|
|
gtk_widget_show (text);
|
|
gtk_widget_show (vbox);
|
|
gtk_widget_show (dialog);
|
|
DBG (DBG_debug, "xcam: prompt_for_device_name: exit\n");
|
|
}
|
|
|
|
static void
|
|
exit_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
if (dialog)
|
|
gsg_destroy_dialog (dialog);
|
|
dialog = 0;
|
|
exit (0);
|
|
}
|
|
|
|
static void
|
|
save_defaults_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
char buf[PATH_MAX];
|
|
|
|
if (make_default_filename (sizeof (buf), buf, dialog->dev_name) < 0)
|
|
return;
|
|
save_settings (buf);
|
|
}
|
|
|
|
static void
|
|
load_defaults_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
load_defaults (0);
|
|
}
|
|
|
|
static void
|
|
save_as_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
if (gsg_get_filename ("File to save settings to", device_settings_filename,
|
|
sizeof (device_settings_filename),
|
|
device_settings_filename) < 0)
|
|
return;
|
|
save_settings (device_settings_filename);
|
|
}
|
|
|
|
static void
|
|
load_from_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
if (gsg_get_filename
|
|
("File to load settings from", device_settings_filename,
|
|
sizeof (device_settings_filename), device_settings_filename) < 0)
|
|
return;
|
|
load_settings (device_settings_filename, 0);
|
|
}
|
|
|
|
static void
|
|
buttons_disable (void)
|
|
{
|
|
|
|
DBG (DBG_debug, "xcam: buttons_disable: enter\n");
|
|
|
|
gsg_set_sensitivity (dialog, FALSE);
|
|
gtk_widget_set_sensitive (win.play_stop_label, FALSE);
|
|
gtk_widget_set_sensitive (win.save_frame_label, FALSE);
|
|
gtk_widget_set_sensitive (win.rgb_bgr_label, FALSE);
|
|
gtk_widget_set_sensitive (win.txt_label, FALSE);
|
|
|
|
DBG (DBG_debug, "xcam: buttons_disable: exit\n");
|
|
}
|
|
|
|
static void
|
|
buttons_enable (void)
|
|
{
|
|
|
|
DBG (DBG_debug, "xcam: buttons_enable: enter\n");
|
|
|
|
gsg_set_sensitivity (dialog, TRUE);
|
|
gtk_widget_set_sensitive (win.play_stop_label, TRUE);
|
|
gtk_widget_set_sensitive (win.save_frame_label, TRUE);
|
|
gtk_widget_set_sensitive (win.rgb_bgr_label, TRUE);
|
|
gtk_widget_set_sensitive (win.txt_label, TRUE);
|
|
|
|
DBG (DBG_debug, "xcam: buttons_enable: exit\n");
|
|
}
|
|
|
|
static GtkWidget *
|
|
build_files_menu (void)
|
|
{
|
|
GtkWidget *menu, *item;
|
|
|
|
DBG (DBG_debug, "xcam: build_files_menu: enter\n");
|
|
|
|
menu = gtk_menu_new ();
|
|
|
|
item = gtk_menu_item_new ();
|
|
gtk_container_add (GTK_CONTAINER (menu), item);
|
|
gtk_widget_show (item);
|
|
|
|
item = gtk_menu_item_new_with_label ("Exit");
|
|
gtk_container_add (GTK_CONTAINER (menu), item);
|
|
gtk_signal_connect (GTK_OBJECT (item), "activate",
|
|
(GtkSignalFunc) exit_callback, 0);
|
|
gtk_widget_show (item);
|
|
|
|
DBG (DBG_debug, "xcam: build_files_menu: exit\n");
|
|
return menu;
|
|
}
|
|
|
|
static gint
|
|
delayed_switch (gpointer data)
|
|
{
|
|
switch_device (data);
|
|
load_defaults (1);
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
device_activate_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
gtk_idle_add (delayed_switch, data);
|
|
}
|
|
|
|
static GtkWidget *
|
|
build_device_menu (void)
|
|
{
|
|
GtkWidget *menu, *item;
|
|
SANE_Status status;
|
|
int i;
|
|
|
|
menu = gtk_menu_new ();
|
|
|
|
status = sane_get_devices (&device, SANE_FALSE);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
fprintf (stderr, "%s: %s\n", prog_name, sane_strstatus (status));
|
|
exit (1);
|
|
}
|
|
|
|
for (i = 0; device[i]; ++i)
|
|
{
|
|
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",
|
|
(GtkSignalFunc) device_activate_callback,
|
|
(gpointer) device[i]);
|
|
gtk_widget_show (item);
|
|
}
|
|
|
|
item = gtk_menu_item_new ();
|
|
gtk_container_add (GTK_CONTAINER (menu), item);
|
|
gtk_widget_show (item);
|
|
|
|
item = gtk_menu_item_new_with_label ("Refresh device list...");
|
|
gtk_signal_connect (GTK_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",
|
|
(GtkSignalFunc) prompt_for_device_name, 0);
|
|
gtk_container_add (GTK_CONTAINER (menu), item);
|
|
gtk_widget_show (item);
|
|
|
|
return menu;
|
|
}
|
|
|
|
static void
|
|
pref_toggle_advanced (GtkWidget * widget, gpointer data)
|
|
{
|
|
preferences.advanced = (GTK_CHECK_MENU_ITEM (widget)->active != 0);
|
|
gsg_set_advanced (dialog, preferences.advanced);
|
|
pref_xcam_save ();
|
|
}
|
|
|
|
static void
|
|
pref_toggle_tooltips (GtkWidget * widget, gpointer data)
|
|
{
|
|
preferences.tooltips_enabled = (GTK_CHECK_MENU_ITEM (widget)->active != 0);
|
|
gsg_set_tooltips (dialog, preferences.tooltips_enabled);
|
|
pref_xcam_save ();
|
|
}
|
|
|
|
static void
|
|
pref_toggle_twocolumn (GtkWidget * widget, gpointer data)
|
|
{
|
|
preferences.twocolumn_enabled = (GTK_CHECK_MENU_ITEM (widget)->active != 0);
|
|
gsg_set_twocolumn (dialog, preferences.twocolumn_enabled);
|
|
pref_xcam_save ();
|
|
}
|
|
|
|
static GtkWidget *
|
|
build_preferences_menu (GSGDialog * dialog)
|
|
{
|
|
GtkWidget *menu, *item;
|
|
|
|
menu = gtk_menu_new ();
|
|
|
|
/* advanced user option: */
|
|
item = gtk_check_menu_item_new_with_label ("Show advanced options");
|
|
gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (item),
|
|
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);
|
|
|
|
/* tooltips submenu: */
|
|
|
|
item = gtk_check_menu_item_new_with_label ("Show tooltips");
|
|
gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (item),
|
|
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);
|
|
|
|
/* twocolumn submenu: */
|
|
|
|
item = gtk_check_menu_item_new_with_label ("Show two column display");
|
|
gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (item),
|
|
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);
|
|
|
|
item = gtk_menu_item_new ();
|
|
gtk_container_add (GTK_CONTAINER (menu), item);
|
|
gtk_widget_show (item);
|
|
|
|
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",
|
|
(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",
|
|
(GtkSignalFunc) load_defaults_callback, 0);
|
|
gtk_widget_show (item);
|
|
|
|
item = gtk_menu_item_new ();
|
|
gtk_container_add (GTK_CONTAINER (menu), item);
|
|
gtk_widget_show (item);
|
|
|
|
item = gtk_menu_item_new_with_label ("Save settings as...");
|
|
gtk_container_add (GTK_CONTAINER (menu), item);
|
|
gtk_signal_connect (GTK_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",
|
|
(GtkSignalFunc) load_from_callback, 0);
|
|
gtk_widget_show (item);
|
|
|
|
return menu;
|
|
}
|
|
|
|
static void
|
|
rescan_devices (GtkWidget * widget, gpointer client_data, gpointer call_data)
|
|
{
|
|
gtk_widget_destroy (GTK_WIDGET (win.devices.menu));
|
|
win.devices.menu = build_device_menu ();
|
|
gtk_menu_item_set_submenu (GTK_MENU_ITEM (win.devices.item),
|
|
win.devices.menu);
|
|
}
|
|
|
|
#define READ_SANE_PIXEL(buf, buf_end, format, depth, r, g, b) \
|
|
{ \
|
|
switch (format) \
|
|
{ \
|
|
case SANE_FRAME_GRAY: \
|
|
switch (depth) \
|
|
{ \
|
|
case 1: \
|
|
if (buf + 1 > buf_end) \
|
|
goto end_of_buffer; \
|
|
(r) = (g) = (b) = (*buf & src_mask) ? 0x0000 : 0xffff; \
|
|
src_mask >>= 1; \
|
|
if (src_mask == 0x00) \
|
|
{ \
|
|
++buf; \
|
|
src_mask = 0x80; \
|
|
} \
|
|
break; \
|
|
\
|
|
case 8: \
|
|
if (buf + 1 > buf_end) \
|
|
goto end_of_buffer; \
|
|
(r) = (g) = (b) = (*buf++ << 8); \
|
|
break; \
|
|
\
|
|
case 16: \
|
|
if (buf + 2 > buf_end) \
|
|
goto end_of_buffer; \
|
|
(r) = (g) = (b) = *((guint16 *) buf); \
|
|
buf += 2; \
|
|
break; \
|
|
} \
|
|
break; \
|
|
\
|
|
case SANE_FRAME_RGB: \
|
|
switch (depth) \
|
|
{ \
|
|
case 1: \
|
|
case 8: \
|
|
if (buf + 3 > buf_end) \
|
|
goto end_of_buffer; \
|
|
(r) = buf[0] << 8; (g) = buf[1] << 8; (b) = buf[2] << 8; \
|
|
buf += 3; \
|
|
break; \
|
|
\
|
|
case 16: \
|
|
if (buf + 3 > buf_end) \
|
|
goto end_of_buffer; \
|
|
(r) = ((guint16 *)buf)[0]; \
|
|
(g) = ((guint16 *)buf)[1]; \
|
|
(b) = ((guint16 *)buf)[2]; \
|
|
buf += 6; \
|
|
break; \
|
|
} \
|
|
break; \
|
|
\
|
|
case SANE_FRAME_RED: \
|
|
case SANE_FRAME_GREEN: \
|
|
case SANE_FRAME_BLUE: \
|
|
default: \
|
|
fprintf (stderr, "%s: format %d not yet supported\n", \
|
|
prog_name, (format)); \
|
|
goto end_of_buffer; \
|
|
} \
|
|
}
|
|
|
|
#define PUT_X11_PIXEL(buf, endian, depth, bpp, r, g, b, gl_map) \
|
|
{ \
|
|
switch (depth) \
|
|
{ \
|
|
case 1: /* duh? A Sun3 or what?? */ \
|
|
lum = 3*(r) + 5*(g) + 2*(b); \
|
|
if (lum >= 5*0x8000) \
|
|
*buf |= dst_mask; \
|
|
dst_mask <<= 1; \
|
|
if (dst_mask > 0xff) \
|
|
{ \
|
|
buf += (bpp); \
|
|
dst_mask = 0x01; \
|
|
} \
|
|
break; \
|
|
\
|
|
case 8: \
|
|
lum = ((3*(r) + 5*(g) + 2*(b)) / (10 * 256/MAX_LUM)) >> 8; \
|
|
if (lum >= MAX_LUM) \
|
|
lum = MAX_LUM; \
|
|
buf[0] = (gl_map)[lum]; \
|
|
buf += (bpp); \
|
|
break; \
|
|
\
|
|
case 15: \
|
|
rgb = ( (((r) >> 11) << r_shift) /* 5 bits of red */ \
|
|
| (((g) >> 11) << g_shift) /* 5 bits of green */ \
|
|
| (((b) >> 11) << b_shift));/* 5 bits of blue */ \
|
|
((guint16 *)buf)[0] = rgb; \
|
|
buf += (bpp); \
|
|
break; \
|
|
\
|
|
case 16: \
|
|
rgb = ( (((r) >> 11) << r_shift) /* 5 bits of red */ \
|
|
| (((g) >> 10) << g_shift)/* 6 bits of green */ \
|
|
| (((b) >> 11) << b_shift));/* 5 bits of blue */ \
|
|
((guint16 *)buf)[0] = rgb; \
|
|
buf += (bpp); \
|
|
break; \
|
|
\
|
|
case 24: \
|
|
case 32: \
|
|
if (bpp == 4) \
|
|
{ \
|
|
rgb = ( (((r) >> 8) << r_shift) \
|
|
| (((g) >> 8) << g_shift) \
|
|
| (((b) >> 8) << b_shift)); \
|
|
((guint32 *)buf)[0] = rgb; \
|
|
} \
|
|
else \
|
|
{ \
|
|
if ( ((endian) == GDK_LSB_FIRST && r_shift == 0) \
|
|
|| ((endian) == GDK_MSB_FIRST && b_shift == 0)) \
|
|
{ \
|
|
buf[0] = (r) >> 8; buf[1] = (g) >> 8; buf[2] = (b) >> 8; \
|
|
} \
|
|
else \
|
|
{ \
|
|
buf[0] = (b) >> 8; buf[1] = (g) >> 8; buf[2] = (r) >> 8; \
|
|
} \
|
|
} \
|
|
buf += (bpp); \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
static void
|
|
input_available (gpointer ignore, gint source, GdkInputCondition cond)
|
|
{
|
|
int x, pixels_per_line, bytes_per_line, dst_depth, src_depth;
|
|
guint32 r = 0, g = 0, b = 0, lum, rgb, src_mask, dst_mask;
|
|
gint r_shift, b_shift, g_shift;
|
|
size_t buf_size, remaining = win.remaining;
|
|
SANE_Byte *src, *src_end;
|
|
GdkByteOrder byte_order;
|
|
u_long bytes_per_pixel;
|
|
SANE_Frame format;
|
|
SANE_Status status;
|
|
SANE_Int len;
|
|
u_char *dst;
|
|
|
|
double max_value = 60; /* min. 1 frame per min. */
|
|
double frame_time = 50; /* dummy value */
|
|
|
|
DBG (DBG_debug, "xcam: input available: enter\n");
|
|
|
|
if (!win.playing)
|
|
/* looks like we got cancelled */
|
|
goto stop_and_exit;
|
|
|
|
buf_size = win.buf_backend_size;
|
|
format = win.params.format;
|
|
src_depth = win.params.depth;
|
|
dst_depth = win.canvas.gdk_image->depth;
|
|
pixels_per_line = win.params.pixels_per_line;
|
|
bytes_per_line = win.canvas.gdk_image->bpl;
|
|
bytes_per_pixel = win.canvas.gdk_image->bpp;
|
|
byte_order = win.canvas.gdk_image->byte_order;
|
|
|
|
x = win.x;
|
|
dst = win.data;
|
|
src_mask = 0x80; /* SANE has left most bit is most significant bit */
|
|
dst_mask = 0x01;
|
|
|
|
r_shift = win.canvas.gdk_image->visual->red_shift;
|
|
g_shift = win.canvas.gdk_image->visual->green_shift;
|
|
b_shift = win.canvas.gdk_image->visual->blue_shift;
|
|
|
|
while (1)
|
|
{
|
|
DBG (DBG_debug, "input available: enter sane_read\n");
|
|
status = sane_read (gsg_dialog_get_device (dialog),
|
|
win.buf + remaining, buf_size - remaining, &len);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
if (status == SANE_STATUS_EOF)
|
|
{
|
|
display_image (&win.canvas);
|
|
stop_camera ();
|
|
if (win.playing)
|
|
{
|
|
next_frame (); /* arrange for next frame */
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
char buf[256];
|
|
sprintf (buf, "Error during read: %s.",
|
|
sane_strstatus (status));
|
|
gsg_error (buf);
|
|
}
|
|
win.playing = FALSE;
|
|
stop_camera ();
|
|
return;
|
|
}
|
|
win.f_count++;
|
|
update_param (dialog, 0);
|
|
win.i_time++;
|
|
if (win.i_time >= 30)
|
|
{
|
|
time (&win.time2); /* time marker */
|
|
|
|
frame_time = difftime (win.time2, win.time1);
|
|
|
|
if (frame_time > max_value)
|
|
{
|
|
frame_time = max_value;
|
|
}
|
|
|
|
win.fps_old3 = win.fps_old2;
|
|
win.fps_old2 = win.fps_old1;
|
|
win.fps_old1 = win.fps;
|
|
win.fps = 30 / frame_time; /* correction for loop 30 */
|
|
/* avarage last 4 frames times */
|
|
win.fps_av =
|
|
(win.fps_old3 + win.fps_old2 + win.fps_old1 + win.fps) / 4;
|
|
|
|
DBG (DBG_debug,
|
|
"xcam: input_available fps count=%ld, frame_time * 30 = %2.3f, fps=%2.3f, fps_av=%2.3f\n",
|
|
win.f_count, frame_time, win.fps, win.fps_av);
|
|
win.i_time = 0;
|
|
|
|
time (&win.time1); /* time marker for new sequence */
|
|
}
|
|
update_param (dialog, 0);
|
|
|
|
if (!len)
|
|
break;
|
|
|
|
if (win.value_txt == 1)
|
|
{
|
|
strcpy (win.picmsg_ps, "xcam ");
|
|
|
|
status =
|
|
xcam_add_text (win.buf, win.params.pixels_per_line,
|
|
win.params.lines, win.picmsg_ps);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_info, "xcam: input available status NOK\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
src = win.buf;
|
|
src_end = src + len + remaining;
|
|
|
|
while (1)
|
|
{
|
|
if (win.value_rgb == 0)
|
|
{
|
|
READ_SANE_PIXEL (src, src_end, format, src_depth, r, g, b);
|
|
}
|
|
else if (win.value_rgb == 1)
|
|
{
|
|
READ_SANE_PIXEL (src, src_end, format, src_depth, b, g, r);
|
|
}
|
|
PUT_X11_PIXEL (dst, byte_order, dst_depth, bytes_per_pixel, r, g, b,
|
|
win.canvas.graylevel);
|
|
if (++x >= pixels_per_line)
|
|
{
|
|
x = 0;
|
|
dst += bytes_per_line - pixels_per_line * bytes_per_pixel;
|
|
}
|
|
}
|
|
end_of_buffer:
|
|
remaining = src_end - src;
|
|
}
|
|
win.data = dst;
|
|
win.x = x;
|
|
win.remaining = remaining;
|
|
DBG (DBG_debug, "xcam: input available: exit\n");
|
|
return;
|
|
|
|
stop_and_exit:
|
|
win.playing = FALSE;
|
|
stop_camera ();
|
|
DBG (DBG_debug, "xcam: input available: stop and exit\n");
|
|
return;
|
|
}
|
|
|
|
static void
|
|
next_frame (void)
|
|
{
|
|
char buf[256];
|
|
SANE_Status status;
|
|
int fd;
|
|
DBG (DBG_debug, "xcam: next frame enter\n");
|
|
buttons_disable ();
|
|
|
|
DBG (DBG_debug, "xcam: next frame, start gsg_sync\n");
|
|
gsg_sync (dialog);
|
|
|
|
#ifdef SANE_STATUS_WARMING_UP
|
|
do
|
|
{
|
|
status = sane_start (gsg_dialog_get_device (dialog));
|
|
}
|
|
while (status == SANE_STATUS_WARMING_UP);
|
|
#else
|
|
status = sane_start (gsg_dialog_get_device (dialog));
|
|
#endif
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
sprintf (buf, "Failed to start webcam: %s.", sane_strstatus (status));
|
|
gsg_error (buf);
|
|
win.playing = FALSE;
|
|
stop_camera ();
|
|
return;
|
|
}
|
|
|
|
status = sane_get_parameters (gsg_dialog_get_device (dialog), &win.params);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
sprintf (buf, "Failed to get parameters: %s.", sane_strstatus (status));
|
|
gsg_error (buf);
|
|
win.playing = FALSE;
|
|
stop_camera ();
|
|
return;
|
|
}
|
|
|
|
if (!win.canvas.gdk_image
|
|
|| win.canvas.gdk_image->width != win.params.pixels_per_line
|
|
|| win.canvas.gdk_image->height != win.params.lines)
|
|
{
|
|
GdkImageType image_type = GDK_IMAGE_FASTEST;
|
|
|
|
if (win.canvas.gdk_image)
|
|
gdk_image_destroy (win.canvas.gdk_image);
|
|
#ifdef __alpha__
|
|
/* Some X servers seem to have a problem with shared images that
|
|
have a width that is not a multiple of 8. Duh... ;-( */
|
|
if (win.params.pixels_per_line % 8)
|
|
image_type = GDK_IMAGE_NORMAL;
|
|
#endif
|
|
win.canvas.gdk_image =
|
|
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,
|
|
win.params.pixels_per_line, win.params.lines);
|
|
}
|
|
win.data = win.canvas.gdk_image->mem;
|
|
win.x = 0;
|
|
win.remaining = 0;
|
|
|
|
|
|
|
|
buttons_enable ();
|
|
if (sane_set_io_mode (gsg_dialog_get_device (dialog), SANE_TRUE)
|
|
== SANE_STATUS_GOOD
|
|
&& sane_get_select_fd (gsg_dialog_get_device (dialog), &fd)
|
|
== SANE_STATUS_GOOD)
|
|
win.gdk_input_tag =
|
|
gdk_input_add (fd, GDK_INPUT_READ, input_available, 0);
|
|
else
|
|
input_available (0, -1, 0);
|
|
|
|
DBG (DBG_debug, "xcam: next frame: exit\n");
|
|
}
|
|
|
|
static void
|
|
play_stop_button (GtkWidget * widget, gpointer client_data,
|
|
gpointer call_data)
|
|
{
|
|
DBG (DBG_debug, "xcam: play_stop_button: enter\n");
|
|
if (!dialog)
|
|
return;
|
|
|
|
if (win.playing)
|
|
{
|
|
win.playing = FALSE;
|
|
gtk_label_set (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 ");
|
|
DBG (DBG_debug, "xcam: wait for stop button to be pushed\n");
|
|
next_frame ();
|
|
}
|
|
DBG (DBG_debug, "xcam: play_stop_button: exit\n");
|
|
}
|
|
|
|
/* Invoked when the save frame button is pressed */
|
|
static void
|
|
save_frame_button (GtkWidget * widget, gpointer client_data,
|
|
gpointer call_data)
|
|
{
|
|
char buf[256];
|
|
char testfilename[256];
|
|
|
|
DBG (DBG_debug, "xcam: save_frame_button\n");
|
|
if (!dialog)
|
|
return;
|
|
|
|
if (win.saving)
|
|
win.saving = FALSE;
|
|
else if (win.gdk_input_tag < 0)
|
|
{
|
|
win.saving = TRUE;
|
|
gtk_label_set (GTK_LABEL (win.save_frame_label), "Saving started");
|
|
/* ------------------------------------------ */
|
|
|
|
/* test for pnm formats */
|
|
strncpy (testfilename, preferences.filename, sizeof (testfilename));
|
|
testfilename[sizeof (testfilename) - 1] = 0;
|
|
g_strreverse (testfilename);
|
|
if (!((!strncmp (testfilename, "mnp.", 4)) ||
|
|
(!strncmp (testfilename, "mgp.", 4)) ||
|
|
(!strncmp (testfilename, "mbp.", 4)) ||
|
|
(!strncmp (testfilename, "mpp.", 4)) ||
|
|
(!strncmp (testfilename, "MNP.", 4)) ||
|
|
(!strncmp (testfilename, "MGP.", 4)) ||
|
|
(!strncmp (testfilename, "MBP.", 4)) ||
|
|
(!strncmp (testfilename, "MPP.", 4))))
|
|
{
|
|
snprintf (buf, sizeof (buf),
|
|
"Failed to scan, wrong file extension, use pnm, pgm, pbm or ppm `%s'",
|
|
preferences.filename);
|
|
gsg_error (buf);
|
|
return;
|
|
}
|
|
win.out = fopen (preferences.filename, "w");
|
|
if (!win.out)
|
|
{
|
|
snprintf (buf, sizeof (buf), "Failed to open `%s': %s",
|
|
preferences.filename, strerror (errno));
|
|
gsg_error (buf);
|
|
return;
|
|
}
|
|
}
|
|
buttons_disable ();
|
|
save_frame ();
|
|
buttons_enable ();
|
|
gsg_sync (dialog);
|
|
gtk_label_set (GTK_LABEL (win.save_frame_label), "Save\nFrame");
|
|
DBG (DBG_debug, "xcam: save_frame_button: exit\n");
|
|
}
|
|
|
|
/* Invoked when the TXT button is pressed */
|
|
static void
|
|
txt_button (GtkWidget * widget, gpointer client_data, gpointer call_data)
|
|
{
|
|
DBG (DBG_debug, "xcam: txt_button\n");
|
|
if (!dialog)
|
|
return;
|
|
|
|
if (win.saving)
|
|
{
|
|
win.saving = FALSE;
|
|
win.value_txt = 0;
|
|
gtk_label_set (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 ");
|
|
win.value_txt = 1;
|
|
}
|
|
gsg_sync (dialog);
|
|
DBG (DBG_debug, "xcam: txt_button: exit\n");
|
|
}
|
|
|
|
/* Invoked when the RGB-BGR button is pressed */
|
|
static void
|
|
rgb_bgr_button (GtkWidget * widget, gpointer client_data, gpointer call_data)
|
|
{
|
|
DBG (DBG_debug, "xcam: rgb_bgr_button\n");
|
|
if (!dialog)
|
|
return;
|
|
|
|
if (win.saving)
|
|
{
|
|
win.saving = FALSE;
|
|
win.value_rgb = 0;
|
|
gtk_label_set (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");
|
|
win.value_rgb = 1;
|
|
}
|
|
gsg_sync (dialog);
|
|
DBG (DBG_debug, "xcam: rgb_bgr_button: exit\n");
|
|
}
|
|
|
|
static void
|
|
save_frame (void)
|
|
{
|
|
SANE_Handle dev = gsg_dialog_get_device (dialog);
|
|
|
|
const char *frame_type = 0;
|
|
char buf[256];
|
|
int fd;
|
|
|
|
DBG (DBG_debug, "xcam: save_frame: enter\n");
|
|
|
|
win.x = win.y = 0;
|
|
|
|
win.num_bytes = win.params.lines * win.params.bytes_per_line;
|
|
win.bytes_read = 0;
|
|
win.have_odd_byte = FALSE;
|
|
|
|
switch (win.params.format)
|
|
{
|
|
case SANE_FRAME_RGB:
|
|
frame_type = "RGB";
|
|
break;
|
|
case SANE_FRAME_RED:
|
|
frame_type = "red";
|
|
break;
|
|
case SANE_FRAME_GREEN:
|
|
frame_type = "green";
|
|
break;
|
|
case SANE_FRAME_BLUE:
|
|
frame_type = "blue";
|
|
break;
|
|
case SANE_FRAME_GRAY:
|
|
frame_type = "gray";
|
|
break;
|
|
default:
|
|
frame_type = "RGB";
|
|
}
|
|
|
|
if (!win.header_size)
|
|
{
|
|
switch (win.params.format)
|
|
{
|
|
case SANE_FRAME_RED:
|
|
case SANE_FRAME_GREEN:
|
|
case SANE_FRAME_BLUE:
|
|
if (win.params.depth > 8)
|
|
{
|
|
gsg_set_sensitivity (dialog, TRUE);
|
|
snprintf (buf, sizeof (buf),
|
|
"Separate channel transfers are not supported "
|
|
"with %d bits/channel.", win.params.depth);
|
|
gsg_error (buf);
|
|
|
|
buttons_enable ();
|
|
return;
|
|
}
|
|
/*FALLTHROUGH*/ case SANE_FRAME_RGB:
|
|
fprintf (win.out, "P6\n# SANE data follows\n%d %d\n%d\n",
|
|
win.params.pixels_per_line, win.params.lines,
|
|
(win.params.depth <= 8) ? 255 : 65535);
|
|
break;
|
|
|
|
case SANE_FRAME_GRAY:
|
|
if (win.params.depth == 1)
|
|
fprintf (win.out, "P4\n# SANE data follows\n%d %d\n",
|
|
win.params.pixels_per_line, win.params.lines);
|
|
else
|
|
fprintf (win.out, "P5\n# SANE data follows\n%d %d\n%d\n",
|
|
win.params.pixels_per_line, win.params.lines,
|
|
(win.params.depth <= 8) ? 255 : 65535);
|
|
break;
|
|
default:
|
|
snprintf (buf, sizeof (buf),
|
|
"Unsupported image format %d", win.params.format);
|
|
DBG (DBG_error, "xcam_add_text: unsupported image format %d\n",
|
|
win.params.format);
|
|
}
|
|
win.header_size = ftell (win.out);
|
|
fwrite (win.buf, 1, win.num_bytes, win.out);
|
|
fclose (win.out);
|
|
win.out = 0;
|
|
}
|
|
if (win.params.format >= SANE_FRAME_RED
|
|
&& win.params.format <= SANE_FRAME_BLUE)
|
|
fseek (win.out,
|
|
win.header_size + win.params.format - SANE_FRAME_RED, SEEK_SET);
|
|
snprintf (buf, sizeof (buf), "Receiving %s data for `%s'...",
|
|
frame_type, preferences.filename);
|
|
|
|
win.input_tag = -1;
|
|
if (sane_set_io_mode (dev, SANE_TRUE) == SANE_STATUS_GOOD
|
|
&& sane_get_select_fd (dev, &fd) == SANE_STATUS_GOOD)
|
|
win.input_tag = gdk_input_add (fd, GDK_INPUT_READ | GDK_INPUT_EXCEPTION,
|
|
input_available, 0);
|
|
else
|
|
{
|
|
while (gtk_events_pending ())
|
|
gtk_main_iteration ();
|
|
input_available (0, -1, GDK_INPUT_READ);
|
|
}
|
|
|
|
DBG (DBG_debug, "xcam: save_frame: exit\n");
|
|
}
|
|
|
|
static void
|
|
xcam_exit (void)
|
|
{
|
|
static int active = 0;
|
|
|
|
DBG (DBG_debug, "xcam: xcam_exit: enter\n");
|
|
if (active)
|
|
return;
|
|
|
|
active = 1;
|
|
pref_xcam_save ();
|
|
sane_exit ();
|
|
/* this has the habit of calling exit itself: */
|
|
gtk_exit (0);
|
|
DBG (DBG_debug, "xcam: xcam_exit: exit\n");
|
|
}
|
|
|
|
/* Invoked when window manager's "delete" (or "close") function is
|
|
invoked. */
|
|
static gint
|
|
xcam_win_delete (GtkWidget * w, gpointer data)
|
|
{
|
|
xcam_exit ();
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
browse_filename_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
char filename[1024];
|
|
|
|
DBG (DBG_debug, "xcam: browse_filename_callback\n");
|
|
if (preferences.filename)
|
|
{
|
|
strncpy (filename, preferences.filename, sizeof (filename));
|
|
filename[sizeof (filename) - 1] = '\0';
|
|
}
|
|
else
|
|
strcpy (filename, OUTFILENAME);
|
|
gsg_get_filename ("Output Filename", filename, sizeof (filename), filename);
|
|
gtk_entry_set_text (GTK_ENTRY (win.filename_entry), filename);
|
|
|
|
if (preferences.filename)
|
|
free ((void *) preferences.filename);
|
|
preferences.filename = strdup (filename);
|
|
DBG (DBG_debug, "xcam: browse_filename_callback: exit\n");
|
|
}
|
|
|
|
static void
|
|
filename_changed_callback (GtkWidget * widget, gpointer data)
|
|
{
|
|
DBG (DBG_debug, "xcam: filename_changed_callback\n");
|
|
if (preferences.filename)
|
|
free ((void *) preferences.filename);
|
|
preferences.filename = strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
|
|
pref_xcam_save ();
|
|
DBG (DBG_debug, "xcam: filename_changed_callbackcallback: exit\n");
|
|
}
|
|
|
|
static void
|
|
usage (void)
|
|
{
|
|
printf ("Usage: %s [OPTION]... [DEVICE]\n\
|
|
\n\
|
|
Start up graphical user interface to access SANE (Scanner Access Now\n\
|
|
Easy) devices.\n\
|
|
\n\
|
|
-h, --help display this help message and exit\n\
|
|
-B, --buffersize set buffersize 1024 * 1024\n\
|
|
-V, --version print version information\n", prog_name);
|
|
}
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
GtkWidget *menu, *menu_bar, *menu_bar_item, *preview_vbox;
|
|
GtkWidget *hbox, *vbox, *button, *alignment, *frame, *label, *text,
|
|
*scrolled_window;
|
|
int i;
|
|
int ch;
|
|
SANE_Status status;
|
|
|
|
DBG_INIT ();
|
|
|
|
DBG (DBG_debug, "xcam: main\n");
|
|
DBG (DBG_error, "xcam (version: %s, package: %s) starting\n", VERSION,
|
|
PACKAGE);
|
|
|
|
win.buf_backend_size = (32 * 1024);
|
|
|
|
pref_xcam_restore ();
|
|
|
|
prog_name = strrchr (argv[0], '/');
|
|
if (prog_name)
|
|
++prog_name;
|
|
else
|
|
prog_name = argv[0];
|
|
|
|
/* turn on by default as we don't support graphical geometry selection */
|
|
preferences.advanced = 1;
|
|
|
|
status = sane_init (0, 0);
|
|
if (status != SANE_STATUS_GOOD)
|
|
{
|
|
DBG (DBG_fatal, "init: sane_main failed: %s\n",
|
|
sane_strstatus (status));
|
|
exit (1);
|
|
}
|
|
|
|
if (argc > 1)
|
|
{
|
|
|
|
while ((ch = getopt_long (argc, argv, "hBV", long_options, 0)) != EOF)
|
|
{
|
|
switch (ch)
|
|
{
|
|
case 'V':
|
|
printf ("xcam (%s) %s\n", PACKAGE, VERSION);
|
|
exit (0);
|
|
|
|
case 'B':
|
|
win.buf_backend_size = 1024 * 1024;
|
|
break;
|
|
case 'h':
|
|
default:
|
|
usage ();
|
|
exit (0);
|
|
}
|
|
}
|
|
}
|
|
|
|
DBG (DBG_debug, "xcam.main: buf_backend_size 0x%x\n",
|
|
(unsigned) win.buf_backend_size);
|
|
|
|
win.buf = malloc (win.buf_backend_size);
|
|
|
|
gdk_set_show_events (0);
|
|
gtk_init (&argc, &argv);
|
|
|
|
atexit (xcam_exit);
|
|
|
|
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);
|
|
|
|
vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_container_border_width (GTK_CONTAINER (vbox), 0);
|
|
gtk_container_add (GTK_CONTAINER (win.shell), vbox);
|
|
gtk_widget_show (vbox);
|
|
|
|
menu_bar = gtk_menu_bar_new ();
|
|
|
|
win.devices.menu = build_device_menu ();
|
|
|
|
/* "Files" entry: */
|
|
menu_bar_item = gtk_menu_item_new_with_label ("File");
|
|
gtk_container_add (GTK_CONTAINER (menu_bar), menu_bar_item);
|
|
menu = build_files_menu ();
|
|
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_bar_item), menu);
|
|
gtk_widget_show (menu_bar_item);
|
|
|
|
/* "Devices" entry: */
|
|
win.devices.item = gtk_menu_item_new_with_label ("Devices");
|
|
gtk_container_add (GTK_CONTAINER (menu_bar), win.devices.item);
|
|
gtk_menu_item_set_submenu (GTK_MENU_ITEM (win.devices.item),
|
|
win.devices.menu);
|
|
gtk_widget_show (win.devices.item);
|
|
|
|
/* "Preferences" entry: */
|
|
menu_bar_item = gtk_menu_item_new_with_label ("Preferences");
|
|
gtk_container_add (GTK_CONTAINER (menu_bar), menu_bar_item);
|
|
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_bar_item),
|
|
build_preferences_menu (dialog));
|
|
gtk_widget_show (menu_bar_item);
|
|
|
|
gtk_box_pack_start (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 0);
|
|
gtk_widget_show (menu_bar);
|
|
|
|
/* add device info at top: */
|
|
frame = gtk_frame_new (0);
|
|
gtk_container_border_width (GTK_CONTAINER (frame), 8);
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
|
|
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
win.device_info_label = gtk_label_new ("");
|
|
gtk_widget_show (win.device_info_label);
|
|
gtk_container_add (GTK_CONTAINER (frame), win.device_info_label);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 0);
|
|
gtk_container_add (GTK_CONTAINER (vbox), hbox);
|
|
gtk_widget_show (hbox);
|
|
|
|
/* create the device dialog box: */
|
|
win.dialog_box = gtk_vbox_new (FALSE, 0);
|
|
gtk_widget_show (win.dialog_box);
|
|
|
|
DBG (DBG_debug, "xcam main, preview vbox on the left hand side \n");
|
|
/* the preview vbox on the left hand side: */
|
|
preview_vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (hbox), preview_vbox, TRUE, TRUE, 0);
|
|
|
|
frame = gtk_frame_new ("Image view");
|
|
gtk_container_border_width (GTK_CONTAINER (frame), 8);
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
|
|
gtk_container_add (GTK_CONTAINER (preview_vbox), frame);
|
|
|
|
alignment = gtk_alignment_new (0, 0.5, 1.0, 1.0);
|
|
gtk_box_pack_start (GTK_BOX (preview_vbox), alignment, TRUE, TRUE, 0);
|
|
|
|
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",
|
|
(GtkSignalFunc) canvas_events, 0);
|
|
gtk_container_add (GTK_CONTAINER (frame), win.canvas.preview);
|
|
|
|
gtk_widget_show (win.canvas.preview);
|
|
gtk_widget_show (alignment);
|
|
gtk_widget_show (frame);
|
|
gtk_widget_show (preview_vbox);
|
|
|
|
win.canvas.graylevel_cmap = gdk_colormap_get_system ();
|
|
for (i = 0; i < NELEMS (win.canvas.graylevel); ++i)
|
|
{
|
|
GdkColor color;
|
|
color.red = color.green = color.blue =
|
|
i * 0xffff / (NELEMS (win.canvas.graylevel) - 1);
|
|
gdk_color_alloc (win.canvas.graylevel_cmap, &color);
|
|
win.canvas.graylevel[i] = color.pixel;
|
|
}
|
|
|
|
#if 0
|
|
{
|
|
win.canvas.cube_cmap
|
|
= gdk_colormap_new (win.canvas.preview->window->visual, 1);
|
|
for (i = 0; i < NELEMS (win.canvas.cube_colors); ++i)
|
|
{
|
|
win.canvas.cube_colors[i].pixel = i;
|
|
win.canvas.cube_colors[i].red = ((i / 30) % 5) * 0xffff / 4;
|
|
win.canvas.cube_colors[i].green = ((i / 5) % 6) * 0xffff / 5;
|
|
win.canvas.cube_colors[i].blue = ((i % 5)) * 0xffff / 4;
|
|
}
|
|
gdk_colors_store (win.canvas.cube_cmap, win.canvas.cube_colors,
|
|
NELEMS (win.canvas.cube_colors));
|
|
gdk_window_set_colormap (win.shell->window, win.canvas.cube_cmap);
|
|
}
|
|
#endif
|
|
|
|
DBG (DBG_debug, "xcam main, use a scrolled window \n");
|
|
|
|
/* use a scrolled window to show the device options, as in xscanimage */
|
|
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
|
|
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
|
|
gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolled_window),
|
|
GTK_CORNER_TOP_RIGHT);
|
|
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW
|
|
(scrolled_window), win.dialog_box);
|
|
gtk_container_add (GTK_CONTAINER (hbox), scrolled_window);
|
|
|
|
gtk_widget_show (GTK_WIDGET (scrolled_window));
|
|
|
|
if (device[0])
|
|
{
|
|
switch_device (device[0]);
|
|
load_defaults (1);
|
|
}
|
|
else
|
|
{
|
|
DBG (DBG_fatal,
|
|
" No vidcams were identified. If you were expecting something\n"
|
|
" different, check that the vidcam is plugged in, turned on and\n"
|
|
" detected by sane-find-scanner (if appropriate). Please read\n"
|
|
" the documentation which came with this software (README, FAQ,\n"
|
|
" manpages).\n");
|
|
atexit (xcam_exit);
|
|
}
|
|
|
|
if (dialog && gsg_dialog_get_device (dialog)
|
|
&& (sane_get_parameters (gsg_dialog_get_device (dialog), &win.params)
|
|
== SANE_STATUS_GOOD))
|
|
{
|
|
gtk_widget_set_usize (win.canvas.preview,
|
|
win.params.pixels_per_line, win.params.lines);
|
|
}
|
|
|
|
/* The bottom row */
|
|
|
|
DBG (DBG_debug, "xcam main, button row: info\n");
|
|
|
|
/* The info row */
|
|
hbox = gtk_hbox_new (FALSE, 5);
|
|
gtk_container_border_width (GTK_CONTAINER (hbox), 3);
|
|
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
|
|
gtk_widget_show (hbox);
|
|
|
|
frame = gtk_frame_new (NULL);
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
|
|
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
|
|
gtk_widget_show (frame);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 5);
|
|
gtk_container_border_width (GTK_CONTAINER (hbox), 2);
|
|
gtk_container_add (GTK_CONTAINER (frame), hbox);
|
|
gtk_widget_show (hbox);
|
|
|
|
win.info_label =
|
|
gtk_label_new ("0 x 0 0 kByte \n0 f_count \n0 fps 0 fps_av");
|
|
gtk_box_pack_start (GTK_BOX (hbox), win.info_label, FALSE, FALSE, 0);
|
|
gtk_widget_show (win.info_label);
|
|
|
|
win.f_count = 0;
|
|
win.fps = 0;
|
|
win.fps_av = 0;
|
|
win.i_time = 0;
|
|
time (&win.time1); /* first time marker */
|
|
update_param (dialog, 0);
|
|
|
|
DBG (DBG_debug, "xcam main, bottom row: rgb-bgr button\n");
|
|
|
|
/* The TXT button */
|
|
button = gtk_button_new_with_label (" TXT ");
|
|
win.txt_label = GTK_BIN (button)->child;
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) txt_button, dialog);
|
|
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
|
|
gtk_widget_show (button);
|
|
DBG (DBG_debug, "xcam main, bottom row: txt button\n");
|
|
|
|
/* 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",
|
|
(GtkSignalFunc) rgb_bgr_button, dialog);
|
|
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
|
|
gtk_widget_show (button);
|
|
|
|
DBG (DBG_debug, "xcam main, bottom row: play button\n");
|
|
|
|
/* 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",
|
|
(GtkSignalFunc) play_stop_button, dialog);
|
|
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
|
|
gtk_widget_show (button);
|
|
|
|
DBG (DBG_debug, "xcam main, bottom row: save frame button\n");
|
|
|
|
/* 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",
|
|
(GtkSignalFunc) save_frame_button, dialog);
|
|
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
|
|
gtk_widget_show (button);
|
|
|
|
DBG (DBG_debug, "xcam main, bottom row: output filename part\n");
|
|
|
|
/* output filename part */
|
|
frame = gtk_frame_new ("Output");
|
|
gtk_container_border_width (GTK_CONTAINER (frame), 4);
|
|
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
|
|
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 2);
|
|
gtk_container_border_width (GTK_CONTAINER (hbox), 2);
|
|
gtk_container_add (GTK_CONTAINER (frame), hbox);
|
|
|
|
label = gtk_label_new ("Filename");
|
|
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
gtk_widget_show (button);
|
|
gtk_widget_show (label);
|
|
gtk_widget_show (text);
|
|
gtk_widget_show (hbox);
|
|
gtk_widget_show (frame);
|
|
|
|
gtk_widget_show (win.shell);
|
|
gtk_main ();
|
|
|
|
pref_xcam_save ();
|
|
|
|
DBG (DBG_debug, "xcam main exit\n");
|
|
return 0;
|
|
}
|