如何在Java中的for循环中的每个update（）之后强制重绘（）？

Question

I have written a small, basic, kaleidoscope type program that should gradually draw the same pattern (over time) at six different points and at different orientations.

To do this I have created an array to store each pixel's colour (it's initial colour being black and represented by number 0) and then 6 starting points in the array have their colour changed to green (represented by number 1). These points should appear on the screen and then, based on the previous 6 points' positions a further 6 points are created. The updated screen should then be displayed. Repeat, repeat, repeat...

My problem is that all of the updates, for new pixels, are being carried out before painting the screen. I have checked some other posts and web tutorials etc, and gather that AWT is kind enough to avoid wasting time repainting minor changes. There seems also to be something called paintManager involved in this. I believe the problem is that I am repainting within a for loop. I am finding this really frustrating as, in my view, it should be a simple thing to do. Is there, indeed, a simple way to persuade java to plot these minor changes in the way I desire?

I have included the code in its entirety below:

package paranoid;

import javax.swing.JFrame;

public class MasterFrame {

    public static void main(String[] args) {
            // TODO Auto-generated method stub
    new MasterFrame();
    }


    public MasterFrame(){
        JFrame f = new JFrame();
        f.setTitle("Kaleidoscope");
        f.add(new Trip2());
        f.setSize(500,300);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
        f.setResizable(false);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }

}

and...

package paranoid;

import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JPanel;


public class Trip2 extends JPanel {

    private static final long serialVersionUID = 1L;

    private int xmin = 0,
                xmax = 499,
                ymin = 0,
                ymax = 279;
    private int x = 120;
    private int y = 80;
    private int dx = 1;
    private int dy = 1;
    private int temp = 0;
    private int update_counter = 0;
    private int repaint_counter = 0;
    private int x_pos[] = new int[6];
    private int y_pos[] = new int[6];
    private int screen[][] = new int[500][280];


    public Trip2() {

        initialisation();
        for(int i = 0; i < 5000; i++)
        {
            update();
            System.out.println("Just returned from update()");

            repaint();                                          //This repaint is not being activated until all updates 
            System.out.println("Just returned from paint()");   //have been completed, but I want a repaint after EVERY update.
        }
    }

    public void initialisation(){
        System.out.println("initialising...");
        x_pos[0] = x;
        y_pos[0] = y;

        x_pos[1] = xmax - x;
        y_pos[1] = y;

        x_pos[2] = x;
        y_pos[2] = ymax - y;

        x_pos[3] = xmax - x;
        y_pos[3] = ymax - y;

        x_pos[4] = (int)(xmax/2)-50;
        y_pos[4] = (int)(ymax/2);

        x_pos[5] = (int)(xmax/2)+50;
        y_pos[5] = (int)(ymax/2);

        for(int j = 0; j<280; j++){
            for(int i = 0; i<500; i++){
                screen[i][j] = 0;
            }
        }
    } //end of initialisation()

    public void update(){
        System.out.println("updating... for the "+update_counter+"th time");

        temp = (int)Math.floor(Math.random()*100);
        if(temp < 40){ // 40% chance that the direction is changed
            dx = (int)Math.floor(Math.random()*3);
            dy = (int)Math.floor(Math.random()*3);
            dx = dx - 1;
            dy = dy - 1;
        }


        x_pos[0] = x_pos[0]+dx;
        y_pos[0] = y_pos[0]+dy;

        x_pos[1] = x_pos[1]-dx;
        y_pos[1] = y_pos[1]+dy;

        x_pos[2] = x_pos[2]+dx;
        y_pos[2] = y_pos[2]-dy;

        x_pos[3] = x_pos[3]-dx;
        y_pos[3] = y_pos[3]-dy;

        x_pos[4] = x_pos[4]-dy;
        y_pos[4] = y_pos[4]-dx;

        x_pos[5] = x_pos[5]+dy;
        y_pos[5] = y_pos[5]+dx;

        for(int k = 0; k < 6; k++){
            if(x_pos[k] < 0){
                x_pos[k] = 0;
            }
            if(x_pos[k] > 499){
                x_pos[k] = 499;
            }
        }

        for(int k = 0; k < 6; k++){
            if(y_pos[k] < 0){
                y_pos[k] = 0;
            }
            if(y_pos[k] > 279){
                y_pos[k] = 279;
            }
        }


        screen[x_pos[0]][y_pos[0]] = 1;
        screen[x_pos[1]][y_pos[1]] = 1;
        screen[x_pos[2]][y_pos[2]] = 1;
        screen[x_pos[3]][y_pos[3]] = 1;
        screen[x_pos[4]][y_pos[4]] = 1;
        screen[x_pos[5]][y_pos[5]] = 1;

        update_counter = update_counter + 1;

    } //end of update()

