Graphics flashing in JApplet

Question

I know that this has been asked many times before, but every time I visit the question thread and excecute the posed solution, it still doesn't work for me.

So before I create any confusion, the problem I have is that the screen I draw is constantly flashing, this is because every time I draw the screen, I clear the screen with a completely white filled rectangle, the things I draw over the rectangle will flash.

Here is my code:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.geom.*;
import javax.swing.Timer.*;

/**
  *
  * beschrijving
  *
  * @version 1.0 van 16-6-2016
  * @author 
  */

public class shadows3 extends JApplet implements ActionListener{
  // Begin variabelen
  int[] loc = new int[2];
  int[][] wall = new int[10][8];
  // Einde variabelen

  public void init() {
    Container cp = getContentPane();
    cp.setLayout(null);
    cp.setBounds(0, 0, 600, 600);
    // Begin componenten
    for (int a=0; a<10; a++) {
      int tempx = (int) (Math.random()*20)*30;
      int tempy = (int) (Math.random()*20)*30;
      wall[a][0] = tempx;
      wall[a][1] = tempy;
      wall[a][2] = tempx+30;
      wall[a][3] = tempy;
      wall[a][4] = tempx+30;
      wall[a][5] = tempy+30;
      wall[a][6] = tempx;
      wall[a][7] = tempy+30;
    } // end of for

    loc[0] = 300;
    loc[1] = 300;

    Timer step = new Timer(20, this);
    step.start();
    // Einde componenten

  } // end of init
  private int length(int x1, int y1, int x2, int y2) {
    double distance = Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
    return (int) distance;
  }

  // Begin eventmethoden

  public void paint (Graphics g){
    g.setColor(Color.WHITE);
    g.fillRect(0,0,600,600);

    int[] xpoints = new int[8];
    int[] ypoints = new int[8];
    int[] list = new int[3];
    for (int a=0; a<5; a++) {
      for (int b=0; b<4; b++) {
        if (length(wall[a][b*2],wall[a][b*2+1],loc[0],loc[1])==Math.max(Math.max(length(wall[a][0],wall[a][1],loc[0],loc[1]),
        length(wall[a][2],wall[a][3],loc[0],loc[1])),
        Math.max(length(wall[a][4],wall[a][5],loc[0],loc[1]),
        length(wall[a][6],wall[a][7],loc[0],loc[1])))) {
          int temp = b;
          for (int c=0; c<3; c++) {
            temp += 1;
            if (temp == 4) {
              temp = 0;
            } // end of if
            list[c] = temp;
          } // end of for
        } // end of if
      } // end of for
      xpoints[0] = wall[a][list[0]*2  ];
      ypoints[0] = wall[a][list[0]*2+1];

      xpoints[1] = wall[a][list[1]*2  ];
      ypoints[1] = wall[a][list[1]*2+1];

      xpoints[2] = wall[a][list[2]*2  ];
      ypoints[2] = wall[a][list[2]*2+1];

      xpoints[3] = wall[a][list[2]*2  ]+(wall[a][list[2]*2  ]-loc[0])*10000;
      ypoints[3] = wall[a][list[2]*2+1]+(wall[a][list[2]*2+1]-loc[1])*10000;

      xpoints[4] = wall[a][list[0]*2  ]+(wall[a][list[0]*2  ]-loc[0])*10000;
      ypoints[4] = wall[a][list[0]*2+1]+(wall[a][list[0]*2+1]-loc[1])*10000;

      g.setColor(Color.BLACK);
      g.fillPolygon(xpoints, ypoints, 5);
      //g.fillRect(wall[a][0],wall[a][1],30,30);
    } // end of for
  }

  //@Override
  public void actionPerformed(ActionEvent e){
    loc[0] += 4;
    loc[1] += 2;

    repaint();
  }
  // Einde eventmethoden

} // end of class shadows3

If you're wondering what I'm trying to create, it's some kind of real-time shadows engine, it's fairly slow but it's just a fun project, the screen flashing is a real problem though for many of my projects.

Many thanks in advance!

