JFrame.getInsets weird value

AdoptOpenJDK 11 on Windows 10. JFrame descendant constructor:

getGraphicsConfiguration().getBounds()
java.awt.Rectangle[x=0,y=0,width=2560,height=1440]
Toolkit.getDefaultToolkit().getScreenInsets(getGraphicsConfiguration())
java.awt.Insets[top=0,left=0,bottom=40,right=0]
set*Size(new Dimension(2560, 1400));
pack();
getSize();
java.awt.Dimension[width=2560,height=1400]
getInsets();
java.awt.Insets[top=31,left=8,bottom=8,right=8]
getContentPane().getSize()
java.awt.Dimension[width=2544,height=1361]

... and yet the window does not cover full desktop space minus the task bar (because of those extra insets of 8). Why?

Example code using my answer:

package javaapplication2;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GraphicsConfiguration;
import java.awt.Insets;
import java.awt.Rectangle;
import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.JPanel;
public final class TestFrame extends JFrame {
private static final long serialVersionUID = 1L;
private static final class CustomPanel extends JPanel {
private static final long serialVersionUID = 1L;
public CustomPanel(Dimension d) {
setMinimumSize(d);
setPreferredSize(d);
setMaximumSize(d);
//this is just an example, there is custom layout code here, not using Swing, but it needs Dimension d to work
}
}
public TestFrame() {
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER, 0, 0));
GraphicsConfiguration gc = getGraphicsConfiguration();
Rectangle screenBounds = gc.getBounds();
Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(gc);
Dimension expectedFrameSize = new Dimension(screenBounds.width - screenInsets.left - screenInsets.right, screenBounds.height - screenInsets.top - screenInsets.bottom);
setExtendedState(JFrame.MAXIMIZED_BOTH);
setVisible(true);
Dimension frameSize = getSize();
Insets frameInsets = getInsets();
setVisible(false);
Dimension contentSize = new Dimension(frameSize.width - frameInsets.left - frameInsets.right, frameSize.height - frameInsets.top - frameInsets.bottom);
getContentPane().add(new CustomPanel(contentSize));
setVisible(true);
setResizable(false);
System.out.println("screenBounds " + screenBounds);
System.out.println("screenInsets " + screenInsets);
System.out.println("expectedFrameSize " + expectedFrameSize);
System.out.println("frameSize " + frameSize);
System.out.println("frameInsets " + frameInsets);
System.out.println("contentSize " + contentSize);
System.out.println("assert expectedFrameSize == frameSize " + expectedFrameSize.equals(frameSize));
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new TestFrame().setVisible(true);
}
});
}
}

I would like to be able to calculate Dimension dimension without making the window temporarily visible. But it's impossible to arrive at correct sizes using methods available in the JDK:

getGraphicsConfiguration().getBounds()
Toolkit.getDefaultToolkit().getScreenInsets(getGraphicsConfiguration())

The insets of a frame describe size of the window decoration, which may include semi-transparent borders. On Microsoft Windows, there’s also a connection to the fact that window borders used to be 8 pixels thick in earlier versions.

When you maximize the window, its bounds will be set in a way that these insets are outside the visible areas, except for some parts of the title bar, which stays visible. To make predictability even worse, the title bar changes its layout when the window has been maximized, having less margin space.

But when you are looking for a Windows-only solution, the legacy aspects may help here. Consider the article “Why does a maximized window have the wrong window rectangle?”. As it explains, the window will always be at (-n,-n) and have (2n×2n) more than the actual visible area, for the border size n, for compatibility with old software. But, as it also explains, the maximized mode is special, as these borders are always cut off, so they do not show up in other monitors nor over the task bar.

That’s why it is impossible to emulate the same behavior by setting bounds only. Not only does the rendition of the title bar differ, you would also make parts of the window appear in other monitors on multi-monitor systems and over the task bar.

So, using that knowledge, you can predict the content pane size:

JFrame frame = new JFrame("Max");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setExtendedState(Frame.MAXIMIZED_BOTH);
Timer t = new Timer(1000, ev -> System.out.println("actual size is "
+frame.getContentPane().getWidth()+" x "+frame.getContentPane().getHeight()));
t.setRepeats(false);
t.start();
Rectangle scrBounds = frame.getGraphicsConfiguration().getBounds();
Insets scrInsets = frame.getToolkit().getScreenInsets(frame.getGraphicsConfiguration());
Insets winInsets = frame.getInsets();
int width = scrBounds.width - scrInsets.left - scrInsets.right;
int height = scrBounds.height - scrInsets.top - scrInsets.bottom
- winInsets.top + winInsets.bottom;
System.out.println("content pane size will be "+width+" x "+height);
frame.setVisible(true);

This assumes that the historical border thickness is the same for all edges, so we can use the bottom size to determine the top size with the title bar size, so top - bottom gives us the remaining title bar size.

Apparently maximized frame has size larger than actual screen, and frame insets include 8,8,8,8 pixels (on my Windows) of which some are outside actual frame. The only way to get actual frame size that is used for maximized window is to make it visible for a while. In the end I resorted to this cheat:

      setExtendedState(JFrame.MAXIMIZED_BOTH);
setVisible(true);
Dimension size = getSize();
Insets insets = getInsets();
setVisible(false);
dimension = new Dimension(size.width - insets.left - insets.right, size.height - insets.top - insets.bottom);

This allows me to find out what will be the dimension of the frame's content pane with frame taking all of desktop space (screen minus taskbar). And setResizable(false) has to be called only after final setVisible(true).

See if those numbers make sense for you:

screen bounds java.awt.Rectangle[x=0,y=0,width=2560,height=1440]

screen insets java.awt.Insets[top=0,left=0,bottom=40,right=0]

frame size java.awt.Dimension[width=2576,height=1416]

frame insets java.awt.Insets[top=31,left=8,bottom=8,right=8]

calculated dimension java.awt.Dimension[width=2560,height=1377]

Frame size is larger than screen space (screen bounds minus screen insets) by 16 in each direction. And those extra pixels are included in frame insets, even though they are not in the frame.