No Business Naming Things

Hopefully this will be the last post with the words “startup changes” in its title for a very long time to come.

As mentioned previously, in 3.3 we prevent unknown Runnables from executing during the startup procedure via

and

. I last mentioned a strategy for avoiding use of such runnables during the initialization of editors. I believe that advice is still valid. However, there are scenarios where you may legitimately need access to these methods. Without them, for instance, Splash Screen implementors are forced to spin the event loop themselves if they want to do any clever UI work while the workbench is coming up. In an answer to this problem, we’ve added the new

class as API to the 3.4 stream. This class has one static method,

. Calling this method on any thread not created by the UI (ie: any user Thread) will allow that thread to access the Display.async() and Display.sync() methods as if they were one of our privileged startup threads.

For example:

package mail.example;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.application.DisplayAccess;
import org.eclipse.ui.splash.AbstractSplashHandler;

public class SplashHandlerWIthDisplayAccess extends AbstractSplashHandler {
        public void init(Shell splash) {
                super.init(splash);

                final Color[] color = new Color[] { splash.getDisplay().getSystemColor(
                                SWT.COLOR_YELLOW) };
                final Canvas canvas = new Canvas(splash, SWT.NONE);
                canvas.setBounds(0, 0, splash.getSize().x, splash.getSize().y);
                canvas.addPaintListener(new PaintListener() {

                        public void paintControl(PaintEvent e) {
                                e.gc.setForeground(e.display.getSystemColor(SWT.COLOR_BLACK));
                                e.gc.setBackground(color[0]);
                                e.gc.fillOval(0, 0, canvas.getSize().x, canvas.getSize().y);
                        }
                });

                Thread worker = new Thread() {
                        public void run() {
                                DisplayAccess.accessDisplayDuringStartup();
                                try {
                                        Thread.sleep(500); // sleep a little so we can see the
                                                                                // color change
                                } catch (InterruptedException e) {
                                }
                                canvas.getDisplay().syncExec(new Runnable() {

                                        public void run() {
                                                color[0] = canvas.getDisplay().getSystemColor(
                                                                SWT.COLOR_GREEN);
                                                if (!canvas.isDisposed())
                                                        canvas.redraw();
                                        }
                                });
                        }
                };
                worker.start();
        }
}

This simple splash handler creates a canvas on the splash shell that will initially have a yellow oval taking up the entirety of the drawing area. We then create a thread which declares that it will be used to access the display during startup. After a short nap this thread will set the color of the oval to green and cause a repaint. You can verify that without the call to

the oval will remain yellow until the splash comes down.