delete drawings made with GC created on a SWT display

I create a GC on the display, and then I do some drawing. My question is how do I un-draw?

The code looks like this:

final GC gc = new GC(display);
gc.setForeground(display.getSystemColor(SWT.COLOR_RED));
gc.setLineWidth(5);
gc.drawRectangle(rectangle);
gc.dispose();

Context: I need to let users select a window from other applications. The behavior I expect can be seen here: http://tools.tortoisesvn.net/SendMessage.html Instead, All my screen is filled with red rectangles.

It is OK for me even if it is a Windows-only solution.

EDIT: sorry, red garbage remains even after I close my application.

EDIT2: The working example:

public static void main(String[] args) {
        final Display display = new Display();
        final Shell shell = new Shell(display);

        shell.addListener(SWT.MouseMove, new Listener() {
            @Override
            public void handleEvent(Event event) {
                final Point displayPoint = display.map(shell, null, event.x, event.y);
                final POINT point = new POINT();
                point.x = displayPoint.x;
                point.y = displayPoint.y;
                final int windowHandle = OS.WindowFromPoint(point);
                if (windowHandle != 0 && windowHandle != shell.handle) {
                    RECT rect = new RECT();
                    if (OS.GetWindowRect(windowHandle, rect)) {
                        Rectangle rectangle = new Rectangle(rect.left, rect.top, rect.right - rect.left,
                                rect.bottom - rect.top);
                        final GC gc = new GC(display);
                        gc.setForeground(display.getSystemColor(SWT.COLOR_RED));
                        gc.setLineWidth(5);
                        gc.drawRectangle(rectangle);
                        gc.dispose();
                    }
                }
            }
        });

        shell.pack();
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();
    }

To use it, start a mouse drag from the shell (not the title bar) and hover it over an application that uses real windows controls (not swing, QT, XUL). A good example of target application is Total Commander. You will see that the screen becomes full of red rectangles. Ideally I would like to have only one red rectangle visible.

I know I could make a new shell with regions that will simulate the red rectangle, but if 开发者_运维问答the mouse jumps over that, I'm stuck.

I make some code. It's not perfect solution, cause after many tries I'm not able to make transparency everything except the "window" border, so I'm just making the whole shell (which covers the "window" area) partially transparent (and it makes nice effect though).

Here's the code

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.internal.win32.OS;
import org.eclipse.swt.internal.win32.POINT;
import org.eclipse.swt.internal.win32.RECT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;

public class ShellBorder {

    private Display display = new Display();
    private Shell shell = new Shell(display);
    private RECT currRect = null;
    private Shell paintShell = null;

    public ShellBorder() {

        shell.addListener(SWT.MouseUp, new Listener() {

            @Override
            public void handleEvent(Event event) {
                paintShell.dispose();

                // do whatever you need
                // ...

                currRect = null;
            }
        });

        shell.addListener(SWT.MouseMove, new Listener() {
            @Override
            public void handleEvent(Event event) {
                final Point displayPoint = display.map(shell, null, event.x, event.y);
                final POINT point = new POINT();
                point.x = displayPoint.x;
                point.y = displayPoint.y;
                if(currRect == null) {
                    getWindowAndDrawBorder(point);
                } else {
                    // cursor is outside the current rectangle
                    if (point.x < currRect.left || point.x > currRect.right || point.y < currRect.top || point.y > currRect.bottom) {
                        currRect = null;
                        paintShell.dispose();
                        getWindowAndDrawBorder(point);
                    }
                }
            }

            private void getWindowAndDrawBorder(POINT point) {
                long windowHandle = OS.WindowFromPoint(point);
                if (windowHandle != 0 && windowHandle != shell.handle) {
                    RECT rect = new RECT();
                    if (OS.GetWindowRect(windowHandle, rect)) {
                        currRect = rect;

                        paintShell = new Shell(display, SWT.NO_TRIM | SWT.ON_TOP);
                        paintShell.setLocation(currRect.left, currRect.top);
                        paintShell.setSize(currRect.right - currRect.left, currRect.bottom - currRect.top);
                        paintShell.setLayout(new FillLayout());
                        paintShell.setAlpha(50);

                        Canvas canvas = new Canvas(paintShell, SWT.NO_BACKGROUND);
                        canvas.addPaintListener(new PaintListener() {
                            public void paintControl(PaintEvent e) {
                                GC gc = e.gc;
                                gc.setForeground(display.getSystemColor(SWT.COLOR_RED));
                                gc.setLineWidth(5);
                                gc.drawRectangle(new Rectangle(0, 0, paintShell.getSize().x, paintShell.getSize().y));
                            }
                        });
                        paintShell.open();
                    }
                }
            }
        });

        shell.pack();
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch()) {
                display.sleep();
            }
        }
        display.dispose();

    }

    public static void main(String[] args) {
        new ShellBorder();
    }
}

To do this, you must draw on a Shell that covers the complete display. When the Shell is disposed, the drawn rectangles are removed.

I don't know how to find the window under the cursor though...

In my first answer I assumed that you wanted to test for a window of other applications on the Desktop. As that is not the case, you should have a look at my answer to How to draw over child elements of a Composite in SWT? which automatically handles redraw of the relevant parts when a rectangle should be removed again...