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

Fist commit to GTK4

merge-requests/14/head
Ordissimo 2024-10-22 22:19:29 +02:00
rodzic 20b6a25f5b
commit dad3c5935d
19 zmienionych plików z 3418 dodań i 4608 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

14
configure.in
Wyświetl plik

@ -32,8 +32,8 @@ AC_SUBST(SANE_MAJOR)
dnl Check if GUIs shall be compiled
AC_ARG_ENABLE(guis, [ --disable-guis do not compile graphical user interfaces (GUIs)], USE_GUI=$enableval, USE_GUI=yes)
dnl Check if GTK3 support is wanted
AC_ARG_ENABLE(gtk3, [ --disable-gtk3 do not use GTK3], USE_GTK3=$enableval, USE_GTK3=yes)
dnl Check if GTK4 support is wanted
AC_ARG_ENABLE(gtk4, [ --disable-gtk4 do not use GTK4], USE_GTK4=$enableval, USE_GTK4=yes)
dnl Check for gimp plugin support
AC_MSG_CHECKING([whether GIMP plugin is requested])
@ -124,16 +124,16 @@ if test "x${HAVE_SANE}" = "x"; then
exit
fi
# check for GTK3
# check for GTK4
if test "${USE_GUI}" = "yes"; then
if test "${USE_GTK3}" = "yes" || test "${USE_GIMP}" = "yes"; then
PKG_CHECK_MODULES([GTK], [gtk+-3.0], HAVE_GTK=yes, [
if test "${USE_GTK4}" = "yes" || test "${USE_GIMP}" = "yes"; then
PKG_CHECK_MODULES([GTK], [gtk4], HAVE_GTK=yes, [
if test "${USE_GIMP}" = "yes"; then
AC_MSG_WARN([*** GIMP 2.0 plugin requested, but GTK+ 3.0 not found, falling back to GIMP/GTK+ < 3.0 if possible ***])
AC_MSG_WARN([*** GIMP 2.0 plugin requested, but GTK+ 4.0 not found, falling back to GIMP/GTK+ < 4.0 if possible ***])
USE_GIMP=no
else
AC_MSG_WARN([*** GTK+ 3.0 not found, falling back to GTK+ < 3.0 if possible ***])
AC_MSG_WARN([*** GTK+ 4.0 not found, falling back to GTK+ < 4.0 if possible ***])
fi])
fi

10
libgtk/Makefile.in
Wyświetl plik

@ -51,15 +51,15 @@ COMPILE = $(CC) -c $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) $(GTK_CFLAGS)
@SET_MAKE@
LIBGTKSANE_OBJS = gtk3curve.o gtk3gamma.o gtk3ruler.o utils-gtk.o
LIBGTKSANE_LTOBJS = gtk3curve.lo gtk3gamma.lo gtk3ruler.lo utils-gtk.lo
LIBGTKSANE_OBJS = gtk4curve.o gtk4gamma.o utils-gtk.o
LIBGTKSANE_LTOBJS = gtk4curve.lo gtk4gamma.lo utils-gtk.lo
TARGETS = $(LIBGTKSANE_OBJS) $(GTK_LIBS)
TARGETS = libgtksane.a
DISTFILES = Makefile.in gtk3curve.c gtk3curve.h \
gtk3gamma.c gtk3gamma.h gtk3ruler.c \
gtk3ruler.h utils-gtk.c utils-gtk.h
DISTFILES = Makefile.in gtk4curve.c gtk4curve.h \
gtk4gamma.c gtk4gamma.h \
utils-gtk.c utils-gtk.h
# gtk3gamma.c gtk3gamma.h gtkpreview.c gtkpreview.h gimpruler.c \

1985
libgtk/gtk3curve.c
Wyświetl plik

Plik diff jest za duży Load Diff

174
libgtk/gtk3curve.h
Wyświetl plik

@ -1,174 +0,0 @@
/* Copyright (C) 2016 Benoit Touchette
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation version
* 2.1 of the License.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GTK3_CURVE__H__
#define __GTK3_CURVE__H__
#include <gtk/gtk.h>
#define GTK3_TYPE_CURVE (gtk3_curve_get_type ())
#define GTK3_CURVE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK3_TYPE_CURVE, Gtk3Curve))
#define GTK3_IS_CURVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK3_TYPE_CURVE))
#define GTK3_CURVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK3_TYPE_CURVE, Gtk3CurveClass))
#define GTK3_IS_CURVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK3_TYPE_CURVE))
#define GTK3_CURVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK3_TYPE_CURVE, Gtk3CurveClass))
#define GTK3_TYPE_CURVE_TYPE (gtk3_curve_type_get_type ())
typedef enum
{
GTK3_CURVE_GRID_MICRO,
GTK3_CURVE_GRID_SMALL,
GTK3_CURVE_GRID_MEDIUM,
GTK3_CURVE_GRID_LARGE,
GTK3_CURVE_GRID_XLARGE
} Gtk3CurveGridSize;
typedef enum
{
GTK3_CURVE_TYPE_LINEAR, /* linear interpolation */
GTK3_CURVE_TYPE_SPLINE, /* spline interpolation */
GTK3_CURVE_TYPE_FREE /* free form curve */
} Gtk3CurveType;
typedef struct _Gtk3Curve Gtk3Curve;
typedef struct _Gtk3CurveClass Gtk3CurveClass;
typedef struct _Gtk3CurvePrivate Gtk3CurvePrivate;
typedef struct _Gtk3CurveColor Gtk3CurveColor;
typedef struct _Gtk3CurveData Gtk3CurveData;
typedef struct _Gtk3CurveVector Gtk3CurveVector;
typedef struct _Gtk3CurvePoint Gtk3CurvePoint;
struct _Gtk3CurvePoint
{
gint x;
gint y;
};
struct _Gtk3CurveColor
{
gfloat red;
gfloat green;
gfloat blue;
gfloat alpha;
};
struct _Gtk3CurveVector
{
gfloat x;
gfloat y;
};
struct _Gtk3CurveData
{
gchar *description;
Gtk3CurveType curve_type;
gint n_points;
Gtk3CurvePoint *d_point;
gint n_cpoints;
Gtk3CurveVector *d_cpoints;
};
struct _Gtk3Curve
{
GtkWidget widget;
Gtk3CurvePrivate *priv;
};
struct _Gtk3CurveClass
{
GtkWidgetClass parent_class;
void (* curve_type_changed) (Gtk3Curve *curve);
/* Padding for future expansion */
void (*_gtk_reserved1) (void);
void (*_gtk_reserved2) (void);
void (*_gtk_reserved3) (void);
void (*_gtk_reserved4) (void);
};
GType gtk3_curve_type_get_type (void);
GType gtk3_curve_get_type (void) G_GNUC_CONST;
GtkWidget* gtk3_curve_new (void);
void gtk3_curve_reset (GtkWidget *widget);
void gtk3_curve_set_gamma (GtkWidget *widget,
gfloat gamma_);
void gtk3_curve_set_range (GtkWidget *widget,
gfloat min_x,
gfloat max_x,
gfloat min_y,
gfloat max_y);
void gtk3_curve_get_vector (GtkWidget *widget,
gint veclen,
gfloat vector[]);
void gtk3_curve_set_vector (GtkWidget *widget,
gint veclen,
gfloat vector[]);
void gtk3_curve_set_curve_type (GtkWidget *widget,
Gtk3CurveType type);
void gtk3_curve_set_color_background (GtkWidget *widget,
Gtk3CurveColor color);
void gtk3_curve_set_color_grid (GtkWidget *widget,
Gtk3CurveColor color);
void gtk3_curve_set_color_curve (GtkWidget *widget,
Gtk3CurveColor color);
void gtk3_curve_set_color_cpoint (GtkWidget *widget,
Gtk3CurveColor color);
void gtk3_curve_set_color_background_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
void gtk3_curve_set_color_grid_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
void gtk3_curve_set_color_curve_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
void gtk3_curve_set_color_cpoint_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
Gtk3CurveType gtk3_curve_get_curve_type (GtkWidget *widget);
Gtk3CurveColor gtk3_curve_get_color_background (GtkWidget *widget);
Gtk3CurveColor gtk3_curve_get_color_grid (GtkWidget *widget);
Gtk3CurveColor gtk3_curve_get_color_curve (GtkWidget *widget);
Gtk3CurveColor gtk3_curve_get_color_cpoint (GtkWidget *widget);
void gtk3_curve_set_use_theme_background (GtkWidget *widget,
gboolean use);
gboolean gtk3_curve_get_use_theme_background (GtkWidget *widget);
void gtk3_curve_set_grid_size (GtkWidget *widget,
Gtk3CurveGridSize size);
Gtk3CurveGridSize gtk3_curve_get_grid_size (GtkWidget *widget);
void gtk3_curve_save (Gtk3CurveData *data,
gchar *filename);
#endif /* __GTK3_CURVE__H__ */

432
libgtk/gtk3gamma.c
Wyświetl plik

@ -1,432 +0,0 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1997 David Mosberger
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <gtk/gtk.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "gtk3gamma.h"
/* forward declarations: */
static void gtk3_gamma_curve_destroy (GtkWidget *object);
static void curve_type_changed_callback (GtkWidget *w, gpointer data);
static void button_realize_callback (GtkWidget *w);
static void button_toggled_callback (GtkWidget *w, gpointer data);
static void button_clicked_callback (GtkWidget *w, gpointer data);
/* XPM */
static const char * spline_xpm[] = {
"16 16 5 1",
" c None",
". c #000000",
"+ c #824141",
"@ c #FF0000",
"# c #7F7F7F",
" ..",
" +.",
" @ ",
" @ ",
" @ ",
" #.# @ ",
" ... @ ",
" +.+ @ ",
" @ @ @ ",
" @ @ @ ",
" @ @ @ ",
" @ @.+ ",
" @ ... ",
" @ #.# ",
".+ ",
".. "};
/* XPM */
static const char * lineart_xpm[] = {
"16 16 4 1",
" c None",
". c #000000",
"+ c #FF0000",
"@ c #BC2D2D",
" ..",
" ++++++.",
" ++ ",
" .@ ",
" ... ",
" @. ",
" + ",
" + ",
" + ",
" + ",
" + ",
" + ",
" + ",
" + ",
".@ ",
".. "};
/* XPM */
static const char * free_xpm[] = {
"16 16 2 1",
" c None",
". c #FF0000",
" ",
" ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . . .....",
" . . ",
" . . ",
" . . ",
" . . ",
". "};
/* XPM */
static const char * gamma_xpm[] = {
"16 16 10 1",
" c None",
". c #000000",
"+ c #5E5E5E",
"@ c #8C8C8C",
"# c #464646",
"$ c #171717",
"% c #BBBBBB",
"& c #757575",
"* c #A4A4A4",
"= c #2F2F2F",
" ",
" ",
" ",
" .+ @.@ ",
" #$% &$* ",
" &@ ## ",
" . .@ ",
" # # ",
" #$@ ",
" *. ",
" &+ ",
" =. ",
" .. ",
" .= ",
" ",
" "};
/* XPM */
static const char * reset_xpm[] = {
"16 16 4 1",
" c None",
". c #000000",
"+ c #824141",
"@ c #FF0000",
" ..",
" +.",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
".+ ",
".. "};
static const gchar ** button_images[] = {
spline_xpm,
lineart_xpm,
free_xpm,
gamma_xpm,
reset_xpm
};
enum
{
LINEAR = 0,
SPLINE,
FREE,
GAMMA,
RESET,
NUM_XPMS
};
G_DEFINE_TYPE (Gtk3GammaCurve, gtk3_gamma_curve, GTK_TYPE_BOX)
static void
gtk3_gamma_curve_class_init (Gtk3GammaCurveClass *class)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
widget_class->destroy = gtk3_gamma_curve_destroy;
}
static void
gtk3_gamma_curve_init (Gtk3GammaCurve *curve)
{
GtkWidget *image = NULL;
GdkPixbuf *pixbuf = NULL;
GtkWidget *vbox;
int i;
gtk_orientable_set_orientation (GTK_ORIENTABLE (curve), GTK_ORIENTATION_VERTICAL);
curve->gamma = 1.0;
curve->table = gtk_grid_new ();
gtk_grid_set_column_homogeneous (GTK_GRID (curve->table), FALSE);
gtk_grid_set_row_homogeneous (GTK_GRID (curve->table), FALSE);
gtk_container_add (GTK_CONTAINER (curve), curve->table);
curve->curve = gtk3_curve_new ();
g_signal_connect (curve->curve, "curve-type-changed",
G_CALLBACK (curve_type_changed_callback), curve);
gtk_grid_attach (GTK_GRID (curve->table), curve->curve, 0, 0 , 1, 1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, /* spacing */ 3);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_grid_attach (GTK_GRID (curve->table), vbox, 1, 0 , 1, 1);
/* toggle buttons: */
for (i = 0; i < 3; ++i)
{
curve->button[i] = gtk_toggle_button_new ();
pixbuf = gdk_pixbuf_new_from_xpm_data(button_images[i]);
image = gtk_image_new_from_pixbuf(pixbuf);
gtk_button_set_image (GTK_BUTTON (curve->button[i]), image);
g_object_set_data (G_OBJECT (curve->button[i]), "_Gtk3GammaCurveIndex",
GINT_TO_POINTER (i));
gtk_container_add (GTK_CONTAINER (vbox), curve->button[i]);
g_signal_connect (G_OBJECT (curve->button[i]), "toggled",
G_CALLBACK (button_toggled_callback), curve);
gtk_widget_show (curve->button[i]);
}
/* push buttons: */
for (i = 3; i < 5; ++i)
{
curve->button[i] = gtk_button_new ();
pixbuf = gdk_pixbuf_new_from_xpm_data(button_images[i]);
image = gtk_image_new_from_pixbuf(pixbuf);
gtk_button_set_image (GTK_BUTTON (curve->button[i]), image);
g_object_set_data (G_OBJECT (curve->button[i]), "_Gtk3GammaCurveIndex",
GINT_TO_POINTER (i));
gtk_container_add (GTK_CONTAINER (vbox), curve->button[i]);
g_signal_connect (G_OBJECT (curve->button[i]), "clicked",
G_CALLBACK (button_clicked_callback), curve);
gtk_widget_show (curve->button[i]);
}
gtk_widget_show (vbox);
gtk_widget_show (curve->table);
gtk_widget_show (curve->curve);
}
static void
button_toggled_callback (GtkWidget *w, gpointer data)
{
Gtk3GammaCurve *c = data;
Gtk3CurveType type;
int active, i;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)))
return;
active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (w), "_Gtk3GammaCurveIndex"));
for (i = 0; i < 3; ++i)
if ((i != active) && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (c->button[i])))
break;
if (i < 3)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c->button[i]), FALSE);
switch (active)
{
case 0: type = GTK3_CURVE_TYPE_SPLINE; break;
case 1: type = GTK3_CURVE_TYPE_LINEAR; break;
default: type = GTK3_CURVE_TYPE_FREE; break;
}
gtk3_curve_set_curve_type (c->curve, type);
}
static void
gamma_cancel_callback (GtkWidget *w, gpointer data)
{
Gtk3GammaCurve *c = data;
gtk_widget_destroy (c->gamma_dialog);
c->gamma_dialog = NULL;
}
static void
gamma_response_callback (GtkWidget *w,
gint response_id,
gpointer data)
{
if (response_id == GTK_RESPONSE_OK)
{
Gtk3GammaCurve *c = data;
const gchar *start;
gchar *end;
gfloat v;
start = gtk_entry_get_text (GTK_ENTRY (c->gamma_text));
// GTK 4 => start = gtk_editable_get_text (GTK_EDITABLE (c->gamma_text));
if (start)
{
v = g_strtod (start, &end);
if (end > start && v > 0.0)
c->gamma = v;
}
gtk3_curve_set_gamma (c->curve, c->gamma);
}
gamma_cancel_callback (w, data);
}
static void
button_clicked_callback (GtkWidget *w, gpointer data)
{
Gtk3GammaCurve *c = data;
int active;
active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (w), "_Gtk3GammaCurveIndex"));
if (active == 3)
{
/* set gamma */
if (c->gamma_dialog)
return;
else
{
GtkWidget *vbox, *hbox, *label;
gchar buf[64];
c->gamma_dialog = gtk_dialog_new_with_buttons ("Gamma",
GTK_WINDOW (w),
GTK_DIALOG_DESTROY_WITH_PARENT,
"Ok", GTK_RESPONSE_OK,
"Cancel", GTK_RESPONSE_CANCEL,
NULL);
g_object_add_weak_pointer (G_OBJECT (c->gamma_dialog),
(gpointer *)&c->gamma_dialog);
vbox =gtk_dialog_get_content_area (GTK_DIALOG (c->gamma_dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, /* spacing */ 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
// GTK4 => gtk_box_append (GTK_BOX (vbox), hbox);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic ("_Gamma value");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
// GTK4 => gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (label);
sprintf (buf, "%g", c->gamma);
c->gamma_text = gtk_entry_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (label), c->gamma_text);
gtk_entry_set_text (GTK_ENTRY (c->gamma_text), buf);
// GTK4 => gtk_editable_set_text (GTK_EDITABLE (c->gamma_text), buf);
gtk_box_pack_start (GTK_BOX (hbox), c->gamma_text, TRUE, TRUE, 2);
// GTK4 => gtk_box_append (GTK_BOX (hbox), c->gamma_text);
gtk_widget_show (c->gamma_text);
/* fill in action area: */
g_signal_connect (c->gamma_dialog,
"response",
G_CALLBACK (gamma_response_callback),
c);
gtk_widget_show (c->gamma_dialog);
}
}
else
{
/* reset */
gtk3_curve_reset (c->curve);
}
}
static void
curve_type_changed_callback (GtkWidget *w, gpointer data)
{
Gtk3GammaCurve *c = data;
Gtk3CurveType new_type;
int active;
new_type = gtk3_curve_get_curve_type (w);
switch (new_type)
{
case GTK3_CURVE_TYPE_SPLINE: active = 0; break;
case GTK3_CURVE_TYPE_LINEAR: active = 1; break;
default: active = 2; break;
}
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (c->button[active])))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c->button[active]), TRUE);
}
GtkWidget*
gtk3_gamma_curve_new (void)
{
return g_object_new (GTK3_TYPE_GAMMA_CURVE, NULL);
}
static void
gtk3_gamma_curve_destroy (GtkWidget *object)
{
Gtk3GammaCurve *c = GTK3_GAMMA_CURVE (object);
if (c->gamma_dialog)
gtk_widget_destroy (c->gamma_dialog);
// G_OBJECT_CLASS (gtk3_gamma_curve_parent_class)->destroy (object);
}

