Delayed Signal Delivery?

[riboaz xs4all nl]

Hello,

i am seeing some behaviour in my app that i don't understand:

i have an application with several tabs in a notebook, each containing an
individual drawing area (one tab contains two and three panes of drawing
areas).  there are several different possible drawing combinations per
drawing area, so to avoid having to redraw only when a combination is
chosen, i am maintaining as many pixmap backing stores necessary to avoid
redrawina a pixmap when it's already been previously drawn. and this all
works nifty, no problems.

my problem can be described by the following sequence:

-) in the normal course of using the app, i generate, say, 10-15 drawing
events;
-) at some point, when switching between two pixmaps that have previously
been drawn (thus, my pixmap expose event must simply draw the current
pixmap to the screen), there is a rather visible delay (~1 second) between
old and new pixmap, event though no drawing occurs (except in the expose
event drawing the entire new pixmap to the screen).

observations:

-) i have noticed that this only happens when some particular pixmap is
being displayed.
-) e.g.: switching between the same two pixmaps, one is drawn delayed, the
other is drawn instantaneously.
-) and, the same behaviour occurs when i partially obscure the drawing
with another window: one pixmap is redrawn delayed, while the other is
redrawn instantaneously (thus, demonstrating that it solely related to
expose event delivery).  (btw, using the same two pixmaps from previous
example.)
-) i have used the ubiquitous printf() inside the expose event to also
demonstrate that the delay occurs before the expose event is drawn.  once
the expose event is called, the drawing of the pixmap to the screen is
instantaneous.

and i've just realized something i think that's important.  this behaviour
is seen only after i have generated a pixmap containing more than the two
colors i have setup for fg and bg.  (in fact, if i reset all my pixmap
backing stores to nothing and start drawing from the beginning, the delay
goes away.)

is there something important (requiring a lot of time) in the background
when dealing with multiple pixmaps having been generated with different
colour maps?  (i'm guessing here, don't shoot me...)  or is there
something else going on that i don't understand?  is there something
relevant to know about how colourmaps are managed in the background, and
then be able to program in consideration of in the foreground (my
program)?

any thoughts/ideas would be greatly appreciated.  i'm striving to write an
efficient program by never redrawing pixmaps that have already been drawn,
and ironically enough, a configure event (drawing from scratch) is quicker
than the expose event (with delay).

or is this all related to my Xserver or machine (linux)?

thanks in advance,

richard boaz