    public void paint(Graphics g){
        System.out.println("painting screen for the "+repaint_counter+"th time");

            g.setColor(Color.BLACK);
            g.fillRect(xmin, ymin, xmax, ymax);

            for(int j = 0; j<280; j++){
                for(int i = 0; i<500; i++){
                    if(screen[i][j] == 0){
                        g.setColor(Color.BLACK);
                    } else 
                    {   
                        g.setColor(Color.GREEN);    
                    }
                    g.drawLine(i,j,i,j); //plots pixel
                }
            }


            try{
                Thread.sleep(100);
            }
            catch(InterruptedException e){  
            }

            repaint_counter = repaint_counter + 1;


    }//end of paint(Graphics g)

}//end of Trip2 class

Answer 1

What's happening is you are stuck in your for-loop until it is done processing and then you repaint. What you should do is, since you are extending JPanel you have access to the Component's paintComponent method which is called when you first paint and on repaint of the component.

Like So

@Override
public void paintComponent(Graphics g) {

}

Rather than your

public void paint(Graphics g) {

}

When you override paintComponent , however, you need to make sure you call it's parent's paintComponent

Like so:

@Override
public void paintComponent(Graphics g) {
    super.paintComponent(g);
}

And while we are at it we can call your Update method before or after all of your painting, I chose before everything in my example:

@Override
public void paintComponent(Graphics g) {
    update();
    super.paintComponent(g); // Super is used to reference the parent


    // All of your painting methodology


    repaint(); // Force the component to repaint so this gets called over and over.
}

Be sure to remove that for-loop; of course you could always keep it if you wanted to have a lot of data before drawing.

And if you really wanted you could always keep the exact same code you have but follow the similar pattern as I said above.

Like this:

public void paint(Graphics g) {
    update();


    // All of your painting methodology


    repaint(); // Force the component to repaint so this gets called over and over.
}

Answer 2

One of the main issues here is that you are calling Thread.sleep() in the paint method - this is not a good idea as will halt the further repainting of your application for that period. (the Event Dispatch thread/Painting thread must not be use for any slow operations)

The usual flow for what you want to achieve here is as follows (poss way more detail than you need):

1. Create a model class that contains all your number variables and specifically just your numbers (no UI code) also create various getters to allow the UI to access these numbers later.
2. Allow this model class to be passed to the view class ( Trip1 in your case) and set to an instance variable.
3. Create a new Thread or Timer from the main controlling class that periodically adjusts your model numbers/internals as you desire.
4. Create a listener interface for changes on your model. (eg ModelChangedListener or such like)
5. Add in a list of listeners to your model - with a register method to simply add a listener to the list.
6. Make it such that any changes to your model ie when numbers are updated, these fire calls to the registered listeners.

7. In your main controlling class, register a listener to this model which solely calls: trip2Panel.repaint();

8. In the paint() method of your panel... just draw the model as it currently stands.

Full code posted:

package paranoid;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.Timer;

public class MasterFrame {

public static void main(String[] args) {
        // TODO Auto-generated method stub
new MasterFrame();
}


public MasterFrame(){
    JFrame f = new JFrame();
    f.setTitle("Kaleidoscope");
    final Trip2 trip2UI = new Trip2();
    final TripModel model = new TripModel();
    model.update();
    Timer timer = new Timer(1, new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            model.update();
        }
    });
    timer.setRepeats(true);
    timer.start();

    model.addListener(new TripModelListener() {
        @Override
        public void modelChanged() {
            trip2UI.repaint();
        }
    });
    trip2UI.setModel(model);

    f.add(trip2UI);
    f.setSize(500,300);
    f.setLocationRelativeTo(null);
    f.setVisible(true);
    f.setResizable(false);

    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    }
}

TripModelListener

package paranoid;

public interface TripModelListener {
    void modelChanged();
}

Trip2 (the ui)

package paranoid;

import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JPanel;


