Correct clipping when calling "paint()" from thread

Question

How do I achieve correct clipping around JMenus or JTooltips when calling paint() for a Component from a background thread?
The whole story:
Trying to implement some blinking GUI symbols (visualizing alerts), I implemented a subclass of JPanel which is linked to a Swing timer and thus receives periodic calls to its "actionPerformed()" methods.
In the "actionPerformed()" method, the symbol's state is toggled and and repainting the object should be triggered.
Unfortunately, "repaint()" has huge overhead (part of the background would need to be repainted, too) and I decided to call "paint( getGraphics() )" instead of it.
This works fine as long as there is nothing (like a JMenu, a JComboBox or a JTooltip) hiding the symbol (partially or completely). In such case the call to paint() simply "overpaints" the object.
I suppose setting a clipping region would help, but where from can I get it?
Any help welcome! (I alread spent hours in search of a solution, but I still have no idea...)

Answer 1

For all those interested in the topic:
It seems as if there is no reliable way to do proper clipping when calling
"paint()".
The problem was that when my sub-component called "repaint()" for itself, the underlying component's "paintComponent()" method was called as well. Painting of that component was complex and avoiding complexity by restricting
on the clipping region is not easily possible.
I have several sub-components to be repainted regularly, resulting in lots of calls to my parent component's "paintComponent()" method. This makes the
repainting of the sub-components awfully slow; the user can see each one begin painted!
Finally I decided I had to speed up the update of the parent component. I found two possible solutions:
a) Store the background of each of the sub-components in a BufferedImage:
When "paintComponent()" is called: test, if the clipping rectangle solely
contains the region of a sub-component. If this is true check if there
is a "cached" BufferedImage for this region. If not, create one, filling
it with the "real" "paintComponent()" method using the Graphic object of
the BufferedImage. Once we have such a cached image, simply copy it the
the screen (i.e. the Graphics object passed as method parameter).
b) To avoid the handling of several of such "cached" image tiles, simply
store the whole parent component's visible part ("computeVisibleRect()")
in a BufferedImage. Take care to re-allocate/re-paint this image each
time the visible part changes. (I need to restrict the image buffer to
the visible part since I use a zooming feature: Storing the whole image
would easily eat up all RAM!) In the "paintComponent()", simple check
if the currently buffered image is still valid - repaint if not -
and copy the requested part of it (clip rect) to the screen. That's it!
The whole procedure works fine.
Best regards,
Armin