74
libgtk/gtk3gamma.h
Wyświetl plik

@ -1,74 +0,0 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1997 David Mosberger
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#ifndef __GTK3_GAMMA_CURVE_H__
#define __GTK3_GAMMA_CURVE_H__
#include "gtk3curve.h"
#define GTK3_TYPE_GAMMA_CURVE (gtk3_gamma_curve_get_type ())
#define GTK3_GAMMA_CURVE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK3_TYPE_GAMMA_CURVE, Gtk3GammaCurve))
#define GTK3_GAMMA_CURVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK3_TYPE_GAMMA_CURVE, Gtk3GammaCurveClass))
#define GTK3_IS_GAMMA_CURVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK3_TYPE_GAMMA_CURVE))
#define GTK3_IS_GAMMA_CURVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK3_TYPE_GAMMA_CURVE))
#define GTK3_GAMMA_CURVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK3_TYPE_GAMMA_CURVE, Gtk3GammaCurveClass))
typedef struct _Gtk3GammaCurve Gtk3GammaCurve;
typedef struct _Gtk3GammaCurveClass Gtk3GammaCurveClass;
struct _Gtk3GammaCurve
{
GtkBox vbox;
GtkWidget *table;
GtkWidget *curve;
GtkWidget *button[5]; /* spline, linear, free, gamma, reset */
gfloat gamma;
GtkWidget *gamma_dialog;
GtkWidget *gamma_text;
};
struct _Gtk3GammaCurveClass
{
GtkBoxClass parent_class;
/* Padding for future expansion */
void (*_gtk_reserved1) (void);
void (*_gtk_reserved2) (void);
void (*_gtk_reserved3) (void);
void (*_gtk_reserved4) (void);
};
GType gtk3_gamma_curve_get_type (void) G_GNUC_CONST;
GtkWidget* gtk3_gamma_curve_new (void);
#endif /* __GTK3_GAMMA_CURVE_H__ */

1500
libgtk/gtk3ruler.c
Wyświetl plik

Plik diff jest za duży Load Diff

1544
libgtk/gtk4curve.c 100644
Wyświetl plik

Plik diff jest za duży Load Diff

153
libgtk/gtk4curve.h 100644
Wyświetl plik

@ -0,0 +1,153 @@
/* Copyright (C) 2016 Benoit Touchette
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation version
* 2.1 of the License.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GTK4_CURVE__H__
#define __GTK4_CURVE__H__
#include <gtk/gtk.h>
#define GTK4_TYPE_CURVE (gtk4_curve_get_type ())
#define GTK4_CURVE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK4_TYPE_CURVE, Gtk4Curve))
#define GTK4_IS_CURVE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK4_TYPE_CURVE))
#define GTK4_CURVE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK4_TYPE_CURVE, Gtk4CurveClass))
#define GTK4_IS_CURVE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK4_TYPE_CURVE))
#define GTK4_CURVE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK4_TYPE_CURVE, Gtk4CurveClass))
#define GTK4_TYPE_CURVE_TYPE (gtk4_curve_type_get_type ())
typedef enum
{
GTK4_CURVE_GRID_MICRO,
GTK4_CURVE_GRID_SMALL,
GTK4_CURVE_GRID_MEDIUM,
GTK4_CURVE_GRID_LARGE,
GTK4_CURVE_GRID_XLARGE
} Gtk4CurveGridSize;
typedef enum
{
GTK4_CURVE_TYPE_LINEAR, /* linear interpolation */
GTK4_CURVE_TYPE_SPLINE, /* spline interpolation */
GTK4_CURVE_TYPE_FREE /* free form curve */
} Gtk4CurveType;
typedef struct _Gtk4Curve Gtk4Curve;
typedef struct _Gtk4CurveClass Gtk4CurveClass;
typedef struct _Gtk4CurvePrivate Gtk4CurvePrivate;
typedef struct _Gtk4CurveColor Gtk4CurveColor;
typedef struct _Gtk4CurveData Gtk4CurveData;
typedef struct _Gtk4CurveVector Gtk4CurveVector;
typedef struct _Gtk4CurvePoint Gtk4CurvePoint;
struct _Gtk4CurvePoint
{
gint x;
gint y;
};
struct _Gtk4CurveColor
{
gfloat red;
gfloat green;
gfloat blue;
gfloat alpha;
};
struct _Gtk4CurveVector
{
gfloat x;
gfloat y;
};
struct _Gtk4CurveData
{
gchar *description;
Gtk4CurveType curve_type;
gint n_points;
Gtk4CurvePoint *d_point;
gint n_cpoints;
Gtk4CurveVector *d_cpoints;
};
GType gtk4_curve_type_get_type (void);
GType gtk4_curve_get_type (void) G_GNUC_CONST;
GtkWidget* gtk4_curve_new (void);
void gtk4_curve_reset (GtkWidget *widget);
void gtk4_curve_set_gamma (GtkWidget *widget,
gfloat gamma_);
void gtk4_curve_set_range (GtkWidget *widget,
gfloat min_x,
gfloat max_x,
gfloat min_y,
gfloat max_y);
void gtk4_curve_get_vector (GtkWidget *widget,
gint veclen,
gfloat vector[]);
void gtk4_curve_set_vector (GtkWidget *widget,
gint veclen,
gfloat vector[]);
void gtk4_curve_set_curve_type (GtkWidget *widget,
Gtk4CurveType type);
void gtk4_curve_set_color_background (GtkWidget *widget,
Gtk4CurveColor color);
void gtk4_curve_set_color_grid (GtkWidget *widget,
Gtk4CurveColor color);
void gtk4_curve_set_color_curve (GtkWidget *widget,
Gtk4CurveColor color);
void gtk4_curve_set_color_cpoint (GtkWidget *widget,
Gtk4CurveColor color);
void gtk4_curve_set_color_background_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
void gtk4_curve_set_color_grid_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
void gtk4_curve_set_color_curve_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
void gtk4_curve_set_color_cpoint_rgba (GtkWidget *widget,
gfloat r,
gfloat g,
gfloat b,
gfloat a);
Gtk4CurveType gtk4_curve_get_curve_type (GtkWidget *widget);
Gtk4CurveColor gtk4_curve_get_color_background (GtkWidget *widget);
Gtk4CurveColor gtk4_curve_get_color_grid (GtkWidget *widget);
Gtk4CurveColor gtk4_curve_get_color_curve (GtkWidget *widget);
Gtk4CurveColor gtk4_curve_get_color_cpoint (GtkWidget *widget);
void gtk4_curve_set_use_theme_background (GtkWidget *widget,
gboolean use);
gboolean gtk4_curve_get_use_theme_background (GtkWidget *widget);
void gtk4_curve_set_grid_size (GtkWidget *widget,
Gtk4CurveGridSize size);
Gtk4CurveGridSize gtk4_curve_get_grid_size (GtkWidget *widget);
#endif /* __GTK4_CURVE__H__ */

422
libgtk/gtk4gamma.c 100644
Wyświetl plik

