testpixbuf.c

Linux下gtk图形界面开发的各种gtk控件调用方法示例

	if (gdk_pixbuf_get_has_alpha (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,
				    event->area.x, event->area.y, 
				    event->area.width, 
				    event->area.height,
				    GDK_RGB_DITHER_NORMAL,
				    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));
	}
}

static void
config_func (GtkWidget *drawing_area, GdkEventConfigure *event, gpointer data)
{
#if 0
	GdkPixbuf *pixbuf;
    
	pixbuf = (GdkPixbuf *)g_object_get_data (G_OBJECT (drawing_area), "pixbuf");

	if (((event->width) != gdk_pixbuf_get_width (pixbuf)) ||
	    ((event->height) != gdk_pixbuf_get_height (pixbuf)))
		gdk_pixbuf_scale (pixbuf, event->width, event->height);
#endif
}

static GtkWidget*
new_testrgb_window (GdkPixbuf *pixbuf, gchar *title)
{
	GtkWidget *window;
	GtkWidget *vbox;
	GtkWidget *temp_box;
	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);

	window = gtk_widget_new (gtk_window_get_type (),
				 "GtkObject::user_data", NULL,
				 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
				 "GtkWindow::title", title ? title : "testrgb",
				 "GtkWindow::allow_shrink", TRUE,
				 NULL);
	g_signal_connect (window, "destroy",
			  G_CALLBACK (quit_func), NULL);

	vbox = gtk_vbox_new (FALSE, 0);

	if (title)
		gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (title),
				    TRUE, TRUE, 0);

	drawing_area = gtk_drawing_area_new ();

	temp_box = gtk_hbox_new (FALSE, 0);
	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);
	

	g_signal_connect (drawing_area, "expose_event",
			  G_CALLBACK (expose_func), NULL);
	g_signal_connect (drawing_area, "configure_event",
			  G_CALLBACK (config_func), NULL);

	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);
	g_signal_connect_swapped (button, "clicked",
				  G_CALLBACK (gtk_widget_destroy), window);

	gtk_widget_show (button);

	gtk_container_add (GTK_CONTAINER (window), vbox);
	gtk_widget_show_all (vbox);

	gtk_widget_show (window);

        return drawing_area;
}


static gint
update_timeout (gpointer data)
{
        ProgressFileStatus *status = data;
	gboolean done;
        GError *error;
        
	done = FALSE;
        error = NULL;

	if (!feof (status->imagefile)) {
		gint nbytes;
                
		nbytes = fread (status->buf, 1, status->readlen, 
			       status->imagefile);


                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) {
                /* 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);
	}

	return !done;
}


static void
progressive_prepared_callback (GdkPixbufLoader* loader, gpointer data)
{
        GtkWidget** retloc = data;
        GdkPixbuf* pixbuf;

        pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);

        g_assert (pixbuf != NULL);

        g_object_ref (pixbuf); /* for the RGB window */

        *retloc = new_testrgb_window (pixbuf, "Progressive");

        return;
}


static void
progressive_updated_callback (GdkPixbufLoader* loader, guint x, guint y, guint width, guint height, gpointer data)
{
        GtkWidget** window_loc = data;

        if (*window_loc != NULL)
                gtk_widget_queue_draw_area (*window_loc,
					   x, y, width, height);
        return;
}

static int readlen = 4096;

extern void pixbuf_init (void);

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)
{
	int i;
	int found_valid = FALSE;

	GdkPixbuf *pixbuf;
	GdkPixbufLoader *pixbuf_loader;

	pixbuf_init ();

	gtk_init (&argc, &argv);

	/*	gdk_rgb_set_verbose (TRUE);*/

	gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());

	{
		char *tbf_readlen = getenv ("TBF_READLEN");
		if (tbf_readlen) readlen = atoi (tbf_readlen);
	}

	{
		char *tbf_bps = getenv ("TBF_KBPS");
		guint bps;

		if (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);
		new_testrgb_window (pixbuf, NULL);

                xpmp = xpms;
                while (*xpmp) {
                        pixbuf = gdk_pixbuf_new_from_xpm_data (*xpmp);
                        new_testrgb_window (pixbuf, NULL);
                        ++xpmp;
                }

                /* Test loading 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);

                        if (pixbuf == NULL) {
                                g_warning ("Error loading image: %s",
                                           error->message);
                                g_error_free (error);
                        }
                        
#if 0
			pixbuf = gdk_pixbuf_rotate (pixbuf, 10.0);
#endif

			if (pixbuf) {
				new_testrgb_window (pixbuf, "File");
				found_valid = TRUE;
			}
		}
#if 1	
                {
                        GtkWidget* rgb_window = NULL;
			ProgressFileStatus   status;

                        pixbuf_loader = gdk_pixbuf_loader_new ();
			status.loader = pixbuf_loader;

			status.rgbwin = &rgb_window;

			status.buf = g_malloc (readlen);

#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 = gdk_threads_add_timeout (100, update_timeout, &status);
                }
#endif
	}

	if (found_valid)
		gtk_main ();

	return 0;
}