Sprites disappearing after scaling down window? Aaargh the frustration!

[Tyler Eastman]

I am so stumped here!

Ok, so I have a chess program that I am writing, and I can't for the life of me figure out what is wrong with my resize code. Any help is greatly appreciated!

EDIT: See 2 comments below for a short compilable example.

Problem: Every time I resize the window smaller, certain pieces disappear, however this problem only arises when I resize the window fast. If I gradually resize it smaller, the pieces don't disappear!?!? I have attached images of the problem.

Code Structure: The resize code is spread over 3 classes. The MainGui, the ChessBoard, and the ChessPiece class. The gamePanelComponentResize method resides in the MainGui class, and is a listener for the resize component event. This method then delegates the resize order to the ChessBoard object, which in turn delegates it to each of the remaining ChessPiece objects.

MainGui method:

    private void gamePanelComponentResized(java.awt.event.ComponentEvent evt) {                                           
        
        // resize and reposition the chessboard when screen is resized
        int size = getHeight() - 150;

        int unit = size/8;  

        // set chessboard to appropriate size (divisible by 8)
        chessBoard.setSize(unit*8, unit*8);

        // resize bottom panel
        bbchess.StatusPanel spanel = (bbchess.StatusPanel) statusPanel;
        spanel.resizePanel(getWidth());

        // set chessboard location
        chessBoard.setLocation((getWidth()/2) - (chessBoard.getWidth()/2), (int) chessBoard.getLocation().getY());
        repaint();
    }   

ChessBoard Methods:

    @Override
    public void setSize(int x, int y) {

        super.setSize(x, y);

        // performs resize calculations on chess squares
        resizeBoard();

        // scales chess pieces
        for (ChessPiece piece : chessPieces) {
            piece.setSize(unit, unit);
        }

    }

