First and foremost: remember that a pixmap is a
server-side resource, i.e. possibly across a network
and definitely across some kind
of socket. Therefore, you do not want to request its
pixels one by one. Iterating over a pixmap that way
could easily take many seconds.
GDK wraps an Xlib object called XImage. The wrapper is called GdkImage. A GdkImage is essentially a local
copy of the data in a pixmap. You can copy a region of
a pixmap or window into a
GdkImage with the
gdk_image_get() routine, then get and set pixels
with gdk_image_get_pixel()
and gdk_image_put_pixel().
You can also access the image's data structures
directly, but this is quite complicated (due to
visuals, depths, differences between host and network
byte order, and so on). If you modify the image, you
use gdk_draw_image() to copy
it back to a server-side drawable.
Copying a pixmap to a
GdkImage, or copying a
GdkImage to a pixmap, still involves moving
quite a bit of data over the network; however, since
it's all in one burst the speed can be tolerable in
many cases. Also, if the client and the server are on
the same machine, and the X shared memory extension is
available, GDK will automatikcally set up a shared
memory segment to copy the data.
Most of the time, if you plan to do a lot of image
manipulation, you are better off using RGB buffers as
your primary data structure (see the section called RGB
Buffers in the chapter called GDK
Basics). The functions in
gdk/gdkrgb.h allow you to copy an RGB buffer to a
drawable. These functions use
GdkImage internally, but they are tuned to be
very fast and handle all the complexities for you.
