Updating JFrame is too slow (Fullscreen)

[Matt Metzger]

I'm trying to simulate an LED display for a device. Right now I'm drawing one image to a fullscreen JFrame, updating the image depending on which LEDs should be turned on. Right now it seems to update far too slowly, for example everything turns on at the end of the "Exposure" loop. I had a sample running alright before drawing to a JPanel canvas, but now I'm running into issues when full screen. There are comments spaced through the code showing how the JPanel was set up in this newer version. Any suggestions to get headed in the right direction?

Also, this is set up fairly poorly in two classes because I'll need a while loop running at one point (single LED blinking on/off until keypress), and I need to set up the KeyListener in another thread I think.
_____________

Some sample functions:

Start:

Ask for "Exposure Time"
User will input 6, 7, 8, 9, or 10
"Exposure Time" divided by 4 = sequence time (in seconds)

When user pushes the "p" key (power):
turn on LED 1

Exposure:
When the user push the "s" key (start):
Delay .2 seconds
Turn on LED 3
Wait "sequence time"
Turn on LEDs 4 and 5
Wait "sequence time"
Turn on LEDs 6 and 7
Wait "sequence time"
Turn on LEDs 8 and 9
Wait "sequence time"
Turn on LEDs A and B

_____________

 
public class Simulation extends JFrame implements Runnable { 
 
    // this line is needed to avoid serialization warnings  
    private static final long serialVersionUID = 1L;
 
	private Component frame;
	private double exposureTime;
	private int sequenceTime;
	private boolean alertState;
	private boolean powerState;
	private boolean exposing;
	DisplayCanvas canvas;
 
    Image screenImage; // downloaded image  
    int w, h; // Display height and width 
    Thread sim;

 
    // Class constructor  
    Simulation() {
    	
    	exposurePrompt();
    	
    	sim = new Thread(this, "Simulation");
    	sim.start();
 
        // Exiting program on window close 
        addWindowListener(new WindowAdapter() { 
            public void windowClosing(WindowEvent e) { 
                System.exit(0);
            } 
        });
 
        
        addKeyListener(new KeyListener() { 

			@Override
			public void keyPressed(KeyEvent e) {

				switch (e.getKeyCode()) {
				case KeyEvent.VK_P:
					Game.power();
					break;
				case KeyEvent.VK_S:
					try {
						Game.exposure();
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
					break;
			/*	case KeyEvent.VK_F:
					Game.finish();
					break;
				case KeyEvent.VK_A:
					Game.alert();
					break;
			*/	case KeyEvent.VK_ESCAPE:
					System.exit(0);
					break;
				}
				
			}
			@Override
			public void keyReleased(KeyEvent arg0) {}
			
			@Override
			public void keyTyped(KeyEvent arg0) {} 
			
        });
 
        
        
        // remove window frame  
        this.setUndecorated(true);
 
        // window should be visible 
        this.setVisible(true);
 
        // switching to fullscreen mode 
        GraphicsEnvironment.getLocalGraphicsEnvironment().
        getDefaultScreenDevice().setFullScreenWindow(this);
 
        // getting display resolution: width and height 
        w = this.getWidth();
        h = this.getHeight();
        System.out.println("Display resolution: " + String.valueOf(w) + "x" + String.valueOf(h));
 
        // loading startup image  
            screenImage = Toolkit.getDefaultToolkit().getImage("res/off.jpg");
       
       /*
        canvas = new DisplayCanvas();
		canvas.setPreferredSize(new Dimension(w, h));
		
		Container contentPane = getContentPane();
		contentPane.add(canvas);
       */
    } 
    
	private void exposurePrompt() {
		
		powerState = false;
		exposing = false;
		
		Object[] possibilities = {"6", "7", "8", "9", "10"};
		
		String s = (String)JOptionPane.showInputDialog(frame,
			    "Exposure time (seconds):",
			    "LED Simulation",
			    JOptionPane.PLAIN_MESSAGE, null,
			    possibilities, null);		
		
		exposureTime = Double.parseDouble(s);
		sequenceTime = (int) Math.ceil((exposureTime / 4) * 1000);
		
	}
    
    public void run() {
    	
    	// TODO:
    	// Break out of while loop
    	// with KeyListener
    	
    	canvas.paintComponent(this.getGraphics());
    }
    
    public void setImage(String jpg){
    	screenImage = Toolkit.getDefaultToolkit().getImage(jpg);
    	SwingUtilities.updateComponentTreeUI(this);	
    //	canvas.paintComponent(getGraphics());
    	
    	
    }
 
   
    @Override
    public void paint (Graphics g) { 
      //  if (screenImage != null) // if screenImage is not null (image loaded and ready) 
            g.drawImage(screenImage, // draw it  
                        0,
                        0,
                        w,
                        screenImage.getHeight(this),            			
                        this);
            // to draw image at the center of screen 
            // we calculate X position as a half of screen width minus half of image width 
            // Y position as a half of screen height minus half of image height 
    }
    
    

    // ----- POWER GETTERS AND SETTERS ------

	public boolean isOn() {
    	return powerState;
    }
    
    public void turnOn() {
    	powerState = true;
    	setImage("res/power.jpg");
    	
    }
    
    public void turnOff() {
    	powerState = false;
    	setImage("res/off.jpg");
    	
    	Thread.sleep(750);
    	
    	exposurePrompt();
    	
    	// TODO: Bring window to front
    	
    }
    
    // // ----- EXPOSING GETTERS AND SETTERS ------
    
    public boolean isExposing() {
    	return exposing;
    }
    
    public void setExposing(boolean b) {
    	exposing = b;
    }
    
    public int getSequenceTime(){
    	return sequenceTime;
    }


	 // DISPLAY CANVAS CLASS
	 // -------------------
	 class DisplayCanvas extends JPanel {

			private static final long serialVersionUID = 1L;
			
			

			@Override
			public void paintComponent(Graphics g) {
				
				 g.drawImage(screenImage,
		                 0,
		                 0,
		                 w,
		                 screenImage.getHeight(this),            			
		                 this);
				
				super.paint(g);
			}
	 }


}

import javax.swing.SwingUtilities;

public class Game {