// called by setSize to resize the board
    private void resizeBoard() {

        unit = (getWidth()/8);

        // perform multiplications now to save repetitive code
        int u2 = unit*2;
        int u3 = unit*3;
        int u4 = unit*4;
        int u5 = unit*5;
        int u6 = unit*6;
        int u7 = unit*7;

        // resize squares depending on board orientation
        if (getBoardOrientation().equals("white")) {
            a1.resize(0, u7, unit);
            a2.resize(0, u6, unit);
            a3.resize(0, u5, unit);
            a4.resize(0, u4, unit);
            a5.resize(0, u3, unit);
            a6.resize(0, u2, unit);
            a7.resize(0, unit, unit);
            a8.resize(0, 0, unit);
            b1.resize(unit, u7, unit);
            b2.resize(unit, u6, unit);
            b3.resize(unit, u5, unit);
            b4.resize(unit, u4, unit);
            b5.resize(unit, u3, unit);
            b6.resize(unit, u2, unit);
            b7.resize(unit, unit, unit);
            b8.resize(unit, 0, unit);
            c1.resize(u2, u7, unit);
            c2.resize(u2, u6, unit);
            c3.resize(u2, u5, unit);
            c4.resize(u2, u4, unit);
            c5.resize(u2, u3, unit);
            c6.resize(u2, u2, unit);
            c7.resize(u2, unit, unit);
            c8.resize(u2, 0, unit);
            d1.resize(u3, u7, unit);
            d2.resize(u3, u6, unit);
            d3.resize(u3, u5, unit);
            d4.resize(u3, u4, unit);
            d5.resize(u3, u3, unit);
            d6.resize(u3, u2, unit);
            d7.resize(u3, unit, unit);
            d8.resize(u3, 0, unit);
            e1.resize(u4, u7, unit);
            e2.resize(u4, u6, unit);
            e3.resize(u4, u5, unit);
            e4.resize(u4, u4, unit);
            e5.resize(u4, u3, unit);
            e6.resize(u4, u2, unit);
            e7.resize(u4, unit, unit);
            e8.resize(u4, 0, unit);
            f1.resize(u5, u7, unit);
            f2.resize(u5, u6, unit);
            f3.resize(u5, u5, unit);
            f4.resize(u5, u4, unit);
            f5.resize(u5, u3, unit);
            f6.resize(u5, u2, unit);
            f7.resize(u5, unit, unit);
            f8.resize(u5, 0, unit);
            g1.resize(u6, u7, unit);
            g2.resize(u6, u6, unit);
            g3.resize(u6, u5, unit);
            g4.resize(u6, u4, unit);
            g5.resize(u6, u3, unit);
            g6.resize(u6, u2, unit);
            g7.resize(u6, unit, unit);
            g8.resize(u6, 0, unit);
            h1.resize(u7, u7, unit);
            h2.resize(u7, u6, unit);
            h3.resize(u7, u5, unit);
            h4.resize(u7, u4, unit);
            h5.resize(u7, u3, unit);
            h6.resize(u7, u2, unit);
            h7.resize(u7, unit, unit);
            h8.resize(u7, 0, unit);
        } else {
            h8.resize(0, u7, unit);
            h7.resize(0, u6, unit);
            h6.resize(0, u5, unit);
            h5.resize(0, u4, unit);
            h4.resize(0, u3, unit);
            h3.resize(0, u2, unit);
            h2.resize(0, unit, unit);
            h1.resize(0, 0, unit);
            g8.resize(unit, u7, unit);
            g7.resize(unit, u6, unit);
            g6.resize(unit, u5, unit);
            g5.resize(unit, u4, unit);
            g4.resize(unit, u3, unit);
            g3.resize(unit, u2, unit);
            g2.resize(unit, unit, unit);
            g1.resize(unit, 0, unit);
            f8.resize(u2, u7, unit);
            f7.resize(u2, u6, unit);
            f6.resize(u2, u5, unit);
            f5.resize(u2, u4, unit);
            f4.resize(u2, u3, unit);
            f3.resize(u2, u2, unit);
            f2.resize(u2, unit, unit);
            f1.resize(u2, 0, unit);
            e8.resize(u3, u7, unit);
            e7.resize(u3, u6, unit);
            e6.resize(u3, u5, unit);
            e5.resize(u3, u4, unit);
            e4.resize(u3, u3, unit);
            e3.resize(u3, u2, unit);
            e2.resize(u3, unit, unit);
            e1.resize(u3, 0, unit);
            d8.resize(u4, u7, unit);
            d7.resize(u4, u6, unit);
            d6.resize(u4, u5, unit);
            d5.resize(u4, u4, unit);
            d4.resize(u4, u3, unit);
            d3.resize(u4, u2, unit);
            d2.resize(u4, unit, unit);
            d1.resize(u4, 0, unit);
            c8.resize(u5, u7, unit);
            c7.resize(u5, u6, unit);
            c6.resize(u5, u5, unit);
            c5.resize(u5, u4, unit);
            c4.resize(u5, u3, unit);
            c3.resize(u5, u2, unit);
            c2.resize(u5, unit, unit);
            c1.resize(u5, 0, unit);
            b8.resize(u6, u7, unit);
            b7.resize(u6, u6, unit);
            b6.resize(u6, u5, unit);
            b5.resize(u6, u4, unit);
            b4.resize(u6, u3, unit);
            b3.resize(u6, u2, unit);
            b2.resize(u6, unit, unit);
            b1.resize(u6, 0, unit);
            a8.resize(u7, u7, unit);
            a7.resize(u7, u6, unit);
            a6.resize(u7, u5, unit);
            a5.resize(u7, u4, unit);
            a4.resize(u7, u3, unit);
            a3.resize(u7, u2, unit);
            a2.resize(u7, unit, unit);
            a1.resize(u7, 0, unit);
        }
    }

ChessPiece methods:

@Override
    public void paintComponent(Graphics g) {
        int border = 20;
        Graphics2D g2d = (Graphics2D) g.create();
        int unitSize = board.getUnitSize();

        try {

            // if we're dragging
            if (isDragging()) {

                mousePointer = board.getMousePosition();

                // if mouse is within X bounds, setTempX
                if (mousePointer.getX() < board.getWidth() - border && mousePointer.getX() >= border) {
                    setTempX((int) mousePointer.getX());
                }

                // if mouse is within Y bounds, setTempY
                if (mousePointer.getY() < board.getHeight() - border && mousePointer.getY() >= border) {
                    setTempY((int) mousePointer.getY());
                }

                // set the location of the piece under the cursor and draw piece
                setLocation(getTempX() - offset, getTempY() - offset);
                g2d.drawImage(getSprite(), 0, 0, unitSize, unitSize, this);

            // else if the piece is in a moving animation
            } else if (isMoving()) {

                // set location and draw piece
                setLocation(getTempX(), getTempY());
                g2d.drawImage(getSprite(), 0, 0, unitSize, unitSize, this);

            // else if piece is captured
            } else if (isCaptured()) {
                // scale sprite so it fits inside capturedPiecesPanel
                g2d.drawImage(getSprite(), 0, 0, 30, 30, this);

            // else just draw the piece at its square
            } else {

                setLocation(position.getTopLeftX(), position.getTopLeftY());
                g2d.drawImage(getSprite(), 0, 0, unitSize, unitSize, this);

                // if the piece is capturable, make sure to draw appropriate sprite
                if (getCapturable()) {
                    ChessSquare.drawCapturableSquare(g, 0, 0, board.getUnitSize());
                }
            }
            
        } catch (Exception ex) {
            // if mouse is out of bounds, draw image anyway
            g2d.drawImage(this.getSprite(), 0, 0, board.getUnitSize(), board.getUnitSize(), this);
        }

        g2d.dispose();
    }

