If you have a large number of objects, RGB mode can be
faster than GDK mode. Drawing to an RGB buffer is a
simple matter of assigning to an array, which is much,
much faster than making a GDK call (since GDK has to
contact the X server and ask it to do the actual
drawing). The expensive part is copying the RGB buffer
to the X server when you're done. However, the copy
takes the same amount of time no matter how many canvas
items you have, since it is done only once, when all
the items have been rendered.
This is a big win in an application called "Guppi" I'm
in the process of writing. Guppi is a plot program. One
of the things it has to do is render a scatter plot
with tens of thousands of points. Each point is a small
colored shape; if I called GDK to render each, there
would be tens of thousands of trips to the X server,
possibly across a network. Instead, I use the canvas in
RGB mode, with a custom canvas item representing the
scatter plot. This allows me to do all the rendering on
the client side, and then the canvas copies the RGB
buffer to the server in a single burst. It's quite fast
and responsive. For less speed-intensive elements of
the plot, such as the legend, I can save time and use
the built-in canvas items.
The one difficulty with direct-to-RGB rendering is that
you need a rasterization library comparable to the GDK
drawing primitives if you want to draw anything
interesting. libart_lgpl
is a very high-quality antialiased rasterization
library, used by the default canvas items. You can use
it in your custom items as well, and it is the best
choice if you will only be drawing hundreds of shapes.
If you're drawing thousands of shapes, however, you'll
quickly see the need for something faster. Fortunately,
this is available; the maintainers of a package called
GNU Plotutils extracted the rasterization library from
the X distribution, and during the development of Guppi
I extracted it from Plotutils and hacked it to work
with the canvas's RGB buffers. I also added alpha
transparency support. The resulting library allows you
to draw on an RGB buffer much as you would draw using
GDK. The library is distributed under the same license
as the X Window System, and is free for anyone to
include with their application.
Raph Levien, author of
libart_lgpl and the GdkRGB module, tells me that
still faster routines could be written; if you need
more speed, consider this a challenge.