@ -0,0 +1,422 @@
#include <gtk/gtk.h>
#include "gtk4gamma.h"
#include "gtk4curve.h"
#define WINDOW_WIDTH 400
#define WINDOW_HEIGHT 400
/*
static const gchar *button_images[] = {
"images/spline.png",
"images/linear.png",
"images/free.png",
"images/gamma.png",
"images/reset.png"
};
*/
/* XPM */
static const char * spline_xpm[] = {
"16 16 5 1",
" c None",
". c #000000",
"+ c #824141",
"@ c #FF0000",
"# c #7F7F7F",
" ..",
" +.",
" @ ",
" @ ",
" @ ",
" #.# @ ",
" ... @ ",
" +.+ @ ",
" @ @ @ ",
" @ @ @ ",
" @ @ @ ",
" @ @.+ ",
" @ ... ",
" @ #.# ",
".+ ",
".. "};
/* XPM */
static const char * lineart_xpm[] = {
"16 16 4 1",
" c None",
". c #000000",
"+ c #FF0000",
"@ c #BC2D2D",
" ..",
" ++++++.",
" ++ ",
" .@ ",
" ... ",
" @. ",
" + ",
" + ",
" + ",
" + ",
" + ",
" + ",
" + ",
" + ",
".@ ",
".. "};
/* XPM */
static const char * free_xpm[] = {
"16 16 2 1",
" c None",
". c #FF0000",
" ",
" ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . ",
" . . .....",
" . . ",
" . . ",
" . . ",
" . . ",
". "};
/* XPM */
static const char * gamma_xpm[] = {
"16 16 10 1",
" c None",
". c #000000",
"+ c #5E5E5E",
"@ c #8C8C8C",
"# c #464646",
"$ c #171717",
"% c #BBBBBB",
"& c #757575",
"* c #A4A4A4",
"= c #2F2F2F",
" ",
" ",
" ",
" .+ @.@ ",
" #$% &$* ",
" &@ ## ",
" . .@ ",
" # # ",
" #$@ ",
" *. ",
" &+ ",
" =. ",
" .. ",
" .= ",
" ",
" "};
/* XPM */
static const char * reset_xpm[] = {
"16 16 4 1",
" c None",
". c #000000",
"+ c #824141",
"@ c #FF0000",
" ..",
" +.",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
" @ ",
".+ ",
".. "};
static const gchar ** button_images[] = {
spline_xpm,
lineart_xpm,
free_xpm,
gamma_xpm,
reset_xpm
};
enum {
LINEAR = 0,
SPLINE,
FREE,
GAMMA,
RESET,
NUM_XPMS
};
struct _Gtk4Gamma
{
GtkBox parent_instance;
GtkBox vbox;
GtkWidget *table;
GtkWidget *curve;
GtkWidget *button[5]; /* spline, linear, free, gamma, reset */
gfloat gamma;
GtkWidget *gamma_dialog;
GtkWidget *gamma_text;
};
struct _Gtk4GammaClass
{
GtkBoxClass parent_class;
};
typedef struct _Gtk4GammaClass Gtk4GammaClass;
G_DEFINE_TYPE (Gtk4Gamma, gtk4_gamma, GTK_TYPE_BOX)
static void
snapshot_blur (GtkWidget *widget,
GtkSnapshot *snapshot)
{
Gtk4Gamma *box = (Gtk4Gamma *) widget;
GTK_WIDGET_CLASS (gtk4_gamma_parent_class)->snapshot (widget, snapshot);
//gtk_snapshot_pop (snapshot);
}
static void
button_toggled_callback (GtkWidget *w, gpointer data)
{
Gtk4Gamma *c = data;
Gtk4CurveType type;
int active, i;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w)))
return;
active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (w), "_Gtk4GammaIndex"));
for (i = 0; i < 3; ++i)
if ((i != active) && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (c->button[i])))
break;
if (i < 3)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c->button[i]), FALSE);
switch (active)
{
case 0: type = GTK4_CURVE_TYPE_SPLINE; break;
case 1: type = GTK4_CURVE_TYPE_LINEAR; break;
default: type = GTK4_CURVE_TYPE_FREE; break;
}
gtk4_curve_set_curve_type (c->curve, type);
}
static void
gamma_cancel_callback (GtkWidget *w, gpointer data)
{
Gtk4Gamma *c = data;
gtk_window_destroy (GTK_WINDOW(c->gamma_dialog));
c->gamma_dialog = NULL;
}
static void
gamma_response_callback (GtkWidget *w,
gint response_id,
gpointer data)
{
if (response_id == GTK_RESPONSE_OK)
{
Gtk4Gamma *c = data;
const gchar *start;
gchar *end;
gfloat v;
start = gtk_editable_get_text (GTK_EDITABLE (c->gamma_text));
if (start)
{
v = g_strtod (start, &end);
if (end > start && v > 0.0)
c->gamma = v;
}
gtk4_curve_set_gamma (c->curve, c->gamma);
}
gamma_cancel_callback (w, data);
}
static void
button_clicked_callback (GtkWidget *w, gpointer data)
{
Gtk4Gamma *c = data;
int active;
active = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (w), "_Gtk4GammaIndex"));
if (active == 3)
{
/* set gamma */
if (c->gamma_dialog)
return;
else
{
GtkWidget *vbox, *hbox, *label, *button;
gchar buf[64];
c->gamma_dialog = gtk_dialog_new_with_buttons ("Gamma",
GTK_WINDOW (w),
GTK_DIALOG_DESTROY_WITH_PARENT,
"Ok", GTK_RESPONSE_OK,
"Cancel", GTK_RESPONSE_CANCEL,
NULL);
g_object_add_weak_pointer (G_OBJECT (c->gamma_dialog),
(gpointer *)&c->gamma_dialog);
vbox =gtk_dialog_get_content_area (GTK_DIALOG (c->gamma_dialog));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, /* spacing */ 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_append (GTK_BOX (vbox), hbox);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic ("_Gamma value");
gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (label);
sprintf (buf, "%g", c->gamma);
c->gamma_text = gtk_entry_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (label), c->gamma_text);
gtk_editable_set_text (GTK_EDITABLE (c->gamma_text), buf);
gtk_box_append (GTK_BOX (hbox), c->gamma_text);
gtk_widget_show (c->gamma_text);
/* fill in action area: */
g_signal_connect (c->gamma_dialog,
"response",
G_CALLBACK (gamma_response_callback),
c);
gtk_widget_show (c->gamma_dialog);
}
}
else
{
/* reset */
gtk4_curve_reset (c->curve);
}
}
static void
curve_type_changed_callback (GtkWidget *w, gpointer data)
{
Gtk4Gamma *c = data;
Gtk4CurveType new_type;
int active;
new_type = gtk4_curve_get_curve_type (w);
switch (new_type)
{
case GTK4_CURVE_TYPE_SPLINE: active = 0; break;
case GTK4_CURVE_TYPE_LINEAR: active = 1; break;
default: active = 2; break;
}
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (c->button[active])))
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c->button[active]), TRUE);
}
static void
gtk4_gamma_init (Gtk4Gamma *gamma) {
GtkWidget *image = NULL;
GtkWidget *vbox;
int i;
gtk_orientable_set_orientation (GTK_ORIENTABLE (GTK_BOX(gamma)), GTK_ORIENTATION_VERTICAL);
gamma->gamma = 1.0;
gamma->table = gtk_grid_new ();
gtk_grid_set_column_homogeneous (GTK_GRID (gamma->table), FALSE);
gtk_grid_set_row_homogeneous (GTK_GRID (gamma->table), FALSE);
gtk_box_append(GTK_BOX(gamma), gamma->table);
gamma->curve = gtk4_curve_new ();
g_signal_connect (gamma->curve, "curve-type-changed",
G_CALLBACK (curve_type_changed_callback), gamma);
gtk_grid_attach (GTK_GRID (gamma->table), gamma->curve, 0, 0 , 1, 1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, /* spacing */ 3);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_grid_attach (GTK_GRID (gamma->table), vbox, 1, 0 , 1, 1);
/* toggle buttons: */
for (i = 0; i < 3; ++i)
{
gamma->button[i] = gtk_toggle_button_new ();
g_object_set_data (G_OBJECT (gamma->button[i]), "_Gtk4GammaIndex", GINT_TO_POINTER (i));
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data(button_images[i]);
GtkWidget *button_image = image = gtk_image_new_from_pixbuf(pixbuf);
// GtkWidget *button_image = gtk_picture_new_for_filename(button_images[i]);
gtk_button_set_child(GTK_BUTTON(gamma->button[i]), button_image);
g_signal_connect(gamma->button[i], "toggled", G_CALLBACK(button_toggled_callback), gamma);
gtk_box_append(GTK_BOX(vbox), gamma->button[i]);
gtk_widget_show (gamma->button[i]);
}
/* push buttons: */
for (i = 3; i < 5; ++i)
{
gamma->button[i] = gtk_button_new ();
g_object_set_data (G_OBJECT (gamma->button[i]), "_Gtk4GammaIndex", GINT_TO_POINTER (i));
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data(button_images[i]);
GtkWidget *button_image = image = gtk_image_new_from_pixbuf(pixbuf);
// GtkWidget *button_image = gtk_picture_new_for_filename(button_images[i]);
gtk_button_set_child(GTK_BUTTON(gamma->button[i]), button_image);
g_signal_connect(gamma->button[i], "clicked", G_CALLBACK(button_clicked_callback), gamma);
gtk_box_append(GTK_BOX(vbox), gamma->button[i]);
gtk_widget_show (gamma->button[i]);
}
gtk_widget_show (vbox);
gtk_widget_show (gamma->table);
gtk_widget_show (gamma->curve);
}
static void
gtk4_gamma_class_init (Gtk4GammaClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
widget_class->snapshot = snapshot_blur;
}
GtkWidget*
gtk4_gamma_new () {
return g_object_new (gtk4_gamma_get_type (),
"orientation", GTK_ORIENTATION_VERTICAL,
"spacing", 32,
NULL);
}
GtkWidget*
gtk4_gamma_get_curve (GtkWidget *w) {
Gtk4Gamma *g = GTK4_GAMMA(w);
return g->curve;
}

21
libgtk/gtk4gamma.h 100644
Wyświetl plik

@ -0,0 +1,21 @@
#ifndef __GTK4_GAMMA_H__
#define __GTK4_GAMMA_H__
#include <gtk/gtk.h>
#define GTK4_TYPE_GAMMA (gtk4_gamma_get_type ())
#define GTK4_GAMMA(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK4_TYPE_GAMMA, Gtk4Gamma))
#define GTK4_IS_GAMMA(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK4_TYPE_GAMMA))
#define GTK4_GAMMA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK4_TYPE_GAMMA, Gtk4GammaClass))
#define GTK4_IS_GAMMA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK4_TYPE_GAMMA))
#define GTK4_GAMMA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK4_TYPE_GAMMA, Gtk4GammaClass))
#define GTK4_TYPE_GAMMA_TYPE (gtk4_gamma_type_get_type ())
typedef struct _Gtk4Gamma Gtk4Gamma;
GType gtk4_gamma_get_type (void);
GtkWidget* gtk4_gamma_new ();
GtkWidget* gtk4_gamma_get_curve (GtkWidget*);
#endif // __GTK4_GAMMA_H__

616
libgtk/gtk4ruler.c 100644
Wyświetl plik

