java - 将 JLabel 添加到 JPanel "hide"JPanel 吗？

Question

如果我在 GridLayout 中有几个 JPanel，每个 JPanel 都有一个 MouseAdapter，然后创建 JLabels(带有文本)并添加到每个 JPanel。请注意，JLabels 没有监听器。如果我渲染它并尝试单击 JPanel，或者最终尝试单击 JLabel，MouseAdapter 会将其注册为事件吗？

基本上，我希望 JPanel 注册事件，并且 JPanel 仅在 JPanel 顶部显示文本。此外，面板还有背景颜色。

如果 JLabel 确实“隐藏”了事件注册，我该如何解决这个问题？

Answer 1

顶部组件将获得鼠标点击。 JLabel 将覆盖的范围取决于其大小和 JPanel 的布局管理器。一种方法是将监听器提供给 JLabel(如上所述)，但另一种方法是如我下面所述，虽然可能不是最好的方法，但它对我来说效果很好:

1) JLayeredPane 包含所有内容，并具有一个作为 MouseListener 和 MouseMotionListener 添加的 MouseAdapter。

2) 一个名为“board”的 JPanel，它使用 GridLayout(8, 8)，其大小与添加到分层 Pane 底层的 JLayeredPane 的大小完全相同，或者更准确地说，是 JLayeredPane.DEFAULT_LAYER。

3) 这个 JPanel 在 GridLayout 中包含 64 个其他的 JPanel 小方 block (实际上这些方 block 是从 JPanel 扩展而来)，并且每个都使用 GridBagLayout。

4) 棋子是 JLabels，由 JPanel 方 block 固定。

5) 在 MouseAdapter mousePressed 方法中，我通过 e.getPoint 获取鼠标所在的点 p(如果 e 是传递给该方法的 MouseEvent 对象)。然后，我通过调用 JPanel 板上的 findComponentAt(p) 来找出哪个方 block 包含该点。然后我检查这个方 block 是否能容纳一 block 。如果是这样，则将该 block 从正方形中移除并直接添加到 JLayeredPane 的 JLayeredPane.DRAG_LAYER 中。

6) 如果棋子被放置在 JLayeredPane 的 JLayeredPane.DRAG_LAYER 中，MouseAdapter 的 mouseDragged 方法将控制棋子的位置。

7) 在 mouseRelease 上，我再次使用与上面相同的技术，使用 findComponentAt(p) 找出哪个方格保存了鼠标的位置或点，如果它是有效的方格，我从 JLayeredPane 的 JLayeredPane 中删除棋子。 DRAG_LAYER 并将其放置在正方形中。如果棋子不在棋盘上或者不是有效的方格，我会将棋子放回原来的位置。

请注意，如果板 JPanel 没有完全填充 JLayeredPane，则必须在调用 findComponentAt(p) 之前使用其在 JLayeredPane 内的偏移量来更正位置 Point, p，因为 MouseAdapter 将返回相对于 JLayeredPane 的 Points，而不是板 JPanel。

例如:

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import javax.swing.*;

public class Chess2 {
    private static void createAndShowUI() {
        JFrame frame = new JFrame("Chess 2");
        frame.getContentPane().add(new Chess2Gui().getMainComponent());
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                createAndShowUI();
            }
        });
    }
}

class Chess2Gui {
    private static final int RANKS = 8;
    private static final int FILES = 8;
    private static final Color DARK_COLOR = new Color(0, 100, 0);
    private static final Color LIGHT_COLOR = new Color(200, 200, 200);
    private static final Color DARK_PIECE_COLOR = Color.black;
    private static final int SQR_WIDTH = 80;
    private static final int PIECE_WIDTH = 60;
    private static final Dimension SQR_SIZE = new Dimension(SQR_WIDTH, SQR_WIDTH);

    private JLayeredPane mainLayeredPane = new JLayeredPane();
    private JPanel board = new JPanel(new GridLayout(RANKS, FILES));
    private JPanelSquare[][] jPanelSquareGrid = new JPanelSquare[RANKS][FILES];