[Peter Taucher]

I can't see no classes and no relations. If you could dumb down your problem to a SSCCE ... that would be great.

[Tyler Eastman]

Ok, I will trim down the fat and try to get a simple compilable example ready by the end of today.

[Tyler Eastman]

Heres a simple compilable example of the problem. I apologize for the length of ChessBoard.java. Most of the code in that class is initialization code and can be ignored. The resizeBoard, setSize, and paintComponent methods are the only ones linked to the problem (that I'm aware of) in that class.

Thank you for taking the time to help!

MainGui.java

import java.awt.*;

public class MainGui extends javax.swing.JFrame {

    public ChessBoard chessBoard;
    private javax.swing.JPanel gamePanel;

    public MainGui() {

        // initialize components
        this.setTitle("BlackBox Chess");
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
        chessBoard = new ChessBoard(this);
        initComponents();

        gamePanel.add(chessBoard);
        chessBoard.setLocation(28, 28);

        this.pack();
                
        setLocationRelativeTo(null);
        setVisible(true);
    }

    public static void main(String[] args) {

        EventQueue.invokeLater(new Runnable() {
            public void run() {
                new MainGui();
            }
        });
    }

    private void initComponents() {

        gamePanel = new javax.swing.JPanel();
        setMinimumSize(new java.awt.Dimension(500, 500));
        gamePanel.setPreferredSize(new java.awt.Dimension(500, 500));
        gamePanel.addComponentListener(new java.awt.event.ComponentAdapter() {
            @Override
            public void componentResized(java.awt.event.ComponentEvent evt) {
                gamePanelComponentResized(evt);
            }
        });

        gamePanel.setLayout(null);
        getContentPane().add(gamePanel, java.awt.BorderLayout.CENTER);
        pack();
    }

    private void gamePanelComponentResized(java.awt.event.ComponentEvent evt) {

        // resize and reposition the chessboard when screen is resized
        int size = getHeight() - 150;
        int unit = size/8;  

        // set chessboard to an appropriate size (divisible by 8)
        chessBoard.setSize(unit*8, unit*8);

        // set chessboard location to center
        chessBoard.setLocation((getWidth()/2) - (chessBoard.getWidth()/2),
                (int) chessBoard.getLocation().getY());
        repaint();
    }
}

ChessBoard.java

import java.awt.Image;
import java.io.File;
import javax.imageio.ImageIO;
import java.awt.Graphics;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import javax.swing.JPanel;

public class ChessBoard extends JPanel {

    // declare variables
    private Map<String, ChessSquare> chessSquares;
    private ArrayList<ChessPiece> chessPieces;
    public MainGui gui;
    private int unit;
    private static Image boardImage;
    private static Image wPawnImage;
    
    // Squares
    ChessSquare a1;
    ChessSquare a2;
    ChessSquare a3;
    ChessSquare a4;
    ChessSquare a5;
    ChessSquare a6;
    ChessSquare a7;
    ChessSquare a8;
    ChessSquare b1;
    ChessSquare b2;
    ChessSquare b3;
    ChessSquare b4;
    ChessSquare b5;
    ChessSquare b6;
    ChessSquare b7;
    ChessSquare b8;
    ChessSquare c1;
    ChessSquare c2;
    ChessSquare c3;
    ChessSquare c4;
    ChessSquare c5;
    ChessSquare c6;
    ChessSquare c7;
    ChessSquare c8;
    ChessSquare d1;
    ChessSquare d2;
    ChessSquare d3;
    ChessSquare d4;
    ChessSquare d5;
    ChessSquare d6;
    ChessSquare d7;
    ChessSquare d8;
    ChessSquare e1;
    ChessSquare e2;
    ChessSquare e3;
    ChessSquare e4;
    ChessSquare e5;
    ChessSquare e6;
    ChessSquare e7;
    ChessSquare e8;
    ChessSquare f1;
    ChessSquare f2;
    ChessSquare f3;
    ChessSquare f4;
    ChessSquare f5;
    ChessSquare f6;
    ChessSquare f7;
    ChessSquare f8;
    ChessSquare g1;
    ChessSquare g2;
    ChessSquare g3;
    ChessSquare g4;
    ChessSquare g5;
    ChessSquare g6;
    ChessSquare g7;
    ChessSquare g8;
    ChessSquare h1;
    ChessSquare h2;
    ChessSquare h3;
    ChessSquare h4;
    ChessSquare h5;
    ChessSquare h6;
    ChessSquare h7;
    ChessSquare h8;

    public ChessBoard(MainGui gui) {

        try {
            wPawnImage = (ImageIO.read(new File("wpawn.png")));
            boardImage = (ImageIO.read(new File("board.png")));
        } catch (Exception ex) {System.out.println("Error loading images");}

        unit = 53;

        chessSquares = new HashMap<String, ChessSquare>();
        chessPieces = new ArrayList<ChessPiece>();
        this.gui = gui;
        setDoubleBuffered(true);
        setLayout(null);
        initSquares();
        initPieces();
    }

    public int getUnitSize() {
        return unit;
    }

    @Override
    public void setSize(int x, int y) {

        super.setSize(x, y);

        // performs resize calculations on chess squares
        resizeBoard();

        // scales chess pieces
        for (ChessPiece piece : chessPieces) {
            piece.setSize(unit, unit);
        }

    }

    // called by setSize to resize the board
    private void resizeBoard() {

        unit = (getWidth() / 8);

        // perform multiplications now to save repetitive code
        int u2 = unit * 2;
        int u3 = unit * 3;
        int u4 = unit * 4;
        int u5 = unit * 5;
        int u6 = unit * 6;
        int u7 = unit * 7;

        a1.resize(0, u7, unit);
        a2.resize(0, u6, unit);
        a3.resize(0, u5, unit);
        a4.resize(0, u4, unit);
        a5.resize(0, u3, unit);
        a6.resize(0, u2, unit);
        a7.resize(0, unit, unit);
        a8.resize(0, 0, unit);
        b1.resize(unit, u7, unit);
        b2.resize(unit, u6, unit);
        b3.resize(unit, u5, unit);
        b4.resize(unit, u4, unit);
        b5.resize(unit, u3, unit);
        b6.resize(unit, u2, unit);
        b7.resize(unit, unit, unit);
        b8.resize(unit, 0, unit);
        c1.resize(u2, u7, unit);
        c2.resize(u2, u6, unit);
        c3.resize(u2, u5, unit);
        c4.resize(u2, u4, unit);
        c5.resize(u2, u3, unit);
        c6.resize(u2, u2, unit);
        c7.resize(u2, unit, unit);
        c8.resize(u2, 0, unit);
        d1.resize(u3, u7, unit);
        d2.resize(u3, u6, unit);
        d3.resize(u3, u5, unit);
        d4.resize(u3, u4, unit);
        d5.resize(u3, u3, unit);
        d6.resize(u3, u2, unit);
        d7.resize(u3, unit, unit);
        d8.resize(u3, 0, unit);
        e1.resize(u4, u7, unit);
        e2.resize(u4, u6, unit);
        e3.resize(u4, u5, unit);
        e4.resize(u4, u4, unit);
        e5.resize(u4, u3, unit);
        e6.resize(u4, u2, unit);
        e7.resize(u4, unit, unit);
        e8.resize(u4, 0, unit);
        f1.resize(u5, u7, unit);
        f2.resize(u5, u6, unit);
        f3.resize(u5, u5, unit);
        f4.resize(u5, u4, unit);
        f5.resize(u5, u3, unit);
        f6.resize(u5, u2, unit);
        f7.resize(u5, unit, unit);
        f8.resize(u5, 0, unit);
        g1.resize(u6, u7, unit);
        g2.resize(u6, u6, unit);
        g3.resize(u6, u5, unit);
        g4.resize(u6, u4, unit);
        g5.resize(u6, u3, unit);
        g6.resize(u6, u2, unit);
        g7.resize(u6, unit, unit);
        g8.resize(u6, 0, unit);
        h1.resize(u7, u7, unit);
        h2.resize(u7, u6, unit);
        h3.resize(u7, u5, unit);
        h4.resize(u7, u4, unit);
        h5.resize(u7, u3, unit);
        h6.resize(u7, u2, unit);
        h7.resize(u7, unit, unit);
        h8.resize(u7, 0, unit);
    }

    @Override
    public void paintComponent(Graphics g) {
        g.drawImage(boardImage, 0, 0, getWidth(), getHeight(), this);
    }

    private void initSquares() {
            chessSquares.put("a1", a1 = new ChessSquare("a1", 0, unit * 7, unit));
            chessSquares.put("a2", a2 = new ChessSquare("a2", 0, unit * 6, unit));
            chessSquares.put("a3", a3 = new ChessSquare("a3", 0, unit * 5, unit));
            chessSquares.put("a4", a4 = new ChessSquare("a4", 0, unit * 4, unit));
            chessSquares.put("a5", a5 = new ChessSquare("a5", 0, unit * 3, unit));
            chessSquares.put("a6", a6 = new ChessSquare("a6", 0, unit * 2, unit));
            chessSquares.put("a7", a7 = new ChessSquare("a7", 0, unit, unit));
            chessSquares.put("a8", a8 = new ChessSquare("a8", 0, 0, unit));
            chessSquares.put("b1", b1 = new ChessSquare("b1", unit, unit * 7, unit));
            chessSquares.put("b2", b2 = new ChessSquare("b2", unit, unit * 6, unit));
            chessSquares.put("b3", b3 = new ChessSquare("b3", unit, unit * 5, unit));
            chessSquares.put("b4", b4 = new ChessSquare("b4", unit, unit * 4, unit));
            chessSquares.put("b5", b5 = new ChessSquare("b5", unit, unit * 3, unit));
            chessSquares.put("b6", b6 = new ChessSquare("b6", unit, unit * 2, unit));
            chessSquares.put("b7", b7 = new ChessSquare("b7", unit, unit, unit));
            chessSquares.put("b8", b8 = new ChessSquare("b8", unit, 0, unit));
            chessSquares.put("c1", c1 = new ChessSquare("c1", unit * 2, unit * 7, unit));
            chessSquares.put("c2", c2 = new ChessSquare("c2", unit * 2, unit * 6, unit));
            chessSquares.put("c3", c3 = new ChessSquare("c3", unit * 2, unit * 5, unit));
            chessSquares.put("c4", c4 = new ChessSquare("c4", unit * 2, unit * 4, unit));
            chessSquares.put("c5", c5 = new ChessSquare("c5", unit * 2, unit * 3, unit));
            chessSquares.put("c6", c6 = new ChessSquare("c6", unit * 2, unit * 2, unit));
            chessSquares.put("c7", c7 = new ChessSquare("c7", unit * 2, unit, unit));
            chessSquares.put("c8", c8 = new ChessSquare("c8", unit * 2, 0, unit));
            chessSquares.put("d1", d1 = new ChessSquare("d1", unit * 3, unit * 7, unit));
            chessSquares.put("d2", d2 = new ChessSquare("d2", unit * 3, unit * 6, unit));
            chessSquares.put("d3", d3 = new ChessSquare("d3", unit * 3, unit * 5, unit));
            chessSquares.put("d4", d4 = new ChessSquare("d4", unit * 3, unit * 4, unit));
            chessSquares.put("d5", d5 = new ChessSquare("d5", unit * 3, unit * 3, unit));
            chessSquares.put("d6", d6 = new ChessSquare("d6", unit * 3, unit * 2, unit));
            chessSquares.put("d7", d7 = new ChessSquare("d7", unit * 3, unit, unit));
            chessSquares.put("d8", d8 = new ChessSquare("d8", unit * 3, 0, unit));
            chessSquares.put("e1", e1 = new ChessSquare("e1", unit * 4, unit * 7, unit));
            chessSquares.put("e2", e2 = new ChessSquare("e2", unit * 4, unit * 6, unit));
            chessSquares.put("e3", e3 = new ChessSquare("e3", unit * 4, unit * 5, unit));
            chessSquares.put("e4", e4 = new ChessSquare("e4", unit * 4, unit * 4, unit));
            chessSquares.put("e5", e5 = new ChessSquare("e5", unit * 4, unit * 3, unit));
            chessSquares.put("e6", e6 = new ChessSquare("e6", unit * 4, unit * 2, unit));
            chessSquares.put("e7", e7 = new ChessSquare("e7", unit * 4, unit, unit));
            chessSquares.put("e8", e8 = new ChessSquare("e8", unit * 4, 0, unit));
            chessSquares.put("f1", f1 = new ChessSquare("f1", unit * 5, unit * 7, unit));
            chessSquares.put("f2", f2 = new ChessSquare("f2", unit * 5, unit * 6, unit));
            chessSquares.put("f3", f3 = new ChessSquare("f3", unit * 5, unit * 5, unit));
            chessSquares.put("f4", f4 = new ChessSquare("f4", unit * 5, unit * 4, unit));
            chessSquares.put("f5", f5 = new ChessSquare("f5", unit * 5, unit * 3, unit));
            chessSquares.put("f6", f6 = new ChessSquare("f6", unit * 5, unit * 2, unit));
            chessSquares.put("f7", f7 = new ChessSquare("f7", unit * 5, unit, unit));
            chessSquares.put("f8", f8 = new ChessSquare("f8", unit * 5, 0, unit));
            chessSquares.put("g1", g1 = new ChessSquare("g1", unit * 6, unit * 7, unit));
            chessSquares.put("g2", g2 = new ChessSquare("g2", unit * 6, unit * 6, unit));
            chessSquares.put("g3", g3 = new ChessSquare("g3", unit * 6, unit * 5, unit));
            chessSquares.put("g4", g4 = new ChessSquare("g4", unit * 6, unit * 4, unit));
            chessSquares.put("g5", g5 = new ChessSquare("g5", unit * 6, unit * 3, unit));
            chessSquares.put("g6", g6 = new ChessSquare("g6", unit * 6, unit * 2, unit));
            chessSquares.put("g7", g7 = new ChessSquare("g7", unit * 6, unit, unit));
            chessSquares.put("g8", g8 = new ChessSquare("g8", unit * 6, 0, unit));
            chessSquares.put("h1", h1 = new ChessSquare("h1", unit * 7, unit * 7, unit));
            chessSquares.put("h2", h2 = new ChessSquare("h2", unit * 7, unit * 6, unit));
            chessSquares.put("h3", h3 = new ChessSquare("h3", unit * 7, unit * 5, unit));
            chessSquares.put("h4", h4 = new ChessSquare("h4", unit * 7, unit * 4, unit));
            chessSquares.put("h5", h5 = new ChessSquare("h5", unit * 7, unit * 3, unit));
            chessSquares.put("h6", h6 = new ChessSquare("h6", unit * 7, unit * 2, unit));
            chessSquares.put("h7", h7 = new ChessSquare("h7", unit * 7, unit, unit));
            chessSquares.put("h8", h8 = new ChessSquare("h8", unit * 7, 0, unit));
    }

    private void initPieces() {
        chessPieces.add(new ChessPiece(e1, wPawnImage));
        chessPieces.add(new ChessPiece(d1, wPawnImage));
        chessPieces.add(new ChessPiece(b1, wPawnImage));
        chessPieces.add(new ChessPiece(g1, wPawnImage));
        chessPieces.add(new ChessPiece(c1, wPawnImage));
        chessPieces.add(new ChessPiece(f1, wPawnImage));
        chessPieces.add(new ChessPiece(a1, wPawnImage));
        chessPieces.add(new ChessPiece(h1, wPawnImage));
        chessPieces.add(new ChessPiece(a2, wPawnImage));
        chessPieces.add(new ChessPiece(b2, wPawnImage));
        chessPieces.add(new ChessPiece(c2, wPawnImage));
        chessPieces.add(new ChessPiece(d2, wPawnImage));
        chessPieces.add(new ChessPiece(e2, wPawnImage));
        chessPieces.add(new ChessPiece(f2, wPawnImage));
        chessPieces.add(new ChessPiece(g2, wPawnImage));
        chessPieces.add(new ChessPiece(h2, wPawnImage));
        chessPieces.add(new ChessPiece(e8, wPawnImage));
        chessPieces.add(new ChessPiece(d8, wPawnImage));
        chessPieces.add(new ChessPiece(b8, wPawnImage));
        chessPieces.add(new ChessPiece(g8, wPawnImage));
        chessPieces.add(new ChessPiece(c8, wPawnImage));
        chessPieces.add(new ChessPiece(f8, wPawnImage));
        chessPieces.add(new ChessPiece(a8, wPawnImage));
        chessPieces.add(new ChessPiece(h8, wPawnImage));
        chessPieces.add(new ChessPiece(a7, wPawnImage));
        chessPieces.add(new ChessPiece(b7, wPawnImage));
        chessPieces.add(new ChessPiece(c7, wPawnImage));
        chessPieces.add(new ChessPiece(d7, wPawnImage));
        chessPieces.add(new ChessPiece(e7, wPawnImage));
        chessPieces.add(new ChessPiece(f7, wPawnImage));
        chessPieces.add(new ChessPiece(g7, wPawnImage));
        chessPieces.add(new ChessPiece(h7, wPawnImage));

        // add newPiece to board
        for (ChessPiece piece : chessPieces) {
            this.add(piece).setSize(unit, unit);
            piece.board = this;
        }

        this.validate();
    }
}

ChessPiece.java

import java.awt.Graphics;
import java.awt.Image;
import javax.swing.JComponent;

public class ChessPiece extends JComponent{

    public int size;
    public int offset;
    public ChessSquare position;
    public Image sprite;
    public int tempX;
    public int tempY;
    public ChessBoard board;
    
    public ChessPiece (ChessSquare position, Image image) {
        offset = size/2;
       this.position = position;
        setLocation(position.topLeftX, position.topLeftY);
        setVisible(true);
        setDoubleBuffered(true);

        sprite = image;
    }

    public void setBoard() {
        board = (ChessBoard) getParent();
    }

    @Override
    public void paintComponent(Graphics g) {
        int unitSize = board.getUnitSize();

        setLocation(position.topLeftX, position.topLeftY);
        g.drawImage(sprite, 0, 0, unitSize, unitSize, this);
    }
}

ChessSquare.java

public class ChessSquare {
    
    // declare variables
    public String position;
    public int size, topLeftX, topLeftY;
    
    public ChessSquare(String position, int topLeftX, int topLeftY,
            int size) {

        this.position = position;
        this.topLeftX = topLeftX;
        this.topLeftY = topLeftY;
        this.size = size;
    }

    public void resize(int topLeftX, int topLeftY, int size) {
        this.topLeftX = topLeftX;
        this.topLeftY = topLeftY;
        this.size = size;
    }
}

[Tyler Eastman]

Any idea's guys? I'm thinking it might be thread related, however if I spawn a new thread each time the resize event is called, won't it be flooded with duplicate threads, all doing the same thing but with different size variables? Any thoughts?
Thanks guys!

[pete stein]

Tyler Eastman wrote:Any idea's guys? I'm thinking it might be thread related, however if I spawn a new thread each time the resize event is called, won't it be flooded with duplicate threads, all doing the same thing but with different size variables? Any thoughts?
Thanks guys!

I've been looking at this, and I'm not sure, but I don't think that it's thread related, but much of the problem is that I can't see where the problem is since it is how Swing is calling your paint methods. The error occurs when the view is shrunk quickly, and when this happens, Swing doesn't paint all the components in the container (at least I'm not seeing the output from a println I have in a paintComponent displaying from all the components when this happens). As an aside, you know that you can and should simplify your code greatly by using arrays here.

[Tyler Eastman]

Thanks for your fast response Pete! I will condense the piece initialization and resize code down using arrays once I'm at my home computer tomorrow, I can see how not using them adds unnecessary bulk to the example.

[Peter Taucher]

I think I'd simply use a GridLayout, there shouldn't be painting problems at all using the 'standard' layout managers. Animations could always be drawn 'on top' (e.g. on a glasspane).

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.util.ArrayList;

import javax.imageio.ImageIO;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class FunWithChess
{
    public static void main( String[] args )
    {
        EventQueue.invokeLater( new Runnable()
        {
            public void run()
            {
                new MainGui().setVisible( true );
            }
        } );
    }
}

class MainGui extends JFrame
{
    public ChessBoard chessBoard;
    
    public MainGui()
    {
        this.setTitle( "BlackBox Chess" );
        setDefaultCloseOperation( DISPOSE_ON_CLOSE );
        chessBoard = new ChessBoard( this );
        
        add( chessBoard, BorderLayout.CENTER );
        
        setLocationRelativeTo( null );
        setSize( 600, 600 );
    }
}

class ChessBoard extends JPanel
{  
    private ChessSquare[][]         chessSquares;
    private ArrayList<ChessPiece>   chessPieces;
    public MainGui                  gui;
    private static Image            boardImage;
    private static Image            wPawnImage;
        
    public ChessBoard( MainGui gui )
    {
        try
        {
            wPawnImage = ImageIO.read( getClass().getClassLoader().getResourceAsStream( "wpawn.png" ) );
            boardImage = ImageIO.read( getClass().getClassLoader().getResourceAsStream( "board.png" ) );
        }
        catch ( Exception ex )
        {
            System.out.println( "Error loading images" );
        }
        
        chessSquares = new ChessSquare[8][8];
        chessPieces = new ArrayList<ChessPiece>();
        this.gui = gui;
        setDoubleBuffered( true );
        setLayout( new GridLayout( 0, 8 ) );
        initSquares();
        initPieces();
    }
    
    @Override
    public void paintComponent( Graphics g )
    {
        g.drawImage( boardImage, 0, 0, getWidth(), getHeight(), this );
    }
    
    private void initSquares()
    {
        for ( int i = 7; i >= 0; i-- )
        {
            for ( int j = 0; j < 8; j++ )
            {
                ChessSquare cs;
                switch( j )
                {
                    case 7: cs = new ChessSquare( "h" + (i+1) ); break;
                    case 6: cs = new ChessSquare( "g" + (i+1) ); break;
                    case 5: cs = new ChessSquare( "f" + (i+1) ); break;
                    case 4: cs = new ChessSquare( "e" + (i+1) ); break;
                    case 3: cs = new ChessSquare( "d" + (i+1) ); break;
                    case 2: cs = new ChessSquare( "c" + (i+1) ); break;
                    case 1: cs = new ChessSquare( "b" + (i+1) ); break;
                    case 0: cs = new ChessSquare( "a" + (i+1) ); break;
                    default: cs = new ChessSquare( "??" );
                }
                chessSquares[i][j] = cs;
                add( cs );
            }
        }
        
        this.validate();
    }
    
    private void initPieces()
    {
        ChessPiece piece = new ChessPiece( wPawnImage );
        chessPieces.add( piece );
        
        // TODO ... create more pieces
        
        chessSquares[0][0].setPiece( piece );
        chessSquares[0][1].setPiece( piece );
        chessSquares[0][2].setPiece( piece );
        chessSquares[0][3].setPiece( piece );
        chessSquares[0][4].setPiece( piece );
        chessSquares[0][5].setPiece( piece );
        chessSquares[0][6].setPiece( piece );
        chessSquares[0][7].setPiece( piece );
        chessSquares[1][0].setPiece( piece );
        chessSquares[1][1].setPiece( piece );
        chessSquares[1][2].setPiece( piece );
        chessSquares[1][3].setPiece( piece );
        chessSquares[1][4].setPiece( piece );
        chessSquares[1][5].setPiece( piece );
        chessSquares[1][6].setPiece( piece );
        chessSquares[1][7].setPiece( piece );
        chessSquares[6][0].setPiece( piece );
        chessSquares[6][1].setPiece( piece );
        chessSquares[6][2].setPiece( piece );
        chessSquares[6][3].setPiece( piece );
        chessSquares[6][4].setPiece( piece );
        chessSquares[6][5].setPiece( piece );
        chessSquares[6][6].setPiece( piece );
        chessSquares[6][7].setPiece( piece );
        chessSquares[7][0].setPiece( piece );
        chessSquares[7][1].setPiece( piece );
        chessSquares[7][2].setPiece( piece );
        chessSquares[7][3].setPiece( piece );
        chessSquares[7][4].setPiece( piece );
        chessSquares[7][5].setPiece( piece );
        chessSquares[7][6].setPiece( piece );
        chessSquares[7][7].setPiece( piece );
    }
}

class ChessPiece
{
    public Image sprite;
    
    public ChessPiece( Image image )
    {
        sprite = image;
    }
}

class ChessSquare extends JComponent
{  
    public String position;
    ChessPiece    piece = null;
    
    public ChessSquare( String position )
    {
        
        this.position = position;
    }
    
    public String toString()
    {
        return "[" + position + "]";
    }
    
    @Override
    public void paintComponent( Graphics g )
    {
        if ( piece != null )
        {
            g.drawImage( piece.sprite, 0, 0, getWidth(), getHeight(), this );
        }
        
        g.setFont( new Font( "Arial", Font.BOLD, 10 ) );
        g.setColor( Color.RED );
        g.drawString( position, 2, 12 );
    }
    
    public ChessPiece getPiece()
    {
        return piece;
    }
    
    public void setPiece( ChessPiece piece )
    {
        this.piece = piece;
    }
}

[Tyler Eastman]

Thank you so much Peter, your example seems to have solved the problem completely! It will require me to restructure my animation code a little bit, but after pulling my hair out for 2 weeks on the resize code, it will be a welcome change of pace!

Thank you everyone for your help, it is very appreciated!