@ -0,0 +1,616 @@
#include <gtk/gtk.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include "gtk4ruler.h"
#define ROUND(x) ((int) round(x))
#define GTK_PARAM_READWRITE G_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB
#define DEFAULT_RULER_FONT_SCALE PANGO_SCALE_X_SMALL
#define MINIMUM_INCR 5
#define IMMEDIATE_REDRAW_THRESHOLD 20
enum {
PROP_0,
PROP_ORIENTATION,
PROP_UNIT,
PROP_LOWER,
PROP_UPPER,
PROP_POSITION,
PROP_MAX_SIZE
};
typedef struct _Gtk4RulerMetric Gtk4RulerMetric;
struct _Gtk4Ruler
{
GtkBox parent_instance;
GtkOrientation orientation;
Gtk4RulerMetricUnit unit;
gdouble lower;
gdouble upper;
gdouble position;
gdouble max_size;
GdkWindow *input_window;
cairo_surface_t *backing_store;
gboolean backing_store_valid;
GdkRectangle last_pos_rect;
guint pos_redraw_idle_id;
PangoLayout *layout;
gdouble font_scale;
GList *track_widgets;
};
typedef struct _Gtk4Ruler Gtk4Ruler;
struct _Gtk4RulerClass
{
GtkBoxClass parent_class;
};
typedef struct _Gtk4RulerClass Gtk4RulerClass;
static GType gtk4_ruler_get_type (void);
G_DEFINE_TYPE (Gtk4Ruler, gtk4_ruler, GTK_TYPE_BOX)
struct _Gtk4RulerMetric
{
gdouble ruler_scale[16];
gint subdivide[5];
};
Gtk4RulerMetric ruler_metric;
// Ruler metric for general use.
static const Gtk4RulerMetric ruler_metric_general = {
{ 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000, 25000, 50000, 100000 },
{ 1, 5, 10, 50, 100 }
};
// Ruler metric for inch scales.
static const Gtk4RulerMetric ruler_metric_inches = {
{ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768 },
{ 1, 2, 4, 8, 16 }
};
#if 0
static const Gtk4RulerMetric ruler_metric_feet =
{
/* 3 feet = 1 yard; 6 feet = 1 fathom */
{ 1, 3, 6, 12, 36, 72, 100, 250, 500, 1000, 2500, 5000, 10000, 25000, 50000, 100000 },
/* 1 foot = 12 inches, so let's divide up to 12, */
{ 1, 3, 6, 12,
/* then divide the inch by 2. */
24 }
};
static const Gtk4RulerMetric ruler_metric_yards =
{
/* 1 fathom = 2 yards. Should we go back to base-10 digits? */
{ 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000, 25000, 50000, 100000 },
/* 1 yard = 3 feet = 36 inches. */
{ 1, 3, 6, 12, 36 }
};
#endif
static void
gtk4_ruler_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
{
Gtk4Ruler *ruler = GTK4_RULER (widget);;
GtkStyleContext *context = gtk_widget_get_style_context (widget);
GtkAllocation allocation;
gtk_widget_get_allocation (widget, &allocation);
gtk_render_background (context, cr, 0, 0, allocation.width, allocation.height);
gtk_render_frame (context, cr, 0, 0, allocation.width, allocation.height);
gtk3_ruler_draw_ticks (ruler);
cairo_set_source_surface(cr, priv->backing_store, 0, 0);
cairo_paint(cr);
gtk3_ruler_draw_pos (ruler, cr);
gtk_snapshot_push_blur (snapshot, box->radius);
GTK_WIDGET_CLASS (gtk4_ruler_parent_class)->snapshot (widget, snapshot);
gtk_snapshot_pop (snapshot);
}
static void
gtk4_ruler_init (Gtk4Ruler *ruler) {
gtk_widget_set_has_window (GTK_WIDGET (ruler), FALSE);
ruler->orientation = GTK_ORIENTATION_HORIZONTAL;
ruler->unit = GTK4_RULER_METRIC_INCHES;
ruler->lower = 0;
ruler->upper = 0;
ruler->position = 0;
ruler->max_size = 0;
ruler->backing_store = NULL;
ruler->backing_store_valid = FALSE;
ruler->last_pos_rect.x = 0;
ruler->last_pos_rect.y = 0;
ruler->last_pos_rect.width = 0;
ruler->last_pos_rect.height = 0;
ruler->pos_redraw_idle_id = 0;
ruler->font_scale = DEFAULT_RULER_FONT_SCALE;
ruler->track_widgets = NULL;
}
static void
gtk4_ruler_class_init (Gtk4RulerClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
gtk_widget_class_set_css_name (widget_class, "ruler-widget");
object_class->dispose = gtk4_ruler_dispose;
object_class->set_property = gtk4_ruler_set_property;
object_class->get_property = gtk4_ruler_get_property;
widget_class->realize = gtk4_ruler_realize;
widget_class->unrealize = gtk4_ruler_unrealize;
widget_class->map = gtk4_ruler_map;
widget_class->unmap = gtk4_ruler_unmap;
widget_class->size_allocate = gtk4_ruler_size_allocate;
widget_class->get_preferred_width = gtk4_ruler_get_preferred_width;
widget_class->get_preferred_height = gtk4_ruler_get_preferred_height;
widget_class->style_updated = gtk4_ruler_style_updated;
widget_class->snapshot = gtk4_ruler_snapshot;
widget_class->motion_notify_event = gtk4_ruler_motion_notify;
g_object_class_install_property (object_class,
PROP_ORIENTATION,
g_param_spec_enum ("orientation",
("Orientation"),
("The orientation of the ruler"),
GTK_TYPE_ORIENTATION,
GTK_ORIENTATION_HORIZONTAL,
GTK_PARAM_READWRITE));
/* FIXME: Should probably use g_param_spec_enum */
g_object_class_install_property (object_class,
PROP_UNIT,
g_param_spec_string ("unit",
("Unit"),
("Unit of the ruler"),
"px",
GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_LOWER,
g_param_spec_double ("lower",
("Lower"),
("Lower limit of ruler"),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_UPPER,
g_param_spec_double ("upper",
("Upper"),
("Upper limit of ruler"),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_POSITION,
g_param_spec_double ("position",
("Position"),
("Position of mark on the ruler"),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
GTK_PARAM_READWRITE));
g_object_class_install_property (object_class,
PROP_MAX_SIZE,
g_param_spec_double ("max-size",
("Max Size"),
("Maximum size of the ruler"),
-G_MAXDOUBLE,
G_MAXDOUBLE,
0.0,
GTK_PARAM_READWRITE));
gtk_widget_class_install_style_property (widget_class,
g_param_spec_double ("font-scale",
NULL, NULL,
0.0,
G_MAXDOUBLE,
DEFAULT_RULER_FONT_SCALE,
G_PARAM_READABLE));
}
static void
gtk4_ruler_dispose (GObject *object)
{
Gtk4Ruler *ruler = GTK4_RULER(object);
if (ruler == NULL || ruler->track_widgets == NULL || g_list_length (ruler->track_widgets) == 0) { return; }
while (ruler->track_widgets != NULL) {
GtkWidget *widget = ruler->track_widgets->data;
if (!GTK_IS_WIDGET (widget))break;
ruler->track_widgets = g_list_remove (ruler->track_widgets, widget);
gtk4_ruler_remove_track_widget(ruler, widget);
}
if (ruler->pos_redraw_idle_id) {
g_source_remove(ruler->pos_redraw_idle_id);
ruler->pos_redraw_idle_id = 0;
}
ruler->track_widgets = NULL;
G_OBJECT_CLASS (parent_class)->dispose(object);
}
/**
* gtk4_ruler_set_range:
* @ruler: the Gtk4Ruler
* @lower: the lower limit of the ruler
* @upper: the upper limit of the ruler
* @max_size: the maximum size of the ruler used when calculating the space to
* leave for the text
*
* This sets the range of the ruler.
*/
void
gtk4_ruler_set_range (Gtk4Ruler *ruler,
gdouble lower,
gdouble upper,
gdouble max_size)
{
g_return_if_fail (GTK4_IS_RULER (ruler));
g_object_freeze_notify (G_OBJECT (ruler));
if (ruler->lower != lower)
{
ruler->lower = lower;
g_object_notify (G_OBJECT (ruler), "lower");
}
if (ruler->upper != upper)
{
ruler->upper = upper;
g_object_notify (G_OBJECT (ruler), "upper");
}
if (ruler->max_size != max_size)
{
ruler->max_size = max_size;
g_object_notify (G_OBJECT (ruler), "max-size");
}
g_object_thaw_notify (G_OBJECT (ruler));
ruler->backing_store_valid = FALSE;
gtk_widget_queue_draw (GTK_WIDGET (ruler));
}
/**
* gtk4_ruler_get_range:
* @ruler: a #Gtk4Ruler
* @lower: (allow-none): location to store lower limit of the ruler, or %NULL
* @upper: (allow-none): location to store upper limit of the ruler, or %NULL
* @max_size: location to store the maximum size of the ruler used when calculating
* the space to leave for the text, or %NULL.
*
* Retrieves values indicating the range and current position of a #Gtk4Ruler.
* See gtk4_ruler_set_range().
**/
void
gtk4_ruler_get_range (Gtk4Ruler *ruler,
gdouble *lower,
gdouble *upper,
gdouble *max_size)
{
g_return_if_fail (GTK4_IS_RULER (ruler));
if (lower)
*lower = ruler->lower;
if (upper)
*upper = ruler->upper;
if (max_size)
*max_size = ruler->max_size;
}
static void
gtk4_ruler_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
Gtk4Ruler *ruler = GTK4_RULER (object);
switch (prop_id)
{
case PROP_ORIENTATION:
ruler->orientation = (GtkOrientation)g_value_get_enum (value);
gtk_widget_queue_resize (GTK_WIDGET (ruler));
break;
case PROP_UNIT:
gtk4_ruler_set_unit (ruler, (Gtk4RulerMetricUnit)g_value_get_int (value));
break;
case PROP_LOWER:
gtk4_ruler_set_range (ruler,
g_value_get_double (value),
ruler->upper,
ruler->max_size);
break;
case PROP_UPPER:
gtk4_ruler_set_range (ruler,
ruler->lower,
g_value_get_int (value),
ruler->max_size);
break;
case PROP_POSITION:
gtk4_ruler_set_position (ruler, g_value_get_double (value));
break;
case PROP_MAX_SIZE:
gtk4ruler_set_range (ruler,
ruler->lower,
ruler->upper,
g_value_get_double (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk4_ruler_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
Gtk4Ruler *ruler = GTK4_RULER (object);
switch (prop_id)
{
case PROP_ORIENTATION:
g_value_set_enum (value, ruler->orientation);
break;
case PROP_UNIT:
g_value_set_int (value, ruler->unit);
break;
case PROP_LOWER:
g_value_set_double (value, ruler->lower);
break;
case PROP_UPPER:
g_value_set_double (value, ruler->upper);
break;
case PROP_POSITION:
g_value_set_double (value, ruler->position);
break;
case PROP_MAX_SIZE:
g_value_set_double (value, ruler->max_size);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk4_ruler_realize (GtkWidget *widget)
{
Gtk4Ruler *ruler = GTK4_RULER (widget);
GtkAllocation allocation;
GdkWindowAttr attributes;
gint attributes_mask;
GTK_WIDGET_CLASS (gtk4_ruler_parent_class)->realize (widget);
gtk_widget_get_allocation (widget, &allocation);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = allocation.x;
attributes.y = allocation.y;
attributes.width = allocation.width;
attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_ONLY;
attributes.event_mask = (gtk_widget_get_events (widget) |
GDK_EXPOSURE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y;
ruler->input_window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (ruler->input_window, ruler);
gtk4_ruler_make_pixmap (ruler);
}
static void
gtk4_ruler_unrealize(GtkWidget *widget)
{
Gtk4Ruler *ruler = GTK4_RULER (widget);
if (ruler->backing_store)
{
cairo_surface_destroy (ruler->backing_store);
ruler->backing_store = NULL;
}
ruler->backing_store_valid = FALSE;
if (ruler->layout)
{
g_object_unref (ruler->layout);
ruler->layout = NULL;
}
if (ruler->input_window)
{
gdk_window_destroy (ruler->input_window);
ruler->input_window = NULL;
}
GTK_WIDGET_CLASS (gtk4_ruler_parent_class)->unrealize (widget);
}
static void
gtk4_ruler_map (GtkWidget *widget)
{
Gtk4Ruler *ruler = GTK4_RULER (widget);
GTK_WIDGET_CLASS (gtk4_ruler_parent_class)->map (widget);
if (ruler->input_window)
gdk_window_show (ruler->input_window);
}
static void
gtk4_ruler_unmap (GtkWidget *widget)
{
Gtk4Ruler *ruler = GTK4_RULER (widget);
if (ruler->input_window)
gdk_window_hide (ruler->input_window);
GTK_WIDGET_CLASS (gtk4_ruler_parent_class)->unmap (widget);
}
static void
gtk4_ruler_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
Gtk4Ruler *ruler = GTK4_RULER(widget);
GtkAllocation widget_allocation;
gboolean resized;
gtk_widget_get_allocation (widget, &widget_allocation);
resized = (widget_allocation.width != allocation->width ||
widget_allocation.height != allocation->height);
GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (ruler->input_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
if (resized)
gtk4_ruler_make_pixmap (ruler);
}
}
static void
gtk4_ruler_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
Gtk4Ruler *ruler = GTK4_RULER (widget);
PangoLayout *layout;
PangoRectangle ink_rect;
gint size;
layout = gtk4_ruler_get_layout (widget, "0123456789");
pango_layout_get_pixel_extents (layout, &ink_rect, NULL);
size = 2 + ink_rect.height * 1.7;
GtkStyleContext *context = gtk_widget_get_style_context (widget);
GtkBorder border;
GtkStateFlags state_flags = gtk_style_context_get_state (context);
gtk_style_context_get_border (context, state_flags, &border);
requisition->width = border.left + border.right;
requisition->height = border.top + border.bottom;
if (ruler->orientation == GTK_ORIENTATION_HORIZONTAL)
{
requisition->width += 1;
requisition->height += size;
}
else
{
requisition->width += size;
requisition->height += 1;
}
}
static void
gtk4_ruler_style_updated (GtkWidget *widget)
{
Gtk4Ruler *ruler = GTK4_RULER (widget);
GTK_WIDGET_CLASS (gtk4_ruler_parent_class)->style_updated (widget);
gtk_widget_style_get (widget,
"font-scale", &ruler->font_scale,
NULL);
if (ruler->layout)
{
g_object_unref (ruler->layout);
ruler->layout = NULL;
}
}
static void
gtk4_ruler_get_preferred_width (GtkWidget *widget,
gint *minimum_width,
gint *natural_width)
{
GtkRequisition requisition;
gtk4_ruler_size_request (widget, &requisition);
*minimum_width = *natural_width = requisition.width;
}
static void
gtk4_ruler_get_preferred_height (GtkWidget *widget,
gint *minimum_height,
gint *natural_height)
{
GtkRequisition requisition;
gtk4_ruler_size_request(widget, &requisition);
*minimum_height = *natural_height = requisition.height;
}
GtkWidget *
gtk4_ruller_new () {
return g_object_new (gtk4_ruler_get_type (),
"orientation", GTK_ORIENTATION_VERTICAL,
"spacing", 32,
NULL);
}

79
libgtk/sample-gtk4.c 100644
Wyświetl plik

@ -0,0 +1,79 @@
#include <gtk/gtk.h>
#include <gtk4curve.h>
#include <gtk4gamma.h>
#define WINDOW_WIDTH 400
#define WINDOW_HEIGHT 400
static void
activate (GtkApplication *app, gpointer user_data)
{
GtkWidget *window;
GtkWidget *da;
GtkWidget *gamma;
GtkWidget *grid;
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Window");
// gtk_container_set_border_width (GTK_CONTAINER (window), 10);
grid = gtk_grid_new();
{
/*
da = gtk4_curve_new ();
gtk_widget_set_name (da, "curve1");
gamma = da;
*/
if (strstr((const char*)user_data, "gtk4curve-sample"))
{
da = gtk4_curve_new ();
gtk_widget_set_name (da, "curve1");
gamma = da;
}
else
{
gamma = gtk4_gamma_new ();
da = gtk4_gamma_get_curve (gamma);
// gtk_widget_show (da);
gtk_widget_set_name (gamma, "GammaCurve");
// gtk_widget_set_size_request (da, WINDOW_WIDTH - 18, WINDOW_HEIGHT - 18);
}
gtk4_curve_set_color_background_rgba (da, 0.8, 0.8, 0.8, 0.5);
gtk4_curve_set_color_grid_rgba (da, 0.0, 0.0, 0.0, 0.5);
gtk4_curve_set_color_curve_rgba (da, 1.0, 1.0, 1.0, 1.0);
gtk4_curve_set_color_cpoint_rgba (da, 0.8, 0.3, 0.3, 1.0);
gtk4_curve_set_use_theme_background(da, FALSE);
gtk_widget_set_size_request (da, WINDOW_WIDTH, WINDOW_HEIGHT);
gtk4_curve_set_grid_size (da, GTK4_CURVE_GRID_SMALL);
gtk4_curve_set_range (da, 0, WINDOW_WIDTH, 0, WINDOW_HEIGHT);
}
gtk_widget_set_size_request (gamma, WINDOW_WIDTH, WINDOW_HEIGHT);
gtk_grid_attach(GTK_GRID(grid), gamma, 1, 1, 1, 1);
gtk_widget_set_halign (grid, GTK_ALIGN_CENTER);
gtk_widget_set_valign (grid, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (grid, TRUE);
gtk_window_set_child (GTK_WINDOW (window), grid);
// gtk_window_set_child (GTK_WINDOW (window), gamma);
gtk_widget_show (gamma);
gtk_widget_show (grid);
gtk_widget_show (window);
}
int
main (int argc, char **argv)
{
GtkApplication *app;
int status;
app = gtk_application_new ("org.gtk.sample", G_APPLICATION_FLAGS_NONE);
g_signal_connect (app, "activate", G_CALLBACK (activate), argv[0]);
status = g_application_run (G_APPLICATION (app), argc, argv);
g_object_unref (app);
return status;
}

215
src/gtkglue.c
Wyświetl plik

@ -36,8 +36,8 @@
#include <sys/stat.h>
#include "gtkglue.h"
#include "../libgtk/gtk3curve.h"
#include "../libgtk/gtk3gamma.h"
#include "../libgtk/gtk4curve.h"
#include "../libgtk/gtk4gamma.h"
#include "preferences.h"
#include <sane/sane.h>
#include <sane/saneopts.h>
@ -244,7 +244,7 @@ set_option (GSGDialog * dialog, int opt_num, void *val, SANE_Action action)
void
gsg_close_dialog_callback (GtkWidget * widget, gpointer data)
{
gtk_widget_destroy (data);
gtk_window_destroy (data);
gsg_message_dialog_active = 0;
}
@ -260,21 +260,21 @@ gsg_message (gchar * title, gchar * message)
return;
}
gsg_message_dialog_active = 1;
message_dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position (GTK_WINDOW (message_dialog), GTK_WIN_POS_MOUSE);
message_dialog = gtk_window_new (); // GTK_WINDOW_TOPLEVEL);
// gtk_window_set_position (GTK_WINDOW (message_dialog), GTK_WIN_POS_MOUSE);
gtk_window_set_title (GTK_WINDOW (message_dialog), title);
gtk_window_set_modal (GTK_WINDOW (message_dialog), TRUE);
/* create the main vbox */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous (GTK_BOX (main_vbox), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5);
gtk_widget_show (main_vbox);
gtk_container_add (GTK_CONTAINER (message_dialog), main_vbox);
gtk_window_set_child (GTK_WINDOW (message_dialog), main_vbox);
/* the message */
label = gtk_label_new (message);
gtk_container_add (GTK_CONTAINER (main_vbox), label);
gtk_box_append (GTK_BOX (main_vbox), label);
gtk_widget_show (label);
/* the confirmation button */
@ -282,7 +282,7 @@ gsg_message (gchar * title, gchar * message)
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (gsg_close_dialog_callback),
message_dialog);
gtk_container_add (GTK_CONTAINER (main_vbox), button);
gtk_box_append (GTK_BOX (main_vbox), button);
gtk_widget_show (button);
gtk_widget_show (message_dialog);
@ -300,46 +300,77 @@ gsg_warning (gchar * warning)
gsg_message ("Warning", warning);
}
int
gsg_get_filename (const char *label, const char *default_name,
size_t max_len, char *filename)
/*
static void
on_open_response (GObject *source,
GAsyncResult *result,
gpointer user_data)
*/
static void
on_open_response (GtkNativeDialog *dialog,
int response,
gpointer user_data)
{
int cancel = 0;
GtkWidget *filesel;
DBG (DBG_debug, "browse_filename_callback: oepn\n");
filesel = gtk_file_chooser_dialog_new ((char*) label, NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
"Ok", GTK_RESPONSE_ACCEPT,
"Cancel", GTK_RESPONSE_CANCEL,
NULL);
gtk_native_dialog_hide (dialog);
gtk_window_set_modal (GTK_WINDOW (filesel), TRUE);
if (default_name)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filesel),
(char *) default_name);
if (gtk_dialog_run (GTK_DIALOG (filesel)) == GTK_RESPONSE_ACCEPT)
if (response == GTK_RESPONSE_ACCEPT)
{
size_t len, cwd_len;
char *cwd;
strncpy (filename,
gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filesel)),
max_len - 1);
filename[max_len - 1] = '\0';
len = strlen (filename);
cwd = alloca (len + 2);
if (getcwd (cwd, len + 1) == NULL)
return -1;
cwd_len = strlen (cwd);
cwd[cwd_len++] = '/';
cwd[cwd_len] = '\0';
if (strncmp (filename, cwd, cwd_len) == 0)
memcpy (filename, filename + cwd_len, len - cwd_len + 1);
GFile *file;
file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
gchar *filename = g_file_get_path (file);
gtk_editable_set_text(GTK_EDITABLE(user_data), filename);
g_free (filename);
g_object_unref (file);
}
gtk_widget_destroy (filesel);
return cancel ? -1 : 0;
gtk_native_dialog_destroy (dialog);
DBG (DBG_debug, "browse_filename_callback: finished\n");
}
int
gsg_get_filename (const char *label, const char *default_name, gpointer user_data)
{
GtkFileChooserNative *filesel;
filesel = gtk_file_chooser_native_new ((char*)label,
NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
"Ok",
"Cancel");
gtk_native_dialog_set_modal (GTK_NATIVE_DIALOG (filesel), TRUE);
if (default_name) {
GFile * file = g_file_new_for_path ((char *) default_name);
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (filesel), file, NULL);
g_object_unref (file);
}
g_signal_connect (filesel, "response", G_CALLBACK (on_open_response), user_data);
gtk_native_dialog_show (GTK_NATIVE_DIALOG (filesel));
return 0;
}
int
gsg_set_filename (const char *label, const char *default_name, void (*save_settings) (GtkNativeDialog *ndialog, int response, gpointer user_data))
{
GtkFileChooserNative *filesel;
filesel = gtk_file_chooser_native_new ((char*)label,
NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
"Ok",
"Cancel");
gtk_native_dialog_set_modal (GTK_NATIVE_DIALOG (filesel), TRUE);
if (default_name) {
GFile * file = g_file_new_for_path ((char *) default_name);
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (filesel), file, NULL);
g_object_unref (file);
}
g_signal_connect (filesel, "response", G_CALLBACK (save_settings), NULL);
gtk_native_dialog_show (GTK_NATIVE_DIALOG (filesel));
return 0;
}
static gint
@ -386,14 +417,13 @@ autobutton_new (GtkWidget * parent, GSGDialogElement * elem,
button = gtk_check_button_new ();
g_object_set_data(G_OBJECT(button), "scale", label);
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 (button, "Turns on automatic mode.");
gtk_box_pack_end (GTK_BOX (parent), label, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (parent), button, FALSE, FALSE, 2);
gtk_box_append (GTK_BOX (parent), label);
gtk_box_append (GTK_BOX (parent), button);
gtk_widget_show (button);
}
@ -422,7 +452,7 @@ button_new (GtkWidget * parent, const char *name, SANE_Word val,
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), val);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (button_update), elem);
gtk_box_pack_start (GTK_BOX (parent), button, FALSE, TRUE, 0);
gtk_box_prepend (GTK_BOX (parent), button);
if (!is_settable)
gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE);
gtk_widget_show (button);
@ -517,11 +547,10 @@ scale_new (GtkWidget * parent, const char *name, gfloat val,
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);
gtk_box_prepend (GTK_BOX (parent), hbox);
label = gtk_label_new ((char *) name);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_box_prepend(GTK_BOX (hbox), label);
elem->data = gtk_adjustment_new (val, min, max, quant, 1.0, 0.0);
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT(elem->data));
@ -536,7 +565,7 @@ scale_new (GtkWidget * parent, const char *name, gfloat val,
if (automatic)
autobutton_new (hbox, elem, scale);
else
gtk_box_pack_end (GTK_BOX (hbox), scale, FALSE, FALSE, 0);
gtk_box_prepend (GTK_BOX (hbox), scale);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
if (quant - (int) quant == 0.0)
@ -628,10 +657,10 @@ option_menu_new (GtkWidget * parent, const char *name, char *str_list[],
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);
gtk_box_prepend (GTK_BOX (parent), hbox);
label = gtk_label_new ((char *) name);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_box_prepend (GTK_BOX (hbox), label);
for (num_items = 0; str_list[num_items]; ++num_items);
menu_items = malloc (num_items * sizeof (menu_items[0]));
@ -647,7 +676,7 @@ option_menu_new (GtkWidget * parent, const char *name, char *str_list[],
if (val && !strcmp(str_list[i], val))
selected = i;
}
gtk_box_pack_end (GTK_BOX (hbox), option_menu, FALSE, FALSE, 2);
gtk_box_append (GTK_BOX (hbox), option_menu);
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu), selected);
set_tooltip (option_menu, desc);
gtk_widget_show (label);
@ -679,7 +708,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';
@ -688,7 +717,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,14 +729,14 @@ text_entry_new (GtkWidget * parent, const char *name, const char *val,
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);
gtk_box_prepend (GTK_BOX (parent), hbox);
label = gtk_label_new ((char *) name);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_box_prepend (GTK_BOX (hbox), label);
text = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (text), (char *) val);
gtk_box_pack_start (GTK_BOX (hbox), text, FALSE, TRUE, 0);
gtk_editable_set_text (GTK_EDITABLE (text), (char *) val);
gtk_box_prepend (GTK_BOX (hbox), text);
g_signal_connect (G_OBJECT (text), "changed",
G_CALLBACK (text_entry_callback), elem);
set_tooltip (text, desc);
@ -727,14 +756,13 @@ group_new (GtkWidget * parent, const char *title)
GtkWidget *frame, *vbox;
frame = gtk_frame_new ((char *) title);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_box_pack_start (GTK_BOX (parent), frame, FALSE, FALSE, 0);
gtk_box_prepend (GTK_BOX (parent), frame);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_frame_set_child (GTK_FRAME (frame), vbox);
gtk_widget_show (vbox);
return vbox;
}
@ -750,16 +778,16 @@ curve_new (GSGDialog * dialog, int optnum)
SANE_Handle dev;
int i, optlen;
gamma = gtk3_gamma_curve_new ();
curve = GTK3_GAMMA_CURVE (gamma)->curve;
gtk3_curve_set_color_background_rgba (curve, 0.8, 0.8, 0.8, 0.5);
gtk3_curve_set_color_grid_rgba (curve, 0.0, 0.0, 0.0, 0.5);
gtk3_curve_set_color_curve_rgba (curve, 1.0, 1.0, 1.0, 1.0);
gtk3_curve_set_color_cpoint_rgba (curve, 0.8, 0.3, 0.3, 1.0);
gamma = gtk4_gamma_new ();
curve = gtk4_gamma_get_curve (gamma);
gtk4_curve_set_color_background_rgba (curve, 0.8, 0.8, 0.8, 0.5);
gtk4_curve_set_color_grid_rgba (curve, 0.0, 0.0, 0.0, 0.5);
gtk4_curve_set_color_curve_rgba (curve, 1.0, 1.0, 1.0, 1.0);
gtk4_curve_set_color_cpoint_rgba (curve, 0.8, 0.3, 0.3, 1.0);
gtk3_curve_set_use_theme_background(curve, FALSE);
gtk3_curve_set_grid_size (curve, GTK3_CURVE_GRID_SMALL);
// gtk3_curve_set_range (da, 0, WINDOW_WIDTH, 0, WINDOW_HEIGHT);
gtk4_curve_set_use_theme_background(curve, FALSE);
gtk4_curve_set_grid_size (curve, GTK4_CURVE_GRID_SMALL);
// gtk4_curve_set_range (da, 0, WINDOW_WIDTH, 0, WINDOW_HEIGHT);
dev = dialog->dev;
opt = sane_get_option_descriptor (dev, optnum);
@ -812,8 +840,8 @@ curve_new (GSGDialog * dialog, int optnum)
}
// gtk_widget_set_size_request (curve, optlen-1, fmax);
gtk_widget_set_size_request (curve, 200, 200);
gtk3_curve_set_range (GTK_WIDGET (curve), 0, optlen - 1, fmin, fmax);
// gtk3_curve_set_range (da, 0, WINDOW_WIDTH, 0, WINDOW_HEIGHT);
gtk4_curve_set_range (GTK_WIDGET (curve), 0, optlen - 1, fmin, fmax);
// gtk4_curve_set_range (da, 0, WINDOW_WIDTH, 0, WINDOW_HEIGHT);
status = sane_control_option (dev, optnum, SANE_ACTION_GET_VALUE,
optval, 0);
@ -827,7 +855,7 @@ curve_new (GSGDialog * dialog, int optnum)
val = optval[i];
vector[i] = val;
}
gtk3_curve_set_vector (GTK_WIDGET (curve), optlen, vector);
gtk4_curve_set_vector (GTK_WIDGET (curve), optlen, vector);
}
else
gtk_widget_set_sensitive (gamma, FALSE);
@ -843,7 +871,7 @@ vector_new (GSGDialog * dialog, GtkWidget * vbox, int num_vopts, int *vopts)
int i;
notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
gtk_box_prepend (GTK_BOX (vbox), notebook);
for (i = 0; i < num_vopts; ++i)
{
@ -858,7 +886,7 @@ vector_new (GSGDialog * dialog, GtkWidget * vbox, int num_vopts, int *vopts)
curve = curve_new (dialog, vopts[i]);
if (curve)
gtk_box_pack_start (GTK_BOX (vbox), curve, TRUE, TRUE, 0);
gtk_box_prepend (GTK_BOX (vbox), curve);
gtk_widget_show (curve);
dialog->element[vopts[i]].widget = curve;
@ -873,7 +901,8 @@ panel_destroy (GSGDialog * dialog)
GSGDialogElement *elem;
int i, j;
gtk_widget_destroy (dialog->main_hbox);
g_object_unref (dialog->main_hbox);
dialog->main_hbox = NULL;
/* free the menu labels of integer/fix-point word-lists: */
for (i = 0; i < dialog->num_elements; ++i)
@ -928,7 +957,7 @@ panel_build (GSGDialog * dialog)
}
gtk_box_set_homogeneous (GTK_BOX (option_vbox), FALSE);
gtk_box_pack_start (GTK_BOX (main_hbox), option_vbox, FALSE, FALSE, 0);
gtk_box_prepend (GTK_BOX (main_hbox), option_vbox);
gtk_widget_show (option_vbox);
/* standard options vbox */
@ -936,17 +965,17 @@ panel_build (GSGDialog * dialog)
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);
gtk_box_prepend (GTK_BOX (option_vbox), standard_vbox);
/* advanced options page */
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);
gtk_box_prepend (GTK_BOX (option_vbox), advanced_vbox);
gsg_set_tooltips (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;
@ -1219,9 +1248,9 @@ panel_build (GSGDialog * dialog)
set_tooltip (button, opt->desc);
label = gtk_label_new (title);
gtk_container_add (GTK_CONTAINER (button), label);
gtk_button_set_child (GTK_BUTTON (button), label);
gtk_box_pack_start (GTK_BOX (parent), button, FALSE, TRUE, 0);
gtk_box_prepend (GTK_BOX (parent), button);
gtk_widget_show (label);
gtk_widget_show (button);
@ -1426,8 +1455,8 @@ gsg_sync (GSGDialog * dialog)
optval = alloca (optlen * sizeof (optval[0]));
vector = alloca (optlen * sizeof (vector[0]));
curve = GTK3_GAMMA_CURVE (dialog->element[i].widget)->curve;
gtk3_curve_get_vector (GTK_WIDGET (curve), optlen, vector);
curve = gtk4_gamma_get_curve (dialog->element[i].widget);
gtk4_curve_get_vector (GTK_WIDGET (curve), optlen, vector);
for (j = 0; j < optlen; ++j)
{
val = vector[j];
@ -1457,25 +1486,25 @@ gsg_set_tooltips (int enable)
if (enable)
{
if (css_prov) {
gtk_style_context_remove_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css_prov));
gtk_style_context_remove_provider_for_display(gdk_display_get_default(), GTK_STYLE_PROVIDER(css_prov));
g_object_unref(css_prov);
}
css_prov = gtk_css_provider_new();
const gchar style[] = "tooltip {opacity:1;}";
gtk_css_provider_load_from_data(css_prov, style, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css_prov),
gtk_css_provider_load_from_data(css_prov, style, -1);
gtk_style_context_add_provider_for_display(gdk_display_get_default(), GTK_STYLE_PROVIDER(css_prov),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
else
{
if (css_prov) {
gtk_style_context_remove_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css_prov));
gtk_style_context_remove_provider_for_display(gdk_display_get_default(), GTK_STYLE_PROVIDER(css_prov));
g_object_unref(css_prov);
}
css_prov = gtk_css_provider_new();
const gchar style[] = "tooltip {opacity:0;}";
gtk_css_provider_load_from_data(css_prov, style, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css_prov),
gtk_css_provider_load_from_data(css_prov, style, -1);
gtk_style_context_add_provider_for_display(gdk_display_get_default(), GTK_STYLE_PROVIDER(css_prov),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}

8
src/gtkglue.h
Wyświetl plik

@ -57,8 +57,8 @@ typedef struct GSGDialog
GtkWidget *advanced_vbox;
int twocolumn;
GtkTooltip *tooltips;
GdkColor tooltips_fg;
GdkColor tooltips_bg;
GdkRGBA tooltips_fg;
GdkRGBA tooltips_bg;
SANE_Handle *dev;
const char *dev_name;
GSGWellKnownOptions well_known;
@ -98,8 +98,8 @@ extern int gsg_make_path (size_t max_len, char *filename_ret,
extern void gsg_message (gchar *title, gchar * message);
extern void gsg_error (gchar * error_message);
extern void gsg_warning (gchar * warning_message);
extern int gsg_get_filename (const char *label, const char *default_name,
size_t max_len, char *filename);
extern int gsg_get_filename (const char *label, const char *default_name, gpointer user_data);
extern int gsg_set_filename (const char *label, const char *default_name, void (*save_settings) (GtkNativeDialog *ndialog, int response, gpointer user_data));
extern GSGDialog *gsg_create_dialog (GtkWidget *window,
const char *device_name,

147
src/preview.c
Wyświetl plik

@ -118,6 +118,7 @@
static void scan_start (Preview * p);
static void scan_done (Preview * p);
/*
static gboolean
_last_call_time_check(unsigned long interval)
{
@ -135,22 +136,59 @@ _last_call_time_check(unsigned long interval)
return TRUE;
}
*/
static GdkMonitor*
_get_largest_size (gint *width, gint *height)
{
GdkDisplay *display = gdk_display_get_default ();
GListModel *monitors; /* (unowned) */
GdkMonitor *monitor; /* (unowned) */
int monitor_max_dimension;
guint n_monitors;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
monitors = gdk_display_get_monitors (display);
n_monitors = g_list_model_get_n_items (monitors);
monitor_max_dimension = 0;
monitor = NULL;
for (guint i = 0; i < n_monitors; i++) {
g_autoptr(GdkMonitor) monitor2 = g_list_model_get_item (monitors, i);
GdkRectangle monitor_geometry;
int monitor2_max_dimension;
if (monitor2 == NULL)
continue;
gdk_monitor_get_geometry (monitor2, &monitor_geometry);
monitor2_max_dimension = MAX (monitor_geometry.width, monitor_geometry.height);
if (monitor2_max_dimension > monitor_max_dimension) {
*width = monitor_geometry.width;
*height = monitor_geometry.height;
monitor_max_dimension = monitor2_max_dimension;
continue;
}
}
return monitor;
}
static void
screen_size_get_dimensions (gint *width, gint *height)
{
GdkScreen *screen;
GdkWindow *window;
gint scale;
GdkMonitor *monitor; /* (unowned) */
screen = gdk_screen_get_default ();
window = gdk_screen_get_root_window (screen);
gint mwidth = 0, mheight = 0;
double scale;
monitor = _get_largest_size(&mwidth, &mheight);
scale = gdk_window_get_scale_factor (window);
scale = gdk_monitor_get_scale_factor (monitor);
*width = gdk_window_get_width (window) / scale;
*height = gdk_window_get_height (window) / scale;
*width = (int)((double)mwidth * scale);
*height = (int)((double)mheight * scale);
}
static void
@ -382,19 +420,13 @@ display_image (Preview * p)
}
static void
preview_area_resize (GtkWidget * widget, GdkEventConfigure *event, gpointer data)
preview_area_resize (GdkSurface *surface, int width, int height, gpointer data)
{
float min_x, max_x, min_y, max_y, xscale, yscale, f;
GtkAllocation alloc;
Preview *p = data;
/*if (!_last_call_time_check(1000000))
return;
*/
gtk_widget_get_allocated_size (widget, &alloc, NULL);
p->preview_width = alloc.width;
p->preview_height = alloc.height;
p->preview_width = width;
p->preview_height = height;
if (p->preview_row)
p->preview_row = realloc (p->preview_row, 3 * p->preview_width);
@ -438,26 +470,26 @@ preview_area_resize (GtkWidget * widget, GdkEventConfigure *event, gpointer data
f = xscale * p->preview_width / p->image_width;
else
f = 1.0;
/*
gtk3_ruler_set_range (GTK3_RULER (p->hruler),
f * min_x,
f * max_x,
// f * min_x,
20); // max_size
*/
if (p->surface_unit == SANE_UNIT_PIXEL)
f = 1.0 / yscale;
else if (p->image_height)
f = yscale * p->preview_height / p->image_height;
else
f = 1.0;
/*
gtk3_ruler_set_range (GTK3_RULER (p->vruler),
f * min_y,
f * max_y,
// f * min_y,
20); // max_size
*/
update_selection (p);
paint_image (p);
//gtk_widget_queue_draw (p->window);
@ -651,11 +683,11 @@ input_available (gint source, GIOCondition cond, gpointer data)
if (p->input_tag < 0)
{
display_maybe (p);
while (gtk_events_pending ())
while (g_main_context_pending(NULL))
{
gtk_widget_queue_draw(p->window);
gtk_main_iteration ();
}
g_main_context_iteration(NULL, FALSE);
}
}
else
{
@ -681,11 +713,11 @@ input_available (gint source, GIOCondition cond, gpointer data)
if (p->input_tag < 0)
{
display_maybe (p);
while (gtk_events_pending ())
{
gtk_widget_queue_draw(p->window);
gtk_main_iteration ();
}
while (g_main_context_pending(NULL))
{
gtk_widget_queue_draw(p->window);
g_main_context_iteration(NULL, FALSE);
}
continue;
}
else
@ -884,10 +916,10 @@ input_available (gint source, GIOCondition cond, gpointer data)
if (p->input_tag < 0)
{
display_maybe (p);
while (gtk_events_pending ())
while (g_main_context_pending(NULL))
{
gtk_widget_queue_draw(p->window);
gtk_main_iteration ();
gtk_widget_queue_draw(p->window);
g_main_context_iteration(NULL, FALSE);
}
}
}
@ -989,11 +1021,11 @@ scan_start (Preview * p)
(current.tv_sec - start.tv_sec) / (gfloat) 60);
# endif
while (gtk_events_pending ())
while (g_main_context_pending(NULL))
{
gtk_widget_queue_draw(p->window);
gtk_main_iteration ();
}
gtk_widget_queue_draw(p->window);
g_main_context_iteration(NULL, FALSE);
}
status = sane_start (dev);
}
progress_free (progress);
@ -1189,6 +1221,7 @@ expose_handler (GtkWidget * window, cairo_t *cr, gpointer data)
return FALSE;
}
/*
static gboolean
button_press_handler(GtkWidget *window,
GdkEvent *event, gpointer data)
@ -1259,6 +1292,7 @@ motion_handler (GtkWidget *window,
}
return FALSE;
}
*/
static void
start_button_clicked (GtkWidget * widget, gpointer data)
@ -1319,54 +1353,59 @@ preview_new (GSGDialog * dialog)
table = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (table), 1);
gtk_grid_set_row_spacing (GTK_GRID (table), 1);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_box_pack_start (vbox, table, TRUE, TRUE, 0);
// gtk_container_set_border_width (GTK_CONTAINER (table), 2);
gtk_box_append (vbox, table);
/* the empty box in the top-left corner */
frame = gtk_frame_new ( /* label */ 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
// gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_grid_attach (GTK_GRID (table), frame, 0, 0, 1, 1);
/* the horizontal ruler */
/*
p->hruler = gtk3_ruler_new (GTK_ORIENTATION_HORIZONTAL);
gtk_grid_attach (GTK_GRID (table), p->hruler, 1, 0, 1, 1);
gsg_widget_placement(GTK_WIDGET (p->hruler), GTK_ALIGN_FILL, GTK_ALIGN_CENTER, 0, 0, 0, 0);
*/
/* the vertical ruler */
/*
p->vruler = gtk3_ruler_new (GTK_ORIENTATION_VERTICAL);
gtk_grid_attach (GTK_GRID (table), p->vruler, 0, 1, 1, 1);
gsg_widget_placement(GTK_WIDGET (p->vruler), GTK_ALIGN_CENTER, GTK_ALIGN_FILL, 0, 0, 0, 0);
*/
/* the preview area */
p->window = gtk_drawing_area_new ();
gtk_widget_set_app_paintable(p->window, TRUE);
// gtk_widget_set_app_paintable(p->window, TRUE);
gsg_widget_placement(GTK_WIDGET (p->window), GTK_ALIGN_FILL, GTK_ALIGN_FILL, 0, 0, 0, 0);
/*
gtk_widget_set_events (p->window,
GDK_EXPOSURE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
*/
g_signal_connect_after (G_OBJECT (p->window), "draw",
G_CALLBACK(expose_handler), p);
/*
g_signal_connect(G_OBJECT(p->window), "button_press_event",
G_CALLBACK(button_press_handler), p);
g_signal_connect(G_OBJECT(p->window), "motion_notify_event",
G_CALLBACK(motion_handler), p);
g_signal_connect(G_OBJECT(p->window), "button_release_event",
G_CALLBACK(button_release_handler), p);
g_signal_connect (p->window ,"configure-event",
G_CALLBACK(preview_area_resize), p);
*/
g_signal_connect (gtk_native_get_surface (GTK_NATIVE (p->window)), "layout",
G_CALLBACK (preview_area_resize), p);
/*
gtk3_ruler_add_track_widget (GTK3_RULER (p->hruler), p->window);
gtk3_ruler_add_track_widget (GTK3_RULER (p->vruler), p->window);
*/
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);
// gtk_frame_set_shadow_type (GTK_FRAME (p->viewport), GTK_SHADOW_IN);
gtk_frame_set_child (GTK_FRAME (p->viewport), p->window);
gtk_grid_attach (GTK_GRID (table), p->viewport, 1, 1, 1, 1);
gsg_widget_placement(GTK_WIDGET (p->viewport), GTK_ALIGN_FILL, GTK_ALIGN_FILL, 0, 0, 0, 0);
@ -1488,10 +1527,8 @@ preview_update (Preview * p)
}
else
{
GtkAllocation alloc;
gtk_widget_get_allocated_size (p->window, &alloc, NULL);
max_width = alloc.width;
max_height = alloc.height;
max_width = gtk_widget_get_width (GTK_WIDGET(p->window));
max_height = gtk_widget_get_height (GTK_WIDGET(p->window));
}
if (p->surface_unit != SANE_UNIT_PIXEL)
@ -1530,7 +1567,7 @@ preview_update (Preview * p)
gtk_widget_set_size_request (GTK_WIDGET (p->window),
p->preview_width, p->preview_height);
if (gtk_widget_is_drawable(GTK_WIDGET(p->window)))
preview_area_resize (p->window, NULL, p);
preview_area_resize (gtk_native_get_surface(GTK_NATIVE(p->window)), gtk_widget_get_width (p->window), gtk_widget_get_height (p->window), p);
if (preferences.preserve_preview)
restore_preview_image (p);
@ -1638,6 +1675,6 @@ preview_destroy (Preview * p)
free (p->preview_row);
p->preview_row = NULL;
if (p->top)
gtk_widget_destroy (p->top);
gtk_window_destroy (GTK_WINDOW(p->top));
free (p);
}

