如果两个组件大小相同且全屏，则 JLayeredPane 不会绘制低组件

Question

JLayeredPane not painting low component if both components are same size and full screen

How software works:

JFrame <- APanel <- JLayeredPane <- (Layered subcomponents)

• My software is full screen software.
• APanel is BorderLayout component.
• JLayeredPane is BorderLayout.CENTER in APanel

Panel1 gp = new Panel1(); //Panel1 extends JPanel
gp.setSize(jlp.getSize());
jlp.add(gp);
gp.initializeDisplay(); //starts repaint() loop
jlp.setLayer(gp, 90);

Panel2 lp = new Panel2(); //Panel2 extends JPanel
lp.setSize(jlp.getSize());
lp.initializeDisplay();  //starts repaint() loop
lp.initializeComponents(); //Adds and moves components
jlp.add(lp);
jlp.setLayer(lp, 110);

When I make like this, only Panel2 is displayed. Panel1 's paintComponent() looks like this (Just draw image):

g.drawImage(myImage, 0, 0, getWidth(), getHeight(), null);

Panel2 contains a lot of buttons and labels. This method fixes the problem.

Panel1 gp = new Panel1();
gp.setSize(jlp.getSize());
jlp.add(gp);
gp.initializeDisplay();
jlp.setLayer(gp, 90);

Panel2 lp = new Panel2();
lp.setSize(jlp.getWidth() - 1, jlp.getHeight() - 1); //Changed here
lp.initializeDisplay();
lp.initializeComponents();
jlp.add(lp);
jlp.setLayer(lp, 110);

But this method causes problem again:

Dimension cs = new Dimension(jlp.getWidth() - 1, jlp.getHeight() - 1);
GrassPane gp = new GrassPane();
gp.setSize(cs);
jlp.add(gp);
gp.initializeDisplay();
jlp.setLayer(gp, 90);

LobbyPane lp = new LobbyPane(this);
lp.setSize(cs);
lp.initializeDisplay();
lp.initializeComponents();
jlp.add(lp);
jlp.setLayer(lp, 110);

Please add a comment if you need some more info such as codes.

Answer 1

When an opaque component overlaps another, it is intentional to skip painting completely obscured components. This can only become a problem, when component wrongly declared to be opaque. So when you implement your own components painting a transparent image, they should implement the isOpaque() method returning false .

Interestingly, I still could reproduce a repainting problem with transparent components using the following code:

JFrame f = new JFrame("Test");
JLayeredPane pane = f.getLayeredPane();
JButton b = new JButton("Normal Text");
b.setHorizontalTextPosition(SwingConstants.LEFT);
b.setBounds(20, 20, 300, 100);
JLabel l = new JLabel("Overlay");
l.setHorizontalTextPosition(SwingConstants.RIGHT);
l.setBorder(BorderFactory.createEmptyBorder(4, 4, 4, 4));
l.setBounds(20, 20, 300, 100);
l.setOpaque(false);
pane.add(l);
pane.add(b);
f.setSize(350, 200);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);

Here, the text “Overlay” may or may not appear initially, but as soon as one of the button's properties change (eg receiving the focus or getting clicked), the text will disappear.

The problem lies in the following property:

System.out.println(pane.isOptimizedDrawingEnabled());

will print true . And “optimized drawing” means that some of the children might not get rendered in certain situations. As the documentation says:

Returns true if this component tiles its children -- that is, if it can guarantee that the children will not overlap.

Of course, JLayeredPane will never tile the children, but stack them on top of each other and can never guaranty that they won't overlap. Still, for some reason, the Swing developers decided to implement the following logic:

private void validateOptimizedDrawing() {
    boolean layeredComponentFound = false;
    synchronized(getTreeLock()) {
        Integer layer;

        for (Component c : getComponents()) {
            layer = null;

            if(SunToolkit.isInstanceOf(c, "javax.swing.JInternalFrame") ||
                   (c instanceof JComponent &&
                    (layer = (Integer)((JComponent)c).
                                 getClientProperty(LAYER_PROPERTY)) != null))
            {
                if(layer != null && layer.equals(FRAME_CONTENT_LAYER))
                    continue;
                layeredComponentFound = true;
                break;
            }
        }
    }

    if(layeredComponentFound)
        optimizedDrawingPossible = false;
    else
        optimizedDrawingPossible = true;
}

So whenever the components are not JComponent instances or don't have the LAYER_PROPERTY property, which is always the case when using the default layer like the above example, the pane decides that optimized paint was possible, despite nothing in the actual layout logic changed.

So when we change

pane.add(l);
pane.add(b);

to

Object myLayer = JLayeredPane.DEFAULT_LAYER+1;
pane.add(l, myLayer);
pane.add(b, myLayer);

the problem will disappear, as System.out.println(pane.isOptimizedDrawingEnabled()); will print false now.

Beware of the autoboxing. When you are using pane.add(l, JLayeredPane.DEFAULT_LAYER+1); or just pane.add(l, 1); , it would call add(Component comp, int index) instead of the desired add(Component comp, Object constraints) .