	static Simulation sim;

	// Program entry
	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {

			public void run() {
				sim = new Simulation();
			}

		});

	}

	public static void power() {

		// REQUIRES: Power is OFF in Start
		// EFFECTS: Power ON.
		if (!sim.isOn()) {
			sim.turnOn();
		} else if (sim.isOn()) {
			sim.turnOff();
		}

	}

	public static void exposure() throws InterruptedException {

		if (sim.isOn() && !sim.isExposing()) {
			// sim.setExposing(true);

			while (sim.isExposing()) {
				// Delay .2 seconds
				wait(200);
				// Turn on LED3
				sim.setImage("res/exposure_1.jpg");
				// Wait "sequence time"
				wait(sim.getSequenceTime());
	
				// Turn on LEDs 4 and 5
				sim.setImage("res/exposure_2.jpg");
				// Wait "sequence time"
				wait(sim.getSequenceTime());
				
				// Turn on LEDs 6 and 7 
				sim.setImage("res/exposure_3.jpg"); //
				//Wait "sequence time" 
				wait(sim.getSequenceTime());
				
				// Turn on LEDs 8 and 9 
				sim.setImage("res/exposure_4.jpg"); //
				//Wait "sequence time" 
				wait(sim.getSequenceTime());
				
				// Turn on LEDs A and B
				sim.setImage("res/exposure_complete.jpg");
				
				sim.setExposing(false);
				 
			}
		}

	}
	
	 public static void wait (int n){
	        
	        long t0, t1;
	        t0 =  System.currentTimeMillis();

	        do {
	        	t1 = System.currentTimeMillis();
	        } while 
	        	(t1 - t0 < n);
	    }

}

[Rob Spoor]

A few things I quickly saw:

1) You are updating the user interface from a thread that is not the Event Dispatcher Thread. You shouldn't; read Concurrency in Swing for more information.

2) You are starting the thread before the object has completed its initialization. This could potentially lead to problems, like NullPointerExceptions etc. If you really need to start the thread (which you don't with the current code), that should be done at the end of the constructor. Even better is to use either a Swing timer (if you need to do something on regular intervals), or a SwingWorker. The latter has methods publish / process with which you can perform updates to the user interface.

3) You override paint of the JFrame itself. You should instead create a new JPanel sub class which overrides paintComponent, and set an instance of that JPanel sub class as the JFrame's content pane.

4) You are calling paintComponent directly. You should instead call repaint().

5) Your JPanel should not call super.paint(g) from paintComponent, but instead super.paintComponent(g). This should also be the first statement of the method.


This last one is actually the main reason for your slowness. When your panel is painted, it calls paintComponent. This will call paint. This in turn will lead to paintComponent to be called. This will again call paint. This will continue forever; your CPU is being hogged by constant repainting.

[Matt Metzger]

Thanks for the quick reply!

For those changes:

1) TODO

2) Starting the thread at the end of the constructor now.

3) JPanel subclass added to the content pane.

4) Changed to repaint(), but see below.

5) Got it! Changing super.paint(g) to super.paintComponent(g) got images to draw to the JPanel while fullscreen. Thanks.

However, there's still a delay with repaint(). Specifically, the screen now goes white until the "Exposure" sequence has run through. But if I run the sequence a second time while the same instance of the program is still up, it runs smoothly. Would using BufferedImage solve this problem, and do you have any advice on its use here?

[Darryl Burke]

Matt Metzger wrote:However, there's still a delay with repaint(). Specifically, the screen now goes white until the "Exposure" sequence has run through.

Rob Spoor wrote:5) Your JPanel should not call super.paint(g) from paintComponent, but instead super.paintComponent(g). This should also be the first statement of the method.

Did you make that change?

And since this is related to GUIs, I'm moving this thread to the section where we usually discuss such things.

[Matt Metzger]

Rob Spoor wrote:5) Your JPanel should not call super.paint(g) from paintComponent, but instead super.paintComponent(g). This should also be the first statement of the method.

I had made this change, but with the same results. And strange, but after removing any sort of super calls within paintComponet() the flickering has stopped. Every call to drawImage() is redrawing over the entire JPanel; maybe that's got something to do with it. Not quite sure what's up, looking into it still, but it's working well. Thanks.

[Rob Spoor]

You're calling exposure() on the EDT. This will block the entire EDT until the method is done. During this time the EDT will do nothing, including (re)painting. I suggest you read the Concurrency in Swing article now, because it will explain what's going wrong and how to solve it.