10
src/progress.c
Wyświetl plik

@ -55,22 +55,20 @@ progress_new (char *title, char *text, GtkWindow * parent,
gtk_window_set_title (GTK_WINDOW (p->shell), title);
vbox = GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG (p->shell)));
gtk_container_set_border_width (GTK_CONTAINER (vbox), 7);
label = gtk_label_new (text);
gtk_label_set_xalign(GTK_LABEL(label), 0.0);
gtk_label_set_yalign(GTK_LABEL(label), 0.5);
gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
gtk_box_prepend (vbox, label);
p->pbar = gtk_progress_bar_new ();
gtk_widget_set_size_request (p->pbar, 200, 20);
gtk_box_pack_start (vbox, p->pbar, TRUE, TRUE, 0);
gtk_box_prepend (vbox, p->pbar);
#ifdef HAVE_SYS_TIME_H
p->etaIndicator = gtk_label_new (ETA_LABEL ": ?");
gtk_label_set_xalign(GTK_LABEL(p->etaIndicator), 0.0);
gtk_label_set_yalign(GTK_LABEL(p->etaIndicator), 0.5);
gtk_box_pack_start (vbox, p->etaIndicator, FALSE, TRUE, 0);
gtk_box_prepend (vbox, p->etaIndicator);
#endif
/* no cancel button if no callback */
@ -98,7 +96,7 @@ progress_free (Progress_t * p)
{
if (p)
{
gtk_widget_destroy (p->shell);
gtk_window_destroy (GTK_WINDOW(p->shell));
free (p);
}
}

