The following applet creates an image producer that puts up blocks of random color, sleeping 0.1 seconds in between. When run under a 1.2 appletviewer (therefore using 1.2 AWT classes) it displays nothing until the entire image is complete. When run under a 1.1 appletviewer (using 1.1 AWT classes) each block is updated on the screen when produced (although it dies with a stack trace at the end for reasons I haven't yet groked, but are irreleveant -- it's the behavior *before* the end that is correct in 1.1 and not correct in 1.2).

This is a small test case for a raytracing applet. Under 1.1 the user will see the image as it is rendered. In 1.2, they will see nothing until the image is complete. This is not acceptable for such a long-running computation.

package com.sun.jini.examples.raytrace;

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.util.*;

public class Scribble extends java.applet.Applet {
    private TextField xText, yText; // chunk dimension typing fields
    private int xChunk, yChunk; // image chunk sizes
    private Label msg; // message display
    private Component display; // where the image is shown
    private int numChunks; // number of chunks in this job
    private long resultCnt; // the number of results returned
    private Random rand = new Random();
    private TakeThread takeThread = null;

    private ImgPainter painter; // this is the creator of the image
    private Image picture; // this is what we are creating

    private final static int MAX_X = 640;
    private final static int MAX_Y = 480;

    public void init() {
super.init();

GridBagConstraints left = new GridBagConstraints();
GridBagConstraints right = new GridBagConstraints();

right.anchor = GridBagConstraints.WEST;
right.fill = GridBagConstraints.HORIZONTAL;
right.gridwidth = GridBagConstraints.REMAINDER;
right.weightx = 1.0;
right.weighty = 0.0;

        add(new Label("Chunk:", Label.RIGHT), left);
add(xText = new TextField(4), left);
add(new Label("x"), left);
add(yText = new TextField(4), left);
xText.setText("80");
yText.setText("80");

add(new StartButton(), left);
add(new StopButton(), left);
add(msg = new Label(), right);

display = new Component() {
public void paint(Graphics g) {
System.out.println("paint()");
if (painter == null) {
painter = new ImgPainter(MAX_X, MAX_Y);
picture = createImage(painter);
}
g.drawImage(picture, 0, 0, this); // observer
}
public Dimension getMinimumSize() { return getPreferredSize(); }
public Dimension getPreferredSize() {
return new Dimension(MAX_X, MAX_Y);
}
};
add(display, right);
display.setSize(MAX_X, MAX_Y);
    }

    public abstract class ActionButton extends Button implements ActionListener
    {
/**
* Create a button with <code>name</code> that works on the
* given <code>actor</code>.
*/
public ActionButton(String name) {
super(name);
addActionListener(this);
}
    }

    /** Start writing requests. */
    private class StartButton extends ActionButton {
StartButton() { super("Start"); }
public void actionPerformed(ActionEvent e) { startTrace(); }
    }

    /** Stop writing requests and clear out the queue -- cancel */
    private class StopButton extends ActionButton {
StopButton() { super("Stop"); }
public void actionPerformed(ActionEvent e) { stopTrace(); }
    }

    public void msg(String str) {
msg.setText(str);
    }

    private void startTrace() {
stopTrace(); // stop the current one

try {
xChunk = Integer.parseInt(xText.getText());
yChunk = Integer.parseInt(yText.getText());
} catch (NumberFormatException e) {
msg("Bad chunk size");
return;
}

takeThread = new TakeThread();
takeThread.start(); // start taking results
    }

    private synchronized void stopTrace() {
if (takeThread != null)
takeThread.interrupt(); // stop taking results
takeThread = null;
    }

    /**
     * A thread that keeps looking for results.
     */
    private class TakeThread extends Thread {
private boolean shuttingDown = false; // currently shutting down?

public void run() {
long waitTime = Long.MAX_VALUE; // see shutting down code below
resultCnt = 0;
int[] pixels = new int[xChunk * yChunk];
Random values = new Random();

int x = 0;
int y = 0;
while (x < MAX_X && y < MAX_Y) {
int v = values.nextInt();
for (int p = 0; p < pixels.length; p++)
pixels[p] = v;
System.out.println(x + ", " + y);
painter.doBlock(x, y, xChunk, yChunk, pixels);
display.repaint();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
x += xChunk;
if (x >= MAX_X) {
x = 0;
y += yChunk;
}
resultCnt++;
}
msg("done");
painter.complete();
}
    }

    /** Show an exception. */
    private void show(Throwable t) {
t.printStackTrace(System.out);
msg(t.toString());
    }

    //
    // The painter object asynchronously creates the ray-traced picture
    // line-by-line
    //
    private static class ImgPainter implements ImageProducer {
Vector consumers;
int width, height;
int[] imagePixels;
int linesConsumed;
int linesProduced;

public ImgPainter(int width, int height) {
// initialize the scene
this.width = width;
this.height = height;
linesProduced = 0;
linesConsumed = 0;
imagePixels = new int[width * height];
consumers = new Vector();
}

public synchronized void
doBlock(int x, int y, int width, int height, int[] imagePixels)
{
for (int i = consumers.size() - 1; i >= 0; i--) {
ImageConsumer ic = (ImageConsumer) consumers.elementAt(i);
// give pixels to the consumer
ic.setPixels(
x, y, width, height, // range
ColorModel.getRGBdefault(), // color model
imagePixels, // array of imagePixels
0, // offset into array
width); // line width
}
}

public synchronized void complete() {
for (int i = consumers.size() - 1; i >= 0; i--) {
ImageConsumer ic = (ImageConsumer) consumers.elementAt(i);
ic.imageComplete(ImageConsumer.STATICIMAGEDONE);
}
}

//
// ImageProducer implementation
//
public synchronized void addConsumer(ImageConsumer ic) {
consumers.addElement(ic);
ic.setColorModel(ColorModel.getRGBdefault());
ic.setDimensions(width, height);
}

public synchronized boolean isConsumer(ImageConsumer ic) {
return consumers.contains(ic);
}

public synchronized void removeConsumer(ImageConsumer ic) {
consumers.remove(ic);
}

public synchronized void requestTopDownLeftRightResend(ImageConsumer ic)
{
ic.setPixels(0, 0, width, linesProduced,
ColorModel.getRGBdefault(), imagePixels, 0, width);

//!! This is the wrong test -- blocks don't come in single lines
//!! so having reached the bottom line doesn't mean "done".
linesConsumed = linesProduced;
if (linesProduced == height)
ic.imageComplete(ImageConsumer.STATICIMAGEDONE);
}

public synchronized void startProduction(ImageConsumer ic) {
addConsumer(ic); // harmless if redundant
if (linesProduced == height)
requestTopDownLeftRightResend(ic);
}
    }
}