public class Trip2 extends JPanel {

private static final long serialVersionUID = 1L;

private TripModel model;

public void paint(Graphics g){

    g.setColor(Color.BLACK);
    g.fillRect(model.getXMin(), model.getYMin(), model.getXMax(), model.getYMax());

    for (int j = 0; j < 280; j++) {
        for (int i = 0; i < 500; i++) {
            if (model.getScreen()[i][j] == 0) {
                g.setColor(Color.BLACK);
            } else {
                g.setColor(Color.GREEN);
            }
            g.drawLine(i, j, i, j); //plots pixel
        }
    }
}

public void setModel(TripModel model) {
    this.model = model;
}

}//en

The Trip Model

package paranoid;

import java.awt.Color;
import java.awt.Graphics;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class TripModel {
private List<TripModelListener> listeners = new CopyOnWriteArrayList<TripModelListener>();
private int xmin = 0,
            xmax = 499,
            ymin = 0,
            ymax = 279;
private int x = 120;
private int y = 80;
private int dx = 1;
private int dy = 1;
private int temp = 0;
private int update_counter = 0;
private int x_pos[] = new int[6];
private int y_pos[] = new int[6];
private int screen[][] = new int[500][280];


public TripModel() {

    initialisation();
}

public void initialisation(){
    System.out.println("initialising...");
    x_pos[0] = x;
    y_pos[0] = y;

    x_pos[1] = xmax - x;
    y_pos[1] = y;

    x_pos[2] = x;
    y_pos[2] = ymax - y;

    x_pos[3] = xmax - x;
    y_pos[3] = ymax - y;

    x_pos[4] = (int)(xmax/2)-50;
    y_pos[4] = (int)(ymax/2);

    x_pos[5] = (int)(xmax/2)+50;
    y_pos[5] = (int)(ymax/2);

    for(int j = 0; j<280; j++){
        for(int i = 0; i<500; i++){
            screen[i][j] = 0;
        }
    }
} //end of initialisation()

public void update(){
    //System.out.println("updating... for the "+update_counter+"th time");

    temp = (int)Math.floor(Math.random()*100);
    if(temp < 40){ // 40% chance that the direction is changed
        dx = (int)Math.floor(Math.random()*3);
        dy = (int)Math.floor(Math.random()*3);
        dx = dx - 1;
        dy = dy - 1;
    }


    x_pos[0] = x_pos[0]+dx;
    y_pos[0] = y_pos[0]+dy;

    x_pos[1] = x_pos[1]-dx;
    y_pos[1] = y_pos[1]+dy;

    x_pos[2] = x_pos[2]+dx;
    y_pos[2] = y_pos[2]-dy;

    x_pos[3] = x_pos[3]-dx;
    y_pos[3] = y_pos[3]-dy;

    x_pos[4] = x_pos[4]-dy;
    y_pos[4] = y_pos[4]-dx;

    x_pos[5] = x_pos[5]+dy;
    y_pos[5] = y_pos[5]+dx;

    for(int k = 0; k < 6; k++){
        if(x_pos[k] < 0){
            x_pos[k] = 0;
        }
        if(x_pos[k] > 499){
            x_pos[k] = 499;
        }
    }

    for(int k = 0; k < 6; k++){
        if(y_pos[k] < 0){
            y_pos[k] = 0;
        }
        if(y_pos[k] > 279){
            y_pos[k] = 279;
        }
    }


    screen[x_pos[0]][y_pos[0]] = 1;
    screen[x_pos[1]][y_pos[1]] = 1;
    screen[x_pos[2]][y_pos[2]] = 1;
    screen[x_pos[3]][y_pos[3]] = 1;
    screen[x_pos[4]][y_pos[4]] = 1;
    screen[x_pos[5]][y_pos[5]] = 1;

    update_counter = update_counter + 1;
    fireModelChangedListener();
} //end of update()

private void fireModelChangedListener() {
    for (TripModelListener listener : listeners) {
        listener.modelChanged();
    }
}


public int getXMin() {
    return xmin;
}

public int getYMin() {
    return ymin;
}

public int getYmin() {
    return ymin;
}

public void setYmin(int ymin) {
    this.ymin = ymin;
}

public int getXMax() {
    return xmax;
}

public int getXmax() {
    return xmax;
}

public void setXmax(int xmax) {
    this.xmax = xmax;
}

public int getYMax() {
    return ymax;
}

public int[][] getScreen() {
    return screen;
}

public void addListener( TripModelListener listener) {
    listeners.add(listener);
}
}