427
src/xcam.c
Wyświetl plik

@ -75,14 +75,14 @@ typedef struct Canvas
cairo_surface_t *surface;
GdkPixbuf *gdk_image;
guint32 graylevel[MAX_LUM]; /* graylevel pixels */
GdkColor cube_colors[5 * 6 * 5];
GdkRGBA 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";
static char device_settings_filename[4096] = "device.rc";
#define DBG_fatal 0
#define DBG_error 1
@ -192,49 +192,13 @@ display_image (Canvas * canvas)
}
}
static gint
canvas_events (GtkWidget * widget, GdkEvent * event)
static void
canvas_events (GtkDrawingArea *area, cairo_t *cr, int width, int height, gpointer user_data)
{
GdkWindow *window = NULL;
Canvas *canvas = &win.canvas;
Canvas *canvas = (Canvas *)user_data;
if (!canvas)
return FALSE;
switch (event->type)
{
case GDK_EXPOSE:
if (!canvas->surface)
{
window = gtk_widget_get_window (canvas->preview);
canvas->surface = gdk_window_create_similar_surface (
window,
CAIRO_CONTENT_COLOR,
gdk_window_get_width(window),
gdk_window_get_height(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;
return;
display_image (canvas);
}
static void
@ -308,10 +272,10 @@ switch_device_by_name (const char *device_name)
}
static void
save_settings (const char *filename)
save_settings (GtkNativeDialog *ndialog, int response, gpointer user_data)
{
int fd;
const char *filename = (const char *)user_data;
DBG (DBG_debug, "xcam: save_settings: enter\n");
fd = open (filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
@ -602,7 +566,7 @@ load_defaults (int silent)
void
device_name_dialog_cancel (GtkWidget * widget, gpointer data)
{
gtk_widget_destroy (data);
gtk_window_destroy (GTK_WINDOW(data));
}
void
@ -611,12 +575,12 @@ device_name_dialog_ok (GtkWidget * widget, gpointer data)
GtkWidget *text = data;
const char *name;
name = gtk_entry_get_text (GTK_ENTRY (text));
name = gtk_editable_get_text (GTK_EDITABLE (text));
if (!name)
return; /* huh? how come? */
switch_device_by_name (name);
gtk_widget_destroy (gtk_widget_get_toplevel (text));
// gtk_window_destroy (GTK_WINDOW(data));
}
static void
@ -627,46 +591,45 @@ prompt_for_device_name (GtkWidget * widget, gpointer data)
DBG (DBG_debug, "xcam: prompt_for_device_name: enter\n");
dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
dialog = gtk_window_new ();
// gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_window_set_title (GTK_WINDOW (dialog), "Device name");
/* create the main vbox */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (dialog), vbox);
gtk_window_set_child (GTK_WINDOW (dialog), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_box_append (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Device name:");
gtk_container_add (GTK_CONTAINER (hbox), label);
gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (label);
text = gtk_entry_new ();
gtk_container_add (GTK_CONTAINER (hbox), text);
gtk_box_append (GTK_BOX (hbox), text);
gtk_widget_show (hbox);
/* the confirmation button */
vbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_label ("OK");
gtk_widget_set_can_default (button, TRUE);
// gtk_widget_set_can_default (button, TRUE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (device_name_dialog_ok), text);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_widget_grab_default (button);
gtk_box_prepend (GTK_BOX (hbox), button);
// gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Cancel");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (device_name_dialog_cancel), dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 5);
gtk_box_prepend (GTK_BOX (hbox), button);
gtk_widget_show (button);
gtk_widget_show (hbox);
@ -692,7 +655,7 @@ save_defaults_callback (GtkWidget * widget, gpointer data)
if (make_default_filename (sizeof (buf), buf, dialog->dev_name) < 0)
return;
save_settings (buf);
save_settings (NULL, 0, buf);
}
static void
@ -704,19 +667,14 @@ load_defaults_callback (GtkWidget * widget, gpointer data)
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);
gsg_set_filename ("File to save settings to", device_settings_filename, save_settings);
}
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)
("File to load settings from", device_settings_filename, device_settings_filename) < 0)
return;
load_settings (device_settings_filename, 0);
}
@ -751,9 +709,21 @@ buttons_enable (void)
DBG (DBG_debug, "xcam: buttons_enable: exit\n");
}
static GtkWidget *
static GMenu *
build_files_menu (void)
{
GMenu *menubar = g_menu_new ();
GMenu *menu = g_menu_new ();
GMenu *section1 = g_menu_new ();
GMenuItem *menu_item_quit = g_menu_item_new ("Quit", "app.quit");
g_menu_append_item (section1, menu_item_quit);
g_object_unref (menu_item_quit);
g_menu_append_section (menu, NULL, G_MENU_MODEL (section1));
g_menu_append_submenu (menubar, "File", G_MENU_MODEL (menu));
return menubar;
/*
GtkWidget *menu, *item;
DBG (DBG_debug, "xcam: build_files_menu: enter\n");
@ -772,6 +742,8 @@ build_files_menu (void)
DBG (DBG_debug, "xcam: build_files_menu: exit\n");
return menu;
*/
return NULL;
}
static gboolean
@ -791,6 +763,7 @@ device_activate_callback (GtkWidget * widget, gpointer data)
static GtkWidget *
build_device_menu (void)
{
/*
GtkWidget *menu, *item;
SANE_Status status;
int i;
@ -831,40 +804,49 @@ build_device_menu (void)
gtk_widget_show (item);
return menu;
*/
return NULL;
}
static void
pref_toggle_advanced (GtkWidget * widget, gpointer data)
{
/*
preferences.advanced = (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)) != 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_get_active (GTK_CHECK_MENU_ITEM (widget)) != 0);
gsg_set_tooltips (preferences.tooltips_enabled);
pref_xcam_save ();
*/
}
static void
pref_toggle_twocolumn (GtkWidget * widget, gpointer data)
{
/*
preferences.twocolumn_enabled = (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget)) != 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: */
// advanced user option:
item = gtk_check_menu_item_new_with_label ("Show advanced options");
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
preferences.advanced);
@ -873,7 +855,7 @@ build_preferences_menu (GSGDialog * dialog)
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_advanced), 0);
/* tooltips submenu: */
// tooltips submenu:
item = gtk_check_menu_item_new_with_label ("Show tooltips");
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
@ -883,7 +865,7 @@ build_preferences_menu (GSGDialog * dialog)
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_tooltips), 0);
/* twocolumn submenu: */
// twocolumn submenu:
item = gtk_check_menu_item_new_with_label ("Show two column display");
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
@ -926,15 +908,19 @@ build_preferences_menu (GSGDialog * dialog)
gtk_widget_show (item);
return menu;
*/
return NULL;
}
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) \
@ -1069,6 +1055,27 @@ rescan_devices (GtkWidget * widget, gpointer client_data, gpointer call_data)
} \
}
static void
_gdk_visual_get_pixel_details (gulong pixel_mask,
gint *shift)
{
gulong m = 0;
gint s = 0;
if (pixel_mask != 0)
{
m = pixel_mask;
while (!(m & 0x1))
{
s++;
m >>= 1;
}
}
if (shift)
*shift = s;
}
static gboolean
input_available (gpointer data, gint source, GIOCondition cond)
{
@ -1086,7 +1093,6 @@ input_available (gpointer data, gint source, GIOCondition cond)
double max_value = 60; /* min. 1 frame per min. */
double frame_time = 50; /* dummy value */
GdkVisual *visual = NULL;
DBG (DBG_debug, "xcam: input available: enter\n");
@ -1094,7 +1100,6 @@ input_available (gpointer data, gint source, GIOCondition cond)
/* looks like we got cancelled */
goto stop_and_exit;
visual = gdk_window_get_visual (gtk_widget_get_window (win.canvas.preview));
buf_size = win.buf_backend_size;
format = win.params.format;
src_depth = win.params.depth;
@ -1109,9 +1114,9 @@ input_available (gpointer data, gint source, GIOCondition cond)
src_mask = 0x80; /* SANE has left most bit is most significant bit */
dst_mask = 0x01;
gdk_visual_get_red_pixel_details (visual, NULL, &r_shift, NULL);
gdk_visual_get_green_pixel_details (visual, NULL, &g_shift, NULL);
gdk_visual_get_blue_pixel_details (visual, NULL, &b_shift, NULL);
_gdk_visual_get_pixel_details (0xFF0000, &r_shift);
_gdk_visual_get_pixel_details (0x00FF00, &g_shift);
_gdk_visual_get_pixel_details (0x0000FF, &b_shift);
while (1)
{
@ -1545,8 +1550,8 @@ save_frame (void)
}
else
{
while (gtk_events_pending ())
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
input_available (0, -1, G_IO_IN);
}
@ -1566,7 +1571,8 @@ xcam_exit (void)
pref_xcam_save ();
sane_exit ();
/* this has the habit of calling exit itself: */
gtk_main_quit ();
while (g_list_model_get_n_items (gtk_window_get_toplevels ()) > 0)
g_main_context_iteration (NULL, TRUE);
DBG (DBG_debug, "xcam: xcam_exit: exit\n");
}
@ -1592,8 +1598,8 @@ browse_filename_callback (GtkWidget * widget, gpointer data)
}
else
strcpy (filename, OUTFILENAME);
gsg_get_filename ("Output Filename", filename, sizeof (filename), filename);
gtk_entry_set_text (GTK_ENTRY (win.filename_entry), filename);
gsg_get_filename ("Output Filename", filename, win.filename_entry);
// gtk_entry_set_text (GTK_ENTRY (win.filename_entry), filename);
if (preferences.filename)
free ((void *) preferences.filename);
@ -1607,11 +1613,51 @@ 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)));
preferences.filename = strdup(gtk_editable_get_text (GTK_EDITABLE (widget)));
pref_xcam_save ();
DBG (DBG_debug, "xcam: filename_changed_callbackcallback: exit\n");
}
static void create_item ( GMenu *menu,
const gchar *const label,
const gchar *const action,
const gchar *const icon,
const gchar *const target,
const gchar *const accel )
{
g_return_if_fail ( G_IS_MENU ( menu ) );
GMenuItem *item = g_menu_item_new ( NULL, NULL );
g_menu_item_set_attribute ( item, G_MENU_ATTRIBUTE_LABEL, "s", label, NULL );
g_menu_item_set_attribute ( item, G_MENU_ATTRIBUTE_ACTION, "s", action, NULL );
g_menu_item_set_attribute ( item, G_MENU_ATTRIBUTE_ICON, "s", icon, NULL );
if ( target )
{
g_menu_item_set_attribute ( item, "target", "s", target, NULL );
}
g_menu_item_set_attribute ( item, "accel", "s", accel, NULL );
g_menu_append_item ( menu, item );
g_object_unref ( item );
}
static void create_submenu_item ( GMenu *menu,
GMenu *submenu,
const gchar *const label )
{
g_return_if_fail ( G_IS_MENU ( menu ) );
GMenuItem *item = g_menu_item_new ( NULL, NULL );
g_menu_item_set_attribute ( item, G_MENU_ATTRIBUTE_LABEL, "s", label, NULL );
g_menu_item_set_submenu ( item, G_MENU_MODEL ( submenu ) );
g_menu_append_item ( menu, item );
g_object_unref ( item );
}
static void
usage (void)
{
@ -1625,13 +1671,12 @@ Easy) devices.\n\
-V, --version print version information\n", prog_name);
}
int
main (int argc, char **argv)
{
GtkWidget *menu, *menu_bar, *menu_bar_item, *preview_vbox;
static void
activate(GApplication *app, gpointer *data) {
GMenu *menu_bar;
GtkWidget *preview_vbox;
GtkWidget *hbox, *vbox, *button, *frame, *label, *text,
*scrolled_window;
int ch;
SANE_Status status;
DBG_INIT ();
@ -1640,16 +1685,11 @@ main (int argc, char **argv)
DBG (DBG_error, "xcam (version: %s, package: %s) starting\n", VERSION,
PACKAGE);
win.buf_backend_size = (32 * 1024);
if (win.buf_backend_size == 0)
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;
@ -1660,70 +1700,39 @@ main (int argc, char **argv)
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);
win.shell = gtk_application_window_new(GTK_APPLICATION(app));
gtk_window_set_title (GTK_WINDOW (win.shell), (char *) prog_name);
g_signal_connect (G_OBJECT (win.shell), "delete_event",
G_CALLBACK (xcam_win_delete), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_container_add (GTK_CONTAINER (win.shell), vbox);
// gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
// gtk_container_add (GTK_CONTAINER (win.shell), vbox);
gtk_window_set_child(GTK_WINDOW(win.shell), GTK_WIDGET(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: */
menu_bar = build_files_menu ();
/*
// "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: */
// "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),
@ -1732,21 +1741,22 @@ main (int argc, char **argv)
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_set_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_container_set_border_width (GTK_CONTAINER (frame), 8);
// gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_append(GTK_BOX (vbox), frame);
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);
gtk_frame_set_child(GTK_FRAME (frame), win.device_info_label);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_add (GTK_CONTAINER (vbox), hbox);
gtk_box_append (GTK_BOX (vbox), hbox);
gtk_widget_show (hbox);
/* create the device dialog box: */
@ -1758,19 +1768,18 @@ main (int argc, char **argv)
/* the preview vbox on the left hand side: */
preview_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (preview_vbox), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), preview_vbox, TRUE, TRUE, 0);
gtk_box_append (GTK_BOX (hbox), preview_vbox);
frame = gtk_frame_new ("Image view");
gtk_container_set_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);
// gtk_container_set_border_width (GTK_CONTAINER (frame), 8);
// gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_append (GTK_BOX (preview_vbox), frame);
win.canvas.preview = gtk_drawing_area_new ();
gtk_widget_set_size_request (GTK_WIDGET (win.canvas.preview), 320, 200);
gtk_widget_set_events (win.canvas.preview, CANVAS_EVENT_MASK);
g_signal_connect (G_OBJECT (win.canvas.preview), "event",
G_CALLBACK (canvas_events), 0);
gtk_container_add (GTK_CONTAINER (frame), win.canvas.preview);
gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (win.canvas.preview), 320);
gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (win.canvas.preview), 200);
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (win.canvas.preview), canvas_events, &(win.canvas), NULL);
gtk_frame_set_child (GTK_FRAME (frame), win.canvas.preview);
gtk_widget_show (win.canvas.preview);
gtk_widget_show (frame);
@ -1779,13 +1788,13 @@ main (int argc, char **argv)
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);
scrolled_window = gtk_scrolled_window_new ();
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_container_add (GTK_CONTAINER (scrolled_window), win.dialog_box);
gtk_container_add (GTK_CONTAINER (hbox), scrolled_window);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), win.dialog_box);
gtk_box_append (GTK_BOX (hbox), scrolled_window);
gtk_widget_show (GTK_WIDGET (scrolled_window));
@ -1820,24 +1829,24 @@ main (int argc, char **argv)
/* The info row */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
// gtk_container_set_border_width (GTK_CONTAINER (hbox), 3);
gtk_box_append (GTK_BOX (vbox), hbox);
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_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_append (GTK_BOX (hbox), frame);
gtk_widget_show (frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox);
// gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_frame_set_child (GTK_FRAME (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_box_append (GTK_BOX (hbox), win.info_label);
gtk_widget_show (win.info_label);
win.f_count = 0;
@ -1851,67 +1860,84 @@ main (int argc, char **argv)
/* The TXT button */
button = gtk_button_new_with_label (" TXT ");
win.txt_label = gtk_bin_get_child (GTK_BIN (button));
GtkWidget *child = gtk_widget_get_first_child(GTK_WIDGET(button));
if (child) {
if (GTK_IS_LABEL(child)) {
win.txt_label = child;
}
}
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (txt_button), dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_box_append (GTK_BOX (hbox), button);
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_get_child (GTK_BIN (button));
child = gtk_widget_get_first_child(GTK_WIDGET(button));
if (child) {
if (GTK_IS_LABEL(child)) {
win.rgb_bgr_label = child;
}
}
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (rgb_bgr_button), dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_box_append (GTK_BOX (hbox), button);
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_get_child (GTK_BIN (button));
child = gtk_widget_get_first_child(GTK_WIDGET(button));
if (child) {
if (GTK_IS_LABEL(child)) {
win.play_stop_label = child;
}
}
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (play_stop_button), dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_box_append (GTK_BOX (hbox), button);
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_get_child (GTK_BIN (button));
child = gtk_widget_get_first_child(GTK_WIDGET(button));
if (child) {
if (GTK_IS_LABEL(child)) {
win.save_frame_label = child;
}
}
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (save_frame_button), dialog);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_box_append (GTK_BOX (hbox), button);
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_set_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);
gtk_box_append (GTK_BOX (hbox), frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_frame_set_child (GTK_FRAME (frame), hbox);
label = gtk_label_new ("Filename");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_box_append (GTK_BOX (hbox), label);
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_editable_set_text (GTK_EDITABLE (text), (char *) preferences.filename);
gtk_box_append (GTK_BOX (hbox), text);
g_signal_connect (G_OBJECT (text), "changed",
G_CALLBACK (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_box_append (GTK_BOX (hbox), button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (browse_filename_callback), 0);
@ -1921,11 +1947,56 @@ main (int argc, char **argv)
gtk_widget_show (hbox);
gtk_widget_show (frame);
gtk_widget_show (win.shell);
gtk_main ();
gtk_application_set_menubar (GTK_APPLICATION (app), G_MENU_MODEL (menu_bar));
gtk_application_window_set_show_menubar(GTK_APPLICATION_WINDOW(win.shell), TRUE);
gtk_window_present (GTK_WINDOW(win.shell));
while (g_list_model_get_n_items (gtk_window_get_toplevels ()) > 0)
g_main_context_iteration (NULL, TRUE);
pref_xcam_save ();
DBG (DBG_debug, "xcam main exit\n");
return 0;
}
int main(int argc, char **argv) {
GApplication *app;
int stat = 0;
int ch;
win.buf_backend_size = 0;
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);
}
}
}
prog_name = strrchr (argv[0], '/');
if (prog_name)
++prog_name;
else
prog_name = argv[0];
app = gtk_application_new("com.scan2vcard", G_APPLICATION_FLAGS_NONE);
g_signal_connect(app, "activate", G_CALLBACK(activate), NULL);
stat = g_application_run(G_APPLICATION(app), argc, argv);
g_object_unref(app);
return stat;
}