    public Chess2Gui() {
        for (int rank = 0; rank < RANKS; rank++) {
            for (int file = 0; file < FILES; file++) {
                Color bkgd = DARK_COLOR;
                if (rank % 2 == file % 2) {
                    bkgd = LIGHT_COLOR;
                } 
                jPanelSquareGrid[rank][file] = new JPanelSquare(rank, file, bkgd);
                jPanelSquareGrid[rank][file].setPreferredSize(SQR_SIZE);
                board.add(jPanelSquareGrid[rank][file]);
            }
        }
        board.setSize(board.getPreferredSize());
        board.setLocation(0, 0);
        mainLayeredPane.add(board, JLayeredPane.DEFAULT_LAYER);
        mainLayeredPane.setPreferredSize(board.getPreferredSize());

        ImageIcon icon = new ImageIcon(ImageUtils2.createImage(PIECE_WIDTH, DARK_PIECE_COLOR));
        JLabel chessPiece = new JLabel(icon, SwingConstants.CENTER);

        jPanelSquareGrid[1][3].add(chessPiece);

        MyMouseAdapter mouseAdapter = new MyMouseAdapter();
        mainLayeredPane.addMouseListener(mouseAdapter);
        mainLayeredPane.addMouseMotionListener(mouseAdapter);

    }

    public JComponent getMainComponent() {
        return mainLayeredPane;
    }

    private class MyMouseAdapter extends MouseAdapter {
        private JLabel piece = null;
        private Point delta = null;
        private int oldRank = -1;
        private int oldFile = -1;

        @Override
        public void mousePressed(MouseEvent e) {
            Point p = e.getPoint();
            Component c = board.getComponentAt(p);
            for (int rank = 0; rank < jPanelSquareGrid.length; rank++) {
                for (int file = 0; file < jPanelSquareGrid[rank].length; file++) {
                    if (jPanelSquareGrid[rank][file] == c) {
                        if (jPanelSquareGrid[rank][file].getChessPiece() != null) {

                            // the jPanelSquares are derived from JPanel but have a 
                            // few of their own methods
                            piece = jPanelSquareGrid[rank][file].getChessPiece();
                            jPanelSquareGrid[rank][file].remove(piece);
                            oldRank = rank;
                            oldFile = file;
                            mainLayeredPane.add(piece, JLayeredPane.DRAG_LAYER);
                            int x = p.x - PIECE_WIDTH/2;
                            int y = p.y - PIECE_WIDTH/2;
                            piece.setLocation(x, y);

                            delta = new Point(p.x - x, p.y - y);
                            board.revalidate();
                            mainLayeredPane.repaint();
                            return;
                        }
                    }
                }
            }

            oldFile = -1;
            oldRank = -1;
        }

        @Override
        public void mouseDragged(MouseEvent e) {
            if (piece != null) {
                Point p = e.getPoint();
                int x = p.x - delta.x;
                int y = p.y - delta.y;
                piece.setLocation(x, y);
                mainLayeredPane.revalidate();
                mainLayeredPane.repaint();
            }
        }

        @Override
        public void mouseReleased(MouseEvent e) {
            if (piece != null) {
                JPanelSquare sqr = (JPanelSquare) board.getComponentAt(e.getPoint());
                mainLayeredPane.remove(piece);
                if (sqr == null || !validMove(sqr)) {
                    jPanelSquareGrid[oldRank][oldFile].add(piece);
                } else {
                    sqr.add(piece);
                }

                piece = null;
                delta = null;

                oldRank = -1;
                oldFile = -1;

                board.revalidate();
                mainLayeredPane.repaint();
            }
        }

        // just a pawn's moves
        private boolean validMove(JPanelSquare sqr) {
            int rank = sqr.getRank();
            int file = sqr.getFile();

            if (file != oldFile) {
                return false;
            }
            if (oldRank == 1 && (rank != 2 && rank != 3)) {
                return false;
            }
            if (oldRank != 1 && rank != oldRank + 1) {
                return false;
            }
            return true;
        }
    }
}

@SuppressWarnings("serial")
class JPanelSquare extends JPanel {
    private int rank;
    private int file;
    private JLabel chessPiece = null;

    public JPanelSquare(int rank, int file, Color bkgrnd) {
        this.rank = rank;
        this.file = file;
        setBackground(bkgrnd);
        setLayout(new GridBagLayout());
    }

    public int getRank() {
        return rank;
    }
    public int getFile() {
        return file;
    }

    @Override
    public Component add(Component c) {
        chessPiece = (JLabel)c;
        return super.add(c);
    }

    @Override
    public void remove(Component comp) {
        chessPiece = null;
        super.remove(comp);
    }

    public JLabel getChessPiece() {
        return chessPiece;
    }
}

class ImageUtils2 {

    public static BufferedImage createImage(int size, Color color) {
        BufferedImage img = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2 = img.createGraphics();
        g2.setColor(color);
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
                    RenderingHints.VALUE_ANTIALIAS_ON);
        g2.fillOval(size/3, 0, size/3, size/3);
        g2.fillOval(size/4, size/4, size/2, 2*size/3);
        g2.fillOval(size/6, 2*size/3, 2*size/3, size/2);
        g2.dispose();
        return img;
    }

}