1) Why code an applet? If it is due to the teacher specifying it, please refer them to [Why CS teachers should **stop** teaching Java applets](http://programmers.blogoverflow.com/2013/05/why-cs-teachers-should-stop-teaching-java-applets/). 2) See [Java Plugin support deprecated](http://www.gizmodo.com.au/2016/01/rest-in-hell-java-plug-in/) and [Moving to a Plugin-Free Web](https://blogs.oracle.com/java-platform-group/entry/moving_to_a_plugin_free). — Andrew Thompson, Jun 22 '16 at 01:54

score 2 · Answer 1 · edited May 23 '17 at 11:58

Because you should be migrating to a plugin-free environment, consider a hybrid deployed via java-web-start. The example below displays your content in a JPanel, which is double buffered by default. In particular,

Invoke super.paintComponent() to avoid rendering artifacts.
Override getPreferredSize() to establish the initial size.
Instantiate Random with a constant seed for easier debugging.
The applet tag in a comment allows easy testing, as shown here.

Test:

$ javac ShadowApplet.java ; appletviewer ShadowApplet.java

Code:

//<applet code="ShadowApplet.class" width=600 height=600></applet>
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JApplet;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

/**
 * @see https://stackoverflow.com/a/37958844/230513
 */
public class ShadowApplet extends JApplet {

    private static final Random R = new Random(42);

    @Override
    public void init() {
        EventQueue.invokeLater(() -> {
            add(new ShadowPanel());
        });
    }

    public static void main(String[] args) {
        EventQueue.invokeLater(new ShadowApplet()::display);
    }

    private void display() {
        JFrame f = new JFrame("Test");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.add(new ShadowPanel());
        f.pack();
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

    private static class ShadowPanel extends JPanel implements ActionListener {

        int[] loc = new int[2];
        int[][] wall = new int[10][8];

        public ShadowPanel() {
            this.setLayout(null);
            this.setBackground(Color.WHITE);
            for (int a = 0; a < 10; a++) {
                int tempx = R.nextInt(20) * 30;
                int tempy = R.nextInt(20) * 30;
                wall[a][0] = tempx;
                wall[a][1] = tempy;
                wall[a][2] = tempx + 30;
                wall[a][3] = tempy;
                wall[a][4] = tempx + 30;
                wall[a][5] = tempy + 30;
                wall[a][6] = tempx;
                wall[a][7] = tempy + 30;
            }
            loc[0] = 300;
            loc[1] = 300;
            Timer step = new Timer(20, this);
            step.start();
        }

        private int length(int x1, int y1, int x2, int y2) {
            double distance = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
            return (int) distance;
        }

        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            int[] xpoints = new int[8];
            int[] ypoints = new int[8];
            int[] list = new int[3];
            for (int a = 0; a < 5; a++) {
                for (int b = 0; b < 4; b++) {
                    if (length(wall[a][b * 2], wall[a][b * 2 + 1], loc[0],
                        loc[1]) == Math.max(Math.max(length(wall[a][0], wall[a][1], loc[0], loc[1]),
                            length(wall[a][2], wall[a][3], loc[0], loc[1])),
                            Math.max(length(wall[a][4], wall[a][5], loc[0], loc[1]),
                                length(wall[a][6], wall[a][7], loc[0], loc[1])))) {
                        int temp = b;
                        for (int c = 0; c < 3; c++) {
                            temp += 1;
                            if (temp == 4) {
                                temp = 0;
                            }
                            list[c] = temp;
                        }
                    }
                }
                xpoints[0] = wall[a][list[0] * 2];
                ypoints[0] = wall[a][list[0] * 2 + 1];

                xpoints[1] = wall[a][list[1] * 2];
                ypoints[1] = wall[a][list[1] * 2 + 1];

                xpoints[2] = wall[a][list[2] * 2];
                ypoints[2] = wall[a][list[2] * 2 + 1];

                xpoints[3] = wall[a][list[2] * 2] + (wall[a][list[2] * 2] - loc[0]) * 10000;
                ypoints[3] = wall[a][list[2] * 2 + 1] + (wall[a][list[2] * 2 + 1] - loc[1]) * 10000;

                xpoints[4] = wall[a][list[0] * 2] + (wall[a][list[0] * 2] - loc[0]) * 10000;
                ypoints[4] = wall[a][list[0] * 2 + 1] + (wall[a][list[0] * 2 + 1] - loc[1]) * 10000;

                g.setColor(Color.BLACK);
                g.fillPolygon(xpoints, ypoints, 5);
                g.fillRect(wall[a][0], wall[a][1], 30, 30);
            }
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            loc[0] += 4;
            loc[1] += 2;
            repaint();
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(600, 600);
        }
    }
}

Thank you, I'll definitely give it a look – Lolslayer Jun 23 '16 at 08:21 — Lolslayer, Jun 23 '16 at 08:21

score 1 · Answer 2 · answered Jun 22 '16 at 01:16

You need to create a separate image to draw all things on:

im=createImage(getWidth(), getHeight());

in init.

Then in your paint:

Graphics g2=im.getGraphics();
g2.setColor(Color.WHITE);
g2.fillRect(0,0,600,600);

and continue with all the g commands replaced with g2:

g2.setColor(Color.BLACK);
g2.fillPolygon(xpoints, ypoints, 5);

then you draw the image on g:

g.drawImage(im, 0, 0, this);

and you have an update method:

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

Graphics flashing in JApplet

2 Answers2

Linked