Although the ClockView
shows a single animated clock, creating an independent widget will allow the clock to be reused in other places.
com.packtpub.e4.clock.ui
package, called ClockWidget
, that extends Canvas
.Composite
parent and an int style
bits parameter, and pass them to the superclass:public ClockWidget(Composite parent, int style) { super(parent, style); }
drawClock
method from the ClockView
to the ClockWidget
. Remove the PaintListener
references from the ClockView
class.ClockWidget
constructor, register a PaintListener
that delegates the call to the drawClock
method:addPaintListener(this::drawClock);
TickTock
thread from the ClockView
to the ClockWidget
constructor; this will allow the ClockWidget
to operate independently. Change any references for clock
to this:Runnable redraw = () -> { while (!this.isDisposed()) { this.getDisplay().asyncExec(() -> this.redraw()); try { Thread.sleep(1000); } catch (InterruptedException e) { return; } } } new Thread(redraw, "TickTock").start();
computeSize
method to allow the clock to have a square appearance that is the minimum of the width and height. Note that SWT.DEFAULT
may be passed in, which has the value -1
, so this needs to be handled explicitly:public Point computeSize(int w, int h, boolean changed) { int size; if (w == SWT.DEFAULT) { size = h; } else if (h == SWT.DEFAULT) { size = w; } else { size = Math.min(w, h); } if (size == SWT.DEFAULT) { size = 50; } return new Point(size, size); }
ClockView
to instantiate the ClockWidget
instead of the Canvas
in the createPartControl
method:new ClockWidget(parent, SWT.NONE);
The drawing logic was moved into its own widget, and registered a PaintListener
to a method in the ClockWidget
to render itself. This allows the Clock
to be used as a standalone in any Eclipse or SWT application.
In a real application, the clocks would not have their own thread; it would either be the case that a single Thread
would control updates to all Clock
instances, or they would be set up with repeating Job
instances using the Eclipse jobs framework, which will be covered in Chapter 4, Interacting with the User.
The technique of using a method reference (or anonymous class) to bind a specific listener type to the instance of the class is a common pattern in SWT. When using inner classes, the convention is to use the same method name in the enclosing class; this helps to disambiguate the use.
It's also possible for the ClockWidget
to implement PaintListener
directly; in this case, addPaintListener(this)
would be called in the constructor. Modern JITs will optimize the calls to equivalent code paths in any case; it comes down to a style decision as to whether the ClockWidget
class should implement the PaintListener
interface or not.
Finally, the size can be computed based on the hints. This is called by the layout manager to determine what size the widget should be. For widgets with a fixed size (say, a text string or an image), the size can vary depending on the layout. In this case, it returns a square, based on the minimum size of the supplied width and height hints, or 50, whichever is bigger. The SWT.DEFAULT
value is -1
, which has to be dealt with specifically.
18.227.114.125