195
src/xscanimage.c
Wyświetl plik

@ -602,16 +602,15 @@ quit_xscanimage (void)
}
while (gsg_message_dialog_active)
{
if (!gtk_events_pending ())
usleep (100000);
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
}
pref_xscanimage_save ();
if (dialog && gsg_dialog_get_device (dialog))
sane_close (gsg_dialog_get_device (dialog));
sane_exit ();
if (gtk_quit_flag == 1)
gtk_main_quit ();
g_main_context_wakeup (NULL);
#ifdef HAVE_LIBGIMP_GIMP_H
if (scan_win.mode == SANE_GIMP_EXTENSION)
gimp_quit ();
@ -801,8 +800,8 @@ input_available (gpointer data, gint source, GIOCondition cond)
{
if (scan_win.input_tag < 0)
{
while (gtk_events_pending ())
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
}
else
{
@ -826,8 +825,8 @@ input_available (gpointer data, gint source, GIOCondition cond)
{
if (scan_win.input_tag < 0)
{
while (gtk_events_pending ())
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
continue;
}
else
@ -838,8 +837,8 @@ input_available (gpointer data, gint source, GIOCondition cond)
progress_update (scan_win.progress,
scan_win.bytes_read / (gfloat) scan_win.num_bytes);
if (scan_win.input_tag < 0)
while (gtk_events_pending ())
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
switch (scan_win.param.format)
{
@ -1153,8 +1152,8 @@ scan_start (void)
scan_win.x = scan_win.y = 0;
while (gtk_events_pending ())
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
status = sane_start (dev);
#ifdef SANE_STATUS_WARMING_UP
@ -1176,8 +1175,8 @@ scan_start (void)
/* we assume that warming up won't exceed 60 seconds */
progress_update (scan_win.progress, (gfloat)(current.tv_sec - start.tv_sec) / (gfloat) 60);
#endif
while (gtk_events_pending ())
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
status = sane_start (dev);
}
progress_free (scan_win.progress);
@ -1366,8 +1365,8 @@ scan_start (void)
}
else
{
while (gtk_events_pending ())
gtk_main_iteration ();
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL, FALSE);
input_available (0, -1, G_IO_IN);
}
DBG (DBG_debug, "scan_start: finished\n");
@ -1454,9 +1453,9 @@ files_exit_callback (GtkWidget * widget, gpointer data)
static GtkWidget *
files_build_menu (void)
{
GtkWidget *menu, *item;
GtkWidget *menu; //, *item;
DBG (DBG_debug, "files_build_menu\n");
/*
menu = gtk_menu_new ();
item = gtk_menu_item_new ();
@ -1468,7 +1467,7 @@ files_build_menu (void)
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");
return menu;
}
@ -1512,7 +1511,7 @@ update_double_callback (GtkWidget * widget, gpointer data)
char *end;
double v;
start = gtk_entry_get_text (GTK_ENTRY (widget));
start = gtk_editable_get_text (GTK_EDITABLE (widget));
if (!start)
return;
@ -1540,7 +1539,7 @@ preview_options_ok_callback (GtkWidget * widget, gpointer data)
}
gtk_widget_destroy (dialog);
gtk_window_destroy (GTK_WINDOW(dialog));
pref_xscanimage_save ();
@ -1556,7 +1555,7 @@ preview_options_cancel_callback (GtkWidget * widget, gpointer data)
{
GtkWidget *dialog = data;
gtk_widget_destroy (dialog);
gtk_window_destroy (GTK_WINDOW(dialog));
}
static void
@ -1576,14 +1575,14 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_check_button_new_with_label ("Preserve preview image");
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (update_int_callback),
&preferences.preserve_preview);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
preferences.preserve_preview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
gtk_box_append (GTK_BOX (hbox), button);
gtk_widget_show (button);
gtk_widget_show (hbox);
@ -1592,14 +1591,14 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
gtk_box_append (GTK_BOX (vbox), hbox);
button = gtk_check_button_new_with_label ("Use private colormap");
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (update_int_callback),
&preferences.preview_own_cmap);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
preferences.preview_own_cmap);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
gtk_box_append (GTK_BOX (hbox), button);
gtk_widget_show (button);
gtk_widget_show (hbox);
@ -1608,17 +1607,18 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
gtk_box_append (GTK_BOX (vbox), hbox);
gtk_widget_show (hbox);
label = gtk_label_new ("Gamma correction value");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_box_append (GTK_BOX (hbox), label);
gtk_widget_show (label);
sprintf (buf, "%g", preferences.preview_gamma);
text = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (text), buf);
gtk_box_pack_start (GTK_BOX (hbox), text, TRUE, TRUE, 2);
gtk_editable_set_text (GTK_EDITABLE (text), buf);
gtk_box_append (GTK_BOX (hbox), text);
g_signal_connect (G_OBJECT (text), "changed",
G_CALLBACK (update_double_callback),
&preferences.preview_gamma);
@ -1626,11 +1626,10 @@ preview_options_dialog (GtkWidget * widget, gpointer data)
/* fill in action area: */
button = gtk_dialog_add_button (GTK_DIALOG (dialog), "OK", GTK_RESPONSE_OK);
gtk_widget_set_can_default (button, TRUE);
gtk_window_set_default_widget (GTK_WINDOW (dialog), button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (preview_options_ok_callback), dialog);
gtk_widget_grab_default (button);
gtk_widget_show (button);
button = gtk_dialog_add_button (GTK_DIALOG (dialog), "Cancel", GTK_RESPONSE_CANCEL);
@ -1690,31 +1689,38 @@ pref_device_restore (void)
static void
pref_toggle_advanced (GtkWidget * widget, gpointer data)
{
/*
preferences.advanced = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (widget));
gsg_set_advanced (dialog, preferences.advanced);
pref_xscanimage_save ();
*/
}
static void
pref_toggle_tooltips (GtkWidget * widget, gpointer data)
{
/*
preferences.tooltips_enabled = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (widget));
gsg_set_tooltips (preferences.tooltips_enabled);
pref_xscanimage_save ();
*/
}
static void
pref_toggle_twocolumn (GtkWidget * widget, gpointer data)
{
/*
preferences.twocolumn_enabled = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM (widget));
gsg_set_twocolumn (dialog, preferences.twocolumn_enabled);
pref_xscanimage_save ();
*/
}
static GtkWidget *
pref_build_menu (void)
{
GtkWidget *menu, *item, *submenu;
GtkWidget *menu; // , *item, *submenu;
/*
GtkWidget *unit_mm, *unit_cm, *unit_in;
GSList *units_group = NULL;
double unit;
@ -1722,7 +1728,7 @@ pref_build_menu (void)
DBG (DBG_debug, "pref_build_menu\n");
menu = gtk_menu_new ();
/* advanced user option: */
// advanced user option:
item = gtk_check_menu_item_new_with_label ("Show advanced options");
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
preferences.advanced);
@ -1731,7 +1737,7 @@ pref_build_menu (void)
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_advanced), 0);
/* tooltips submenu: */
// tooltips submenu:
item = gtk_check_menu_item_new_with_label ("Show tooltips");
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
@ -1741,7 +1747,7 @@ pref_build_menu (void)
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_tooltips), 0);
/* two column submenu: */
// two column submenu:
item = gtk_check_menu_item_new_with_label ("Show two column display");
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
@ -1751,7 +1757,7 @@ pref_build_menu (void)
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (pref_toggle_twocolumn), 0);
/* length unit submenu: */
// length unit submenu:
item = gtk_menu_item_new_with_label ("Length unit");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
@ -1792,7 +1798,7 @@ pref_build_menu (void)
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
/* preview options: */
// preview options:
item = gtk_menu_item_new_with_label ("Preview options...");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
@ -1800,7 +1806,7 @@ pref_build_menu (void)
G_CALLBACK (preview_options_dialog), 0);
gtk_widget_show (item);
/* insert separator: */
// insert separator:
item = gtk_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
@ -1816,7 +1822,7 @@ pref_build_menu (void)
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");
return menu;
}
@ -1834,13 +1840,7 @@ browse_filename_callback (GtkWidget * widget, gpointer data)
}
else
strcpy (filename, OUTFILENAME);
gsg_get_filename ("Output Filename", filename, sizeof (filename), filename);
gtk_entry_set_text (GTK_ENTRY (scan_win.filename_entry), filename);
if (preferences.filename)
free ((void *) preferences.filename);
preferences.filename = strdup (filename);
DBG (DBG_debug, "browse_filename_callback: finished\n");
gsg_get_filename ("Output Filename", filename, scan_win.filename_entry);
}
static void
@ -1848,7 +1848,7 @@ filename_changed_callback (GtkWidget * widget, gpointer data)
{
if (preferences.filename)
free ((void *) preferences.filename);
preferences.filename = strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
preferences.filename = strdup (gtk_editable_get_text (GTK_EDITABLE (widget)));
}
/* Create the main dialog box. */
@ -1857,7 +1857,7 @@ device_dialog (void)
{
GtkWidget *vbox, *hbox, *button, *frame, *scrolled_window, *dialog_window,
*label, *text;
GtkWidget *menubar_item;
// GtkWidget *menubar_item;
const gchar *devname;
DBG (DBG_debug, "device_dialog\n");
@ -1879,51 +1879,54 @@ device_dialog (void)
/* create the menubar */
scan_win.menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox), scan_win.menubar, FALSE, FALSE, 0);
// scan_win.menubar = gtk_menu_bar_new ();
gtk_box_append (GTK_BOX (vbox), scan_win.menubar);
/* "Files" submenu: */
/*
menubar_item = gtk_menu_item_new_with_label ("File");
gtk_container_add (GTK_CONTAINER (scan_win.menubar), menubar_item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menubar_item),
files_build_menu ());
gtk_widget_show (menubar_item);
*/
/* "Preferences" submenu: */
/*
menubar_item = gtk_menu_item_new_with_label ("Preferences");
gtk_container_add (GTK_CONTAINER (scan_win.menubar), menubar_item);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menubar_item),
pref_build_menu ());
gtk_widget_show (menubar_item);
*/
gtk_widget_show (scan_win.menubar);
// gtk_widget_show (scan_win.menubar);
/* if we're running in standalone mode, provide a output filename box: */
if (scan_win.mode == STANDALONE)
{
frame = gtk_frame_new ("Output");
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
// gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_box_append (GTK_BOX (vbox), frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox);
// gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_frame_set_child (GTK_FRAME (frame), hbox);
label = gtk_label_new ("Filename");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
gtk_box_append (GTK_BOX (hbox), label);
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_editable_set_text (GTK_EDITABLE (text), (char *) preferences.filename);
gtk_box_append (GTK_BOX (hbox), text);
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_box_append (GTK_BOX (hbox), button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (browse_filename_callback), 0);
@ -1935,17 +1938,16 @@ device_dialog (void)
}
/* create a subwindow so the dialog keeps its position on rebuilds: */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
scrolled_window = gtk_scrolled_window_new ();
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);
dialog_window = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (dialog_window), FALSE);
gtk_container_add (GTK_CONTAINER
(scrolled_window), dialog_window);
gtk_window_set_child(GTK_WINDOW (scrolled_window), dialog_window);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
gtk_box_append (GTK_BOX (vbox), scrolled_window);
gtk_widget_show (scrolled_window);
gtk_widget_show (dialog_window);
@ -1957,23 +1959,22 @@ device_dialog (void)
/* The info row */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 3);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
// gtk_container_set_border_width (GTK_CONTAINER (hbox), 3);
gtk_box_append (GTK_BOX (vbox), hbox);
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_box_append (GTK_BOX (hbox), frame);
gtk_widget_show (frame);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_container_add (GTK_CONTAINER (frame), hbox);
// gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);
gtk_frame_set_child(GTK_FRAME (frame), hbox);
gtk_widget_show (hbox);
scan_win.info_label = gtk_label_new ("0x0: 0KB");
gtk_box_pack_start (GTK_BOX (hbox), scan_win.info_label, FALSE, FALSE, 0);
gtk_box_append (GTK_BOX (hbox), scan_win.info_label);
gtk_widget_show (scan_win.info_label);
update_param (dialog, 0);
@ -2013,22 +2014,18 @@ device_dialog (void)
static void
ok_choose_dialog_callback (void)
{
gtk_widget_destroy (choose_device_dialog);
gtk_window_destroy (GTK_WINDOW(choose_device_dialog));
device_dialog ();
}
static int
select_device_callback (GtkWidget * widget, GdkEventButton * event,
gpointer data)
static void
select_device_callback (GtkWidget * widget, gpointer data)
{
if (event->type == GDK_2BUTTON_PRESS && event->button == 1)
ok_choose_dialog_callback ();
return 0;
ok_choose_dialog_callback ();
}
static void
group_change_callback (GtkToggleButton* button,
gpointer data)
group_change_callback (GtkToggleButton* button, gpointer data)
{
if (gtk_toggle_button_get_active(button))
{
@ -2039,7 +2036,7 @@ group_change_callback (GtkToggleButton* button,
static gint32
choose_device (void)
{
GtkWidget *main_vbox, *vbox, *button;
GtkWidget *main_vbox, *vbox, *button, *group = NULL;
const SANE_Device *adev;
gint i;
@ -2054,8 +2051,8 @@ choose_device (void)
/* The list of drivers */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, TRUE, TRUE, 0);
// gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
gtk_box_append (GTK_BOX (main_vbox), vbox);
gtk_widget_show (vbox);
/* The radio buttons */
@ -2066,29 +2063,36 @@ choose_device (void)
if (button == NULL)
{
button = gtk_radio_button_new_with_label (NULL, (char *) adev->name);
button = gtk_check_button_new_with_label ((char *) adev->name);
group = button;
}
/*
else
button = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(button), adev->name );
g_signal_connect (G_OBJECT (button), "button_press_event",
{
gtk_check_button_set_label( GTK_CHECK_BUTTON(button), adev->name );
group = button;
}*/
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (select_device_callback),
(void *) (long) i);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (group_change_callback),
(void *) (long) i);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_box_append (GTK_BOX (vbox), button);
gtk_widget_show (button);
if (i == defdev)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
if (i == defdev) {
gtk_check_button_set_group (GTK_CHECK_BUTTON (button), GTK_CHECK_BUTTON (group));
gtk_check_button_set_active (GTK_CHECK_BUTTON (group), TRUE);
}
}
/* The OK button */
button = gtk_dialog_add_button (GTK_DIALOG (choose_device_dialog), "OK", GTK_RESPONSE_OK);
gtk_widget_set_can_default (button, TRUE);
gtk_window_set_default_widget (GTK_WINDOW (choose_device_dialog), button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (ok_choose_dialog_callback), NULL);
gtk_widget_grab_default (button);
gtk_widget_show (button);
/* The Cancel button */
@ -2124,7 +2128,7 @@ init (int argc, char **argv)
DBG_INIT ();
DBG (DBG_debug, "init\n");
gtk_init (&argc, &argv);
gtk_init ();
/*
#ifdef HAVE_LIBGIMP_GIMP_H
gtk_rc_parse (gimp_gtkrc ());
@ -2271,8 +2275,9 @@ interface (int argc, char **argv)
}
}
gtk_quit_flag = 1;
DBG (DBG_debug, "interface: now running gtk_main ()\n");
gtk_main ();
DBG (DBG_debug, "interface: now running g_main_context_iteration ()\n");
while (g_list_model_get_n_items (gtk_window_get_toplevels ()) > 0)
g_main_context_iteration (NULL, TRUE);
sane_exit ();
DBG (DBG_debug, "interface: finished\n");
}