#include <unistd.h>
#include <string.h>
#include <gtk/gtk.h>
-#include <gtk/gdk-pixbuf-loader.h>
+#include <gdk-pixbuf/gdk-pixbuf-loader.h>
#include "test-inline-pixbufs.h"
{
GdkPixbuf *pixbuf;
- pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
+ pixbuf = (GdkPixbuf *)g_object_get_data (G_OBJECT (drawing_area), "pixbuf");
if (gdk_pixbuf_get_has_alpha (pixbuf)) {
- gdk_draw_rgb_32_image (drawing_area->window,
- drawing_area->style->black_gc,
- event->area.x, event->area.y,
- event->area.width,
- event->area.height,
- GDK_RGB_DITHER_MAX,
- gdk_pixbuf_get_pixels (pixbuf)
- + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf))
- + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
- gdk_pixbuf_get_rowstride (pixbuf));
+ GdkPixbuf *dest;
+
+ gdk_window_set_back_pixmap (drawing_area->window, NULL, FALSE);
+
+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, event->area.width, event->area.height);
+
+ gdk_pixbuf_composite_color (pixbuf, dest,
+ 0, 0, event->area.width, event->area.height,
+ -event->area.x, -event->area.y,
+ (double) drawing_area->allocation.width / gdk_pixbuf_get_width (pixbuf),
+ (double) drawing_area->allocation.height / gdk_pixbuf_get_height (pixbuf),
+ GDK_INTERP_BILINEAR, 255,
+ event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
+
+ gdk_draw_pixbuf (drawing_area->window, drawing_area->style->fg_gc[GTK_STATE_NORMAL], dest,
+ 0, 0, event->area.x, event->area.y,
+ event->area.width, event->area.height,
+ GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
+
+ g_object_unref (dest);
} else {
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
{
GdkPixbuf *pixbuf;
- pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
-
- g_print("X:%d Y:%d\n", event->width, event->height);
+ pixbuf = (GdkPixbuf *)g_object_get_data (G_OBJECT (drawing_area), "pixbuf");
#if 0
if (((event->width) != gdk_pixbuf_get_width (pixbuf)) ||
((event->height) != gdk_pixbuf_get_height (pixbuf)))
- gdk_pixbuf_scale(pixbuf, event->width, event->height);
+ gdk_pixbuf_scale (pixbuf, event->width, event->height);
#endif
}
GtkWidget *button;
GtkWidget *drawing_area;
gint w, h;
-
+
+ g_return_val_if_fail (pixbuf != NULL, NULL);
w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);
"GtkWindow::title", title ? title : "testrgb",
"GtkWindow::allow_shrink", TRUE,
NULL);
- gtk_signal_connect (GTK_OBJECT (window), "destroy",
- (GtkSignalFunc) quit_func, NULL);
+ g_signal_connect (window, "destroy",
+ G_CALLBACK (quit_func), NULL);
vbox = gtk_vbox_new (FALSE, 0);
drawing_area = gtk_drawing_area_new ();
temp_box = gtk_hbox_new (FALSE, 0);
- gtk_drawing_area_size (GTK_DRAWING_AREA(drawing_area), w, h);
+ gtk_widget_set_size_request (GTK_WIDGET (drawing_area), w, h);
gtk_box_pack_start (GTK_BOX (temp_box), drawing_area, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), temp_box, FALSE, FALSE, 0);
- gtk_signal_connect (GTK_OBJECT(drawing_area), "expose_event",
- GTK_SIGNAL_FUNC(expose_func), NULL);
- gtk_signal_connect (GTK_OBJECT(drawing_area), "configure_event",
- GTK_SIGNAL_FUNC (config_func), NULL);
+ g_signal_connect (drawing_area, "expose_event",
+ G_CALLBACK (expose_func), NULL);
+ g_signal_connect (drawing_area, "configure_event",
+ G_CALLBACK (config_func), NULL);
- gtk_object_set_data (GTK_OBJECT(drawing_area), "pixbuf", pixbuf);
+ g_object_set_data (G_OBJECT (drawing_area), "pixbuf", pixbuf);
gtk_widget_show (drawing_area);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
- gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
- (GtkSignalFunc) gtk_widget_destroy,
- GTK_OBJECT (window));
+ g_signal_connect_swapped (button, "clicked",
+ G_CALLBACK (gtk_widget_destroy), window);
gtk_widget_show (button);
gtk_widget_show (window);
- return window;
+ return drawing_area;
}
static gint
-update_timeout(gpointer data)
+update_timeout (gpointer data)
{
ProgressFileStatus *status = data;
gboolean done;
+ GError *error;
+
+ done = FALSE;
+ error = NULL;
- done = TRUE;
- if (!feof(status->imagefile)) {
+ if (!feof (status->imagefile)) {
gint nbytes;
-
- nbytes = fread(status->buf, 1, status->readlen,
+
+ nbytes = fread (status->buf, 1, status->readlen,
status->imagefile);
- done = !gdk_pixbuf_loader_write (GDK_PIXBUF_LOADER (status->loader), status->buf, nbytes);
-
- }
+ if (!gdk_pixbuf_loader_write (GDK_PIXBUF_LOADER (status->loader), status->buf, nbytes, &error)) {
+ g_warning ("Error writing to loader: %s",
+ error->message);
+ g_error_free (error);
+ done = TRUE;
+ }
+
+
+ }
+ else
+ done = TRUE;
+
if (done) {
- gtk_widget_queue_draw(*status->rgbwin);
- gdk_pixbuf_loader_close (GDK_PIXBUF_LOADER (status->loader));
- gtk_object_destroy (GTK_OBJECT(status->loader));
+ /* ignoring errors, we should not do that. */
+ gdk_pixbuf_loader_close (GDK_PIXBUF_LOADER (status->loader), NULL);
+ gtk_widget_queue_draw (*status->rgbwin);
+ g_object_unref (status->loader);
fclose (status->imagefile);
g_free (status->buf);
}
static void
-progressive_prepared_callback(GdkPixbufLoader* loader, gpointer data)
+progressive_prepared_callback (GdkPixbufLoader* loader, gpointer data)
{
GtkWidget** retloc = data;
GdkPixbuf* pixbuf;
- pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
- g_assert(pixbuf != NULL);
+ pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
+
+ g_assert (pixbuf != NULL);
- gdk_pixbuf_ref(pixbuf); /* for the RGB window */
+ g_object_ref (pixbuf); /* for the RGB window */
- *retloc = new_testrgb_window(pixbuf, "Progressive");
+ *retloc = new_testrgb_window (pixbuf, "Progressive");
return;
}
static void
-progressive_updated_callback(GdkPixbufLoader* loader, guint x, guint y, guint width, guint height, gpointer data)
+progressive_updated_callback (GdkPixbufLoader* loader, guint x, guint y, guint width, guint height, gpointer data)
{
GtkWidget** window_loc = data;
-/* g_print ("progressive_updated_callback:\n\t%d\t%d\t%d\t%d\n", x, y, width, height); */
-
if (*window_loc != NULL)
- gtk_widget_queue_draw_area(*window_loc,
+ gtk_widget_queue_draw_area (*window_loc,
x, y, width, height);
-
return;
}
static int readlen = 4096;
-extern void pixbuf_init();
+extern void pixbuf_init ();
+
+void size_func (GdkPixbufLoader *loader, gint width, gint height, gpointer data)
+{
+ gdk_pixbuf_loader_set_size (loader, width*2, height*2);
+}
+
int
main (int argc, char **argv)
gtk_init (&argc, &argv);
- gdk_rgb_set_verbose (TRUE);
-
- gdk_rgb_init ();
+ /* gdk_rgb_set_verbose (TRUE);*/
- gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
+ gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());
{
- char *tbf_readlen = getenv("TBF_READLEN");
- if(tbf_readlen) readlen = atoi(tbf_readlen);
+ char *tbf_readlen = getenv ("TBF_READLEN");
+ if (tbf_readlen) readlen = atoi (tbf_readlen);
}
{
- char *tbf_bps = getenv("TBF_KBPS");
+ char *tbf_bps = getenv ("TBF_KBPS");
guint bps;
if (tbf_bps) {
- bps = atoi(tbf_bps);
+ bps = atoi (tbf_bps);
g_print ("Simulating %d kBytes/sec\n", bps);
readlen = (bps*1024)/10;
}
i = 1;
if (argc == 1) {
const gchar*** xpmp;
-
+ GError *error = NULL;
+
pixbuf = gdk_pixbuf_new_from_data (default_image, GDK_COLORSPACE_RGB, FALSE, 8,
DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_WIDTH * 3,
NULL, NULL);
}
/* Test loading from inline data. */
- pixbuf = gdk_pixbuf_new_from_inline (apple_red, FALSE, -1);
- new_testrgb_window (pixbuf, "Red apple from inline data");
-
- pixbuf = gdk_pixbuf_new_from_inline (gnome_foot, TRUE, sizeof (gnome_foot));
- new_testrgb_window (pixbuf, "Foot from inline data");
+ pixbuf = gdk_pixbuf_new_from_inline (-1, apple_red, FALSE, &error);
+ if (!pixbuf)
+ {
+ fprintf (stderr, "failed to construct \"red apple\" pixbuf: %s\n",
+ error->message);
+ g_error_free (error);
+ }
+ else
+ new_testrgb_window (pixbuf, "Red apple from inlined RLE data");
+
+ pixbuf = gdk_pixbuf_new_from_inline (sizeof (gnome_foot), gnome_foot, TRUE, NULL);
+ new_testrgb_window (pixbuf, "GNOME Foot from inlined RLE data");
found_valid = TRUE;
} else {
for (i = 1; i < argc; i++) {
+ GError *error;
+
+ error = NULL;
+ pixbuf = gdk_pixbuf_new_from_file (argv[i], &error);
- pixbuf = gdk_pixbuf_new_from_file (argv[i]);
+ if (pixbuf == NULL) {
+ g_warning ("Error loading image: %s",
+ error->message);
+ g_error_free (error);
+ }
+
#if 0
- pixbuf = gdk_pixbuf_rotate(pixbuf, 10.0);
+ pixbuf = gdk_pixbuf_rotate (pixbuf, 10.0);
#endif
if (pixbuf) {
found_valid = TRUE;
}
}
-#if 1
+#if 1
{
GtkWidget* rgb_window = NULL;
ProgressFileStatus status;
status.rgbwin = &rgb_window;
status.buf = g_malloc (readlen);
- gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
- "area_prepared",
- GTK_SIGNAL_FUNC(progressive_prepared_callback),
- &rgb_window);
- gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
- "area_updated",
- GTK_SIGNAL_FUNC(progressive_updated_callback),
- &rgb_window);
+#if 0
+ g_signal_connect (pixbuf_loader, "size_prepared",
+ G_CALLBACK (size_func), NULL);
+#endif
+ g_signal_connect (pixbuf_loader, "area_prepared",
+ G_CALLBACK (progressive_prepared_callback),
+ &rgb_window);
+ g_signal_connect (pixbuf_loader, "area_updated",
+ G_CALLBACK (progressive_updated_callback),
+ &rgb_window);
status.imagefile = fopen (argv[1], "r");
g_assert (status.imagefile != NULL);
status.readlen = readlen;
- status.timeout = gtk_timeout_add(100, update_timeout, &status);
+ status.timeout = g_timeout_add (100, update_timeout, &status);
}
#endif
}
projects / ~andy / gtk / blobdiff