Animation - Need way to avoid UI wipe off

[parind poi]

I need to implement a network simulation animation with messages (icons) flowing back and forth between nodes (filloval). Each node is a thread behind the scenes and determines which message to send based on its state transition model.

Now everytime the window is minimized or some other window comes over my swing window, the part of the window overlapped becomes blank. The books say that I have to put in all the drawing code in paint() so that it will update itself whenever invoked automatically.

How can i do this - the state transition is per thread. Any ideas as to how I can avoid the system from wiping my UI when minimized or overlapped?

[Craig Wood]

This is set up to compile and run in j2se 1.5
If using j2se 1.4 or earlier comment out the j2se 1.5 lines and uncomment the j2se 1.4 lines in the three areas of NetworkPanel, eg,

class NetworkPanel extends JPanel
{
    ...
//    List<Message> messages;                                 // j2se 1.5
    List messages;                                        // j2se 1.4

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.Point2D;
import java.util.*;
import java.util.List;
import javax.swing.*;
 
public class Network
{
    Messenger messenger;
    Node[] nodes;
    NetworkPanel networkPanel;
 
    public Network()
    {
        messenger = new Messenger(this);
        nodes = createNodes(messenger);
        messenger.setNodes(nodes);
        networkPanel = new NetworkPanel(nodes);
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(getUIPanel(), "North");
        f.getContentPane().add(networkPanel);
        f.setSize(500,500);
        f.setLocation(100,100);
        f.setVisible(true);
    }
 
    private Node[] createNodes(Messenger messenger)
    {
        Node[] n = new Node[3];
        n[0] = new Node(245, 20,  20, Color.red,            messenger);
        n[1] = new Node(75,  350, 25, Color.blue,           messenger);
        n[2] = new Node(375, 175, 35, Color.green.darker(), messenger);
        return n;
    }
 
    public NetworkPanel getPanel()
    {
        return networkPanel;
    }
 
    private JPanel getUIPanel()
    {
        JButton start = new JButton("start");
        start.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                messenger.resetNodes();
                messenger.send(nodes[0], Color.cyan, Messenger.RANDOM);
            }
        });
        JPanel panel = new JPanel();
        panel.add(start);
        return panel;
    }
 
    public static void main(String[] args)
    {
        new Network();
    }
}
 
class NetworkPanel extends JPanel
{
    Node[] nodes;
    List<Message> messages;                                 // j2se 1.5
//    List messages;                                        // j2se 1.4
 
    public NetworkPanel(Node[] nodes)
    {
        this.nodes = nodes;
        messages = new ArrayList<Message>();                // j2se 1.5
//        messages = new ArrayList();                       // j2se 1.4
    }
 
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D)g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                            RenderingHints.VALUE_ANTIALIAS_ON);
        for(int j = 0; j < messages.size(); j++)
        {
            Message message = messages.get(j);              // j2se 1.5
//            Message message = (Message)messages.get(j);   // j2se 1.4
            if(message.advance())
                messages.remove(message);
            message.draw(g2);
        }
        for(int j = 0; j < nodes.length; j++)
            nodes[j].draw(g2);
    }
 
    public void addMessage(Message message)
    {
        messages.add(message);
    }
}
 
class Node
{
    int x, y, dia;
    Color color;
    int totalCyan, totalMagenta;
    boolean haveReceivedYellow;
    Messenger messenger;
 
    public Node(int x, int y, int dia, Color color, Messenger m)
    {
        this.x = x;
        this.y = y;
        this.dia = dia;
        this.color = color;
        haveReceivedYellow = false;
        messenger = m;
    }
 
    public void draw(Graphics2D g2)
    {
        g2.setPaint(color);
        g2.fillOval(x - dia/2, y - dia/2, dia, dia);
    }
 
    public synchronized void receiveMessage(Color color)
    {
        if(color == Color.cyan)
        {
            totalCyan++;
            respondToCyan();
        }
        else if(color == Color.magenta)
        {
            totalMagenta++;
            respondToMagenta();
        }
        else if(color == Color.yellow)
            haveReceivedYellow = true;
    }
 
    private void respondToCyan()
    {
        if(totalCyan < 8)
            respond(Color.cyan, Messenger.ALL);        // send cyan to all nodes
        else if(totalCyan == 8)
            respond(Color.magenta, Messenger.ALL);     // send magenta to all nodes
        else
            respond(Color.magenta, Messenger.RANDOM);  // send magenta to a random node
    }
 
    private void respondToMagenta()
    {
        if(totalMagenta > 2 && !haveReceivedYellow)
            respond(Color.yellow, Messenger.RANDOM);   // send yellow to a random node
    }
 
    private synchronized void respond(Color color, int target)
    {
        messenger.send(this, color, target);
    }
}
 
class Messenger
{
    Network network;
    Random seed;
    Node[] nodes;
    Thread animator;
    final static int STEP = 2;
    final static int
        ALL    = 0,
        RANDOM = 1;
 
    public Messenger(Network network)
    {
        this.network = network;
        seed = new Random();
    }
 
    public synchronized void send(Node node, Color color, int range)
    {
        switch(range)
        {
            case ALL:
                for(int j = 0; j < nodes.length; j++)
                    if(nodes[j] != node)
                        sendMessage(node, nodes[j], color);
                break;
            case RANDOM:
                Node target;
                do
                    target = nodes[seed.nextInt(nodes.length)];
                while(target == node);
                sendMessage(node, target, color);
        }
    }
 
    private void sendMessage(Node source, Node target, Color color)
    {
        double d = Point2D.distance(source.x, source.y, target.x, target.y);
        int steps = (int)(d / STEP);
        double theta = Math.atan2(target.y - source.y, target.x - source.x);
        network.getPanel().addMessage(new Message(target, source.x, source.y,
                                                  steps, theta, color));
        if(animator == null)
        {
            animator = new Thread(runner);
            animator.start();
        }
    }
 
    private Runnable runner = new Runnable()
    {
        public void run()
        {
            while(network.getPanel().messages.size() > 0)
            {
                try
                {
                    Thread.sleep(75);
                }
                catch(InterruptedException ie)
                {
                    System.err.println("interrupt: " + ie.getMessage());
                }
                network.getPanel().repaint();
            }
            animator = null;
        }
    };
 
    public void setNodes(Node[] n)
    {
        nodes = n;
    }
 
    public void resetNodes()
    {
        for(int j = 0; j < nodes.length; j++)
        {
            nodes[j].totalCyan = 0;
            nodes[j].totalMagenta = 0;
            nodes[j].haveReceivedYellow = false;
        }
    }
}
 
class Message
{
    Node target;
    int cx, cy, steps, currentStep, dia, x, y;
    double theta;
    Color color;
 
    public Message(Node n, int cx, int cy, int steps, double theta, Color color)
    {
        target = n;
        this.cx = cx;
        this.cy = cy;
        this.steps = steps;
        this.theta = theta;
        this.color = color;
        currentStep = 0;
        dia = 15;
    }
 
    public boolean advance()
    {
        x = cx + (int)(currentStep * Messenger.STEP * Math.cos(theta));
        y = cy + (int)(currentStep * Messenger.STEP * Math.sin(theta));
        boolean haveFinished = false;
        if(currentStep++ >= steps)
        {
            haveFinished = true;
            target.receiveMessage(color);
        }
        return haveFinished;
    }
 
    public void draw(Graphics2D g2)
    {
        g2.setPaint(color);
        g2.fillOval(x - dia/2, y - dia/2, dia, dia);
    }
}