Java Window Basics with JFrame

When a program opens a window, two questions come up almost immediately: how big should the window be, and where should it appear on the screen? One answer is to size the window by hand with a fixed number of pixels. That approach breaks down as soon as the contents change, because a fixed size that suits one set of components may cut off or waste space for another. This article looks at two techniques that answer both questions from inside the window's own constructor. The first is the pack() method, which sizes the window to fit what it contains. The second is a short calculation that places the window in the exact middle of the screen.

Both techniques live in the constructor, the part of a window class that runs when the window object is created. The best way to see what each line contributes is to follow the constructor step by step, so the rest of this article is organized around the order in which those lines run.

The constructor starts by passing a title to the superclass, JFrame, and then builds the contents of the window. Those setup lines come first because the window's size depends on what they add. The next line that changes the window's dimensions is the call to pack(). Once that call has run, the window has a size. The last two lines set the window's position so that it is centered on the screen. Note that the constructor does not make the window appear; that happens in a separate step covered later.

As you read the code below, ask one question at each line: does this statement decide the size, the position, or the visibility of the window? Each of those three properties is set by a different part of the code. The example is an original sketch written to show the order described in the source, not a listing from the source itself.

The statement window.pack() resizes the window so that its size matches the preferred size of its contents. The source describes this as usually the best way to set a window's size. Instead of choosing a width and height in advance, you let the components inside the window report how big they want to be, and pack() gathers those preferred sizes into the window's overall size.

Read the tree from the leaves upward. Each leaf component offers a preferred size, the panel that holds them takes those sizes into account, and the window as a whole takes its size from its contents. The diagram is an illustration of the logic in the source rather than a literal reproduction of it. The essential point is that pack() does not guess a size. It asks the contents for their preferred sizes and adopts the result.

The source states that pack() works correctly only when every component in the window has a correct preferred size, and it identifies two situations in which this is not automatic. The first is a panel used as a drawing surface, such as a panel where your code paints shapes or images. The second is a panel used as a container with a null layout manager. In both cases the system has no way to determine the correct preferred size on its own, so the programmer has to set it.

The source gives one example of setting the size by hand: calling setPreferredSize on the panel with a Dimension of 400 by 250. Once the panel reports that size, pack() can take it into account when sizing the window. In the code shown earlier, the canvas panel receives exactly this treatment before pack() is called, which is why the window is sized from that panel rather than collapsing to nothing.

After the window has its size, the constructor places it on the screen. At the end of the constructor, the window has been created, given a size, and given a position. Even so, it is not yet visible. The source makes this distinction precise: the constructor creates the window object, but the visual representation of that object has not yet been created. Making the window visible is a separate step, performed by calling setVisible(true) on the window.

Trace the diagram from left to right. The window object comes into existence, pack() gives it a size, and setLocation() gives it a position. At that point it is in the Hidden state. Only the call to setVisible(true) moves it to the Visible state. Because setVisible(true) is usually called from outside the constructor, as in the main method of the example, the window can be fully prepared before the user ever sees it.

Centering requires two numbers: the size of the screen and the size of the window. The screen size can be obtained through the default toolkit. The window's position is then set with setLocation(). The source explains that setLocation() sets the position of the upper left corner of the frame. The coordinates you pass describe where that corner should go, not where the center should go. This is why the calculation has to subtract the window's size before placing the corner.

In words: subtract the window's width and height from the screen's width and height, halve each result, and pass those two values to setLocation(). The subtraction gives the leftover space on each axis, and halving splits that leftover space equally on both sides of the window.