Swing & AWT Overview

Early AWT

In some respects, AWT or the Abstract Windowing Toolkit was
really not ready for prime-time when Java exploded into popularity
circa 1996. AWT was designed as a peer based architecture.
AWT 'widgets' act as wrappers for native platform components.
At the time the one-to-one ratio of peer-based to native components
resulted in poor performance. This performance issue is really now
gone given the power of today's machines.

A more important problem arose from the differences between native
components on different platforms. Consistent cross platform appearance
was elusive, threatening to sink one of Java's touted claims to 'cross
platform' portability. In the early days AWT still had a fair number of
garden-variety 'bugs' that needed fixing.

IFC, Internet Foundation Classes

Netscape had built conceptually on NextStep's visual toolkit to produce
the IFC, or the Internet Foundation Classes. Sun made a deal with
Netscape, and together with Apple and IBM ported the IFC toolkit to
Java. Swing has since evolved to the point that it's relationship to the
original Internet Foundation Classes has become distant.

Swing replaced AWT's heavyweight components with a set of lightweight
components and in addition, added a large number of new components.
Today there are are over 40 components that utilize over 250 classes.

The following tutorial by the then, Magelang institute, on the Sun web site
has faithfully maintained on the web since the early days of Java and is a
useful reference that shows diagrams of the various Swing components.

Link to Tutorial that Diagrams the Swing Framework

Swing Builds On Rather Than Replaces AWT

Swing still uses AWT resources such as graphics, color management,
fonts and layout managers. Swing also uses heavyweight container for
the their initial builds. These heavy-weight classes are built as extensions
of their peer based counterparts in AWT, (namely JFrame, JWindow,
JDialog and JApplet .) Thus, Swing builds on AWT rather than relegating
it to the dust bin.

Issues Related to Mixing AWT and Swing Components

Something New In Java 6 ( Update 12 )

Before Java 6 Swing and AWT components did not mix well.
This was due to the different natures of the components. The
long and short was that AWT widgets  were peer based and
as such opaque, when sharing space with 'lightweight' peerless
Swing components. This resulted in AWT components always
appearing 'on top' of Swing components when mixed.

Time moves on and the Java developers introduced a fix for
this problem in Java 6. Now when components are mixed from
the two APIs they behave properly. A lot of textbooks will need
revision!

To reiterate, before JDK 1.6, The problem with mixing AWT heavyweight
widgets and Swing lightweight controls comes from the fact that all AWT
component, based on native widgets, are 'opaque'. That is they are
not transparent.

Swing components are by nature lightweight and 'transparent' (at least
relative to a heavyweight component). The result is that if a Swing
component is layered on top of an AWT component, the AWT component
appears to be on top of the Swing component.

Z-order  // high order, think 'on top of'

'Z Order' (sometimes called  'zorder'  or z-order ) is a term that
represents the layering depth at which components appear with
respect to other components in the same container.

Think of a deck of cards. Each card has a different z-order
value. This 'z'  is similar to one used in 3-D Cartesian graphs.

The first component added to a container takes the highest z-order
value and appears at the top of the stack. The last component added
adopts the lowest 'z-order' number value and is placed at the bottom
of the stack.

Diagram depicting the relationship between component adding and z-ordering

Z-order values are not published as being accessible so they only
provide us with a theoretical description of how elements are layered
using z-order values.

The following code, before JDK 1.6, use to illuminates the idea of z-order
as well as mixing light and heavyweight components. You will need to use
a JRE from JDK 1.5 to make the code work as first intended. Where the
AWT components do not layer sequentially with the Swing components. 

Z-Order and Mixing Light and Heavyweight Components

With respect to components of the same type, AWT or  Swing, z-order
is respected, however AWT components will always appear to have
a higher z-order value than a lightweight Swing component when the
two types are mixed.

There were a set of suggestions provided by Dave Geary which are
explained at length in his book, 'Graphics Java'. While perhaps no
longer needed, the guidelines would apply for backwards compatibility
and perhaps still should still be followed, if you are in a situation where
you have to work with both sorts of components in a single GUI.
The suggestions are paraphrased below.

Dave Geary's Suggestions When Mixing Heavy & Light
Components  ( Applying to Java version JDK 1.6 Update 12 )

A more general rule, avoid mixing AWT and Swing! Even with
JDK 1.6 this suggestion is probably still a good idea to heed. 

Swing Component Overview

The Swing components are a big improvement on AWT
components for a number of reasons. Swing allows
the creation of sophisticated GUI features such as the
ability to add icons to components, to set 'tool tips' that
respond to mouse-overs, to drag and drop items and to
add layered pop-up menus and dialog boxes into GUIs.

New Features That Come with Swing

• add icons to components
• set tool tips that respond to 'mouse-overs'
  
• provides drag & drop
  
• provides layered pop-up menus & dialog boxes
  

In addition to creating a new set of J-prefixed Swing
components to replace each of the peer-based AWT
components,  the Swing library adds a number of new
Swing components to extend the capabilities of Java
graphical user interfaces.

//  ( J + AWT ) components  + new Swing Components

The numerous Swing components are in general easy to
use. They can be classified by a number of schemes. The
component hierarchy itself supplies the most logical system
of organizing these components.

Text, Button, Panel and Container Components

We find in Swing and AWT, there is a group of visual components
that work with text. These all descend from JTextComponent.
There is another group of controls based on the button theme
which have the parent, AbstractButton. Another set is based
on the panel concept. There is also a group of container classes
that share a common ancestry.

Complex Components

A few complex components are unique and 'stand-alones'.
Components such as JList, JTree and JTable are quite
complex and deserve to be singled out and treated  with
special attention. There are also a number of components
that are one-of-a kind and do not fit into a group. For instance
JLabel, which has the job of labeling GUIs. There really only
needed to be one of these.

A classification can be made of components that are used
across the board. For instance borders and icons are used
by all  components. We can treat these kinds of components
as a group in their own rite.

Classifying Swing Components

• Trans-Class Components // i.e Border & Icon
  
• One of a Kind // JLabel, JProgressBar
  
• Base Components // peer based i.e JFrame JApplet
  
• Text Components  // JTextArea
  
• Button Components // JButton
  
• Panel Components  // JPanel
  
• Complex Components // i.e. JTree JTable JList

Commonly Shared Elements, Borders & Icons

'Trans-Class' Components

Components such as borders, icons and tooltips may
be used by all the Swing components. Consider the
tooltip class.

Tooltips

A tooltip is a short pop-up text which appears over top
of a GUI when the mouse wands over a component.
There is a JToolTip class, however, for convenience a
method called setToolTipText( ) has been added to
JComponent. This component enables a tooltip to be
easily added for any visual component.

Example   

JButton myButton = new JButton("Accept");
myButton.setToolTipText ("Press to confirms the purchase");
 

Icon & ImageIcon

Icons are miniature pictures that can be embedded in
components. They are Java Image class objects that
have been processed in a way that binds them to the
component. The component can be serialized and sent
down a wire and the image will go with it and not need
special classes to reconstitute it as an ordinary Image
object requires.

// image element will serialize with the component

Icons can be added in a similar manner to all Swing
components. Icon is an interface that defines three
methods. By supplying implementations for these three
methods, a custom graphic can be created and applied
to the Swing components you deploy.

Here you see again an example of an interface. We
discussed interfaces in the previous note.
 

The Icon interface Definition

public interface Icon {
      void paintIcon(
          Component c, Graphics g, int x, int y);
          int getIconWidth( );
          int getIconHeight( );
          }

Because most images a designer uses in a Swing GUI
will be GIF (.gif ), PNG, (.png) or JPEG ( .jpg )  files, the
Swing developers have supplied a default implementation
of the Icon interface, the class, ImageIcon.

ImageIcon has several constructors allowing an image to
be supplied as a file, an array or a URL. The class is usually
declared to the type of the Icon interface.

// png files are also now supported, sometimes at or before JDK 1.6

Example         

Icon miniature = new ImageIcon("AuntSarahLee.jpg");

// ImageIcon constructors may receive files, arrays or URLs.

 
Another example shows a Hubble telescope shot of the
'Bug Nebula' inserted as an icon.

Example 2     

ImageIcon icon = new ImageIcon("images/bugnebula.jpg");
JLabel label2= new JLabel(icon); 

We see shortly how easy it is to set this icon into a visual
component.

We can include a custom implementation of Icon here,
just to get some complete Java code into the discussion.
( Apologies, this is not art! ).

Example of a Custom Implementation of the  Icon Interface

// for the moment use Ctrl-C to exit DOS Process

import javax.swing.*;
import java.awt.*;

// a class that implements the Icon Interface

class SimpleIcon implements Icon{
       public int getIconWidth( ){
            return 20;             }
       public int getIconHeight( ){
            return 20;
            }
      
 public void paintIcon(Component c, Graphics g, int x, int y){
      
        g.setColor(Color.red);
        g.fillRect(10,10,30,10);
        g.setColor(Color.gray);
        g.fillRect(20,22,10,16);
        g.setColor(Color.red);
        g.fillRect(10,40,30,10);
      }
   }

// a 'runner' class that that shows a JLabel including the Icon object

class IconShow extends JFrame{

       IconShow( ){
          Icon icon = new SimpleIcon();
          JLabel label = new JLabel
          ("Simple Icon In a JLabel", icon, SwingConstants.CENTER);
          JFrame frame = new JFrame();
          getContentPane().add(label);
          setSize(200,200);
          setVisible(true);
          }
    public static void main(String[]args){
         new IconShow();
         }
   }
 

Borders

Swing components have borders that can be set to factory
default values or can be customized in a way similar to the
example shown for the Icon interface. Borders are supplied
to components via the Border interface. Border interface
defines a number of methods specifically designed to draw
borders on components. The tools for customizing borders
are housed in the javax.swing.border package. The package
stores several classes that implement the Border interface in
different ways to provide stock choices to the designer.
Following is the Border interface and the three methods
it defines.

// Border interface, javax.swing.border package
 

The Border interface

interface Border
           {
           public Insets getBorderInsets(Component c)
           public boolean isBorderOpaque( )
           public void paintBorder (Component c, Graphics g, int x,
           int y, int width, int height )
           }

The paintBorder method paints the component's border with
the specified border and size. The getBorderInsets method
returns the insets for the 'drawable' area of the component
supplied. The isBorder method returns a boolean to indicate
whether the border area is opaque or transparent.
 

The Border Package

AbstactBorder
      |___BevelBorder
      |       |___ SoftBevelBorder
      |
      |______CompoundBorder
      |
      |______EmptyBorder
      |          |____ MatteBorder
      |
      |______EtchedBorder
      |______LineBorder
      |______TitledBorder
 

// the convenience method setBorder( ) makes applying borders easy

JComponent Implements Border

JComponent implements Border so all of it's subclasses
inherit the same border behavior. JComponent also defines
the setBorder( ) method for conveniently changing the
default border to another border selection. Swing defines
the parent AbstractBorder that you can use to implement
custom borders as well as eight preset descendants the
programmer can use for 'off the shelf' effects.

// 8 presets plus one abstract parent usable for custom borders
// presets can also be extended

Creating Borders Using BorderFactory

There are a few approaches that can be taken to create
borders. One method uses the createXXXBorder( ) methods
of the BorderFactory class. This class is stored in javax.swing
unlike the border classes listed below which are in the
javax.swing.border package. BorderFactory can create
different border types via static methods named after each
of the predefined Border class.
 

Example  

Border border =
BorderFactory.createEtchedBorder(Color.gray, Color.white);
JButton jb= new JButton("Button");
jb.setBorder(border);

This is a convenient technique for defining a border once
and then easily adding it to other components in a GUI.
The different pre-defined Border classes are listed below.
 
 
 

//  EmptyBorder to adding Space around a component

Creating Borders By Instantiating the Border Classes

The examples below show a different approach where Border
classes are instantiated and applied to JButton components.


Border Examples

MatteBorder Example          Icon ike=new ImageIcon("images/PLAY1.jpg");
                                            JButton b1=new JButton("PLAY");
                                             b1.setBorder( new MatteBorder( 5 , 15 , 5 , 15 , ike) );
                                             //  insets top, left, bottom, right and a tile icon

EtchedBorder Example        JButton b2=new JButton(" Next ");
                                            b2.setBorder( new EtchedBorder(Color.white, Color.gray) );
                                            // highlight and shadow colors

LineBorderExample            JButton b3=new JButton(" Next ");
                                            b3.setForeground(Color.red);
                                            b3.setBorder( new LineBorder(new Color(250,240,230), 2, true) );
                                            // constructor that takes color, thickness, and rounded corners

SoftBevelBorder Example   JButton b4=new JButton(" Next ");
                                            b4.setForeground(Color.magenta);
                                            b4.setBorder(new SoftBevelBorder(SoftBevelBorder.RAISED,
                                            new Color(200,100,50), new Color(200,55,77)));
                                            // bevel type, highlight and shadow colors

TitledBorder Example          JButton b5=new JButton();
                                             b5.setForeground(Color.white);
                                             b5.setBorder(
                                             new TitledBorder(new LineBorder(Color.yellow),
                                             "SKIP"));
                                          // This shows the default arrangement. Constants can be
                                          // added to relocate the position of the text in the line

The following applet demonstrates these border variations.
Note that Matte was left out. This is because of security
restrictions at the college where Applets are restricted from
reading outside files. Here it would be a jpg file. ( Try Matte
at home where It should work fine. Also , if at the school
you can also import an image file and run the applet locally. )

//  There are techniques for downloading the applet and image in a Jar file
// so the image is not treated as remote which should get around the firewall.

Applet Demonstrating Border Variations
 

Common Components

JLabel

The first component we look at is JLabel. JLabel allows
a developer to label the various parts of a GUI. ( In AWT,
the counterpart was called by the simpler name, 'Label'.)

Swing goes beyond AWT in permitting the miniature pictures
called icons to be added to components like label. This
allows the possibility of using images rather than words to
indicate a control's function. (Think of the arrows on a DVD
player.) Swing allows text and icons to be positioned in
different locations relative to each other inside a component. 

There is not a lot more to be said about JLabel, but we
can use JLabel as an example to discuss adding icons. It
is appropriate to do this early in the talk as what applies
to JLabel also applies to the other Swing components, all
of which also can have icons applied.

// set icons via the constructor or using the setIcon( ) method

Icon Setting and Positioning

Icons may be added via a components constructor or after
construction using the component's method, setIcon( ).
The default locations of the icons and text can be changed
using positioning methods discussed below. In the table
below, the constructors of JLabel are shown in their different
overloaded forms. These variations can be used to add and
position text and icons in a label.

// JLabel's background is transparent by default

Swing's JLabel is Transparent

Also if you had trouble setting the background color of the JLabel
this is because of a little advertised fact that it has a transparency
factor that by default is set to transparent. (AWT's Label class
wasn't transparent. You would set background color to match the
GUI.)

Transparency is a good idea for labels as typically you don't want
to see the label's rectangle. To change a JLabel's background so
that a background color setting is visible, call it's method,
setOpaque( boolean) and set it's boolean argument to true.

Example  

JLabel label=new
JLabel("JLabel's background is transparent by default");
label.setOpaque(true);
label.setBackground(new Color(77,99,133));

JLabel Constructors
 

In the following example, the layout is set to a grid layout. We will see
later this forces the label to occupy the whole area of the panel. This
was done just to increase the area that the JLabel occupied so the
effects of positioning could be observed. JLabel.RIGHT constant
moves both the icon and text as a group to the right margin of the
label.  ( You will have to supply your own JPG  file. )
 

Example

// reminder to include imports

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

        class Pic extends JPanel{
             Pic( ){
             setLayout(new GridLayout(1,1));
             Icon goPix = new ImageIcon("balloon.jpg");
             JLabel label=new JLabel("Balloon", goPix, JLabel.RIGHT );
             add(label);
             }

// this code needs a  main( ) method to run

The Magelang Institute's Swing tutorial on the Sun site uses
a nice technique of building examples inside JPanel extension
classes as in the example above. These panels then can easily
be instantiated in a Frame class like in the following example.
 

Example 

 class JTour extends JFrame{
    JTour( ){
       Pic p=new Pic( );

// getContentPane(). setLayout(new FlowLayout());
// use to add more then one display element at a time

       getContentPane( ).add(p);
       setSize(400,300);
       setVisible(true);
      setDefaultCloseOperation(EXIT_ON_CLOSE);
       }
 
public static void main(String [] args){
 new JTour( );
 }
}

Positioning Methods

The positioning methods take constants that are statically
defined in a repository called the SwingConstants class.
The methods used for positioning in the horizontal take LEFT,
 RIGHT and CENTER with CENTER being the default  value.
The methods used for vertical positioning take the constants
TOP BOTTOM or CENTER with CENTER being default.
These constants are referenced via the class name using
the dot operator.

Example         

SwingConstants.BOTTOM
 

The setHorizontalAlignment( ) & setVerticalAlignment( ) Methods

These methods set the contents as a group, whether icon, text
or both, to the left center or right in the horizontal and to the top,
center or bottom in the vertical in the space that is defined by the
label. Notice, in some conditions setting these values will not
have an effect as the contents are already occupying all the
space that is available in the component and there is no where
to go. This will happen with text and icons in labels that have
been added to a flow layout where components are allowed to
occupy a minimal, preferred size.

// sets the position of the group within component can't observe the effect
// if the space or layout policy won't permit it

The setVerticalTextPosition( ) & setHorizontalTextPosition( ) Methods

These methods set the text position relative to the Icon. By combining
the constants in the horizontal and vertical the text can be put in 9
positions relative to the icon. At the top above the image, left right
and center. In the center, left, right and center where the text is
centered on the icon and at the bottom, underneath the image, left,
right and center.

// sets text relative to icon
// for the assignment below just use these methods

The following code shows both sets of methods. The alignment
methods that set the whole group have a an alternate set of lines
commented out. If you change which lines are commented, you will
see the whole groups moment is controlled by these methods. The
relative position of text and icon though remain the same.

Example

JPanel  // implements double buffering, flow layout by default

Another simple and widely used component is JPanel. It is
an all-purpose sub-container to build sub-sections for GUIs. 
It supports double buffering which improves the quality of
painting operations that might occur on it's surfaces.

JPanels constructors allow specifying whether the double
buffering feature is turned on and which layout manager the
JPanel will use.  ( Double buffering is used for smooth image
display.)

// a JPanel depends on a container to be shown on screen

JPanel Aspects

By default JPanel has a flow layout. You might have expected it
to be grouped with the Container components but it really is in
it's own inheritance branch, being a sub-class of JComponent.
It is not like the major container components as it cannot be
realized on the screen without first being added to a base
container like JFrame.

// can't appear on it's own

JPanel Hierarchy

java.lang.Object
   |
  +--java.awt.Component
         |
        +--java.awt.Container
               |
              +--javax.swing.JComponent
                     |
                    +--javax.swing.JPanel  

JSeparator  // a speciality component usually used with menus

JSeparator is typically used to add a spacer bar between
elements of menus and probably more is more aptly placed
with that topic. On the other hand it is an accessory component
that can be used just about anywhere.  In menus and toolbars,
the separator can be added with the addSeparator( ) method.
To add in other locations a JSeparator object is instantiated.

Example Showing a Non-typical Use of JSeparator

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

class Separator{
public static void main(String[]args){
JFrame frame = new JFrame();


JPanel pan=new JPanel();
pan.setLayout(new GridLayout(3,1));
JLabel over =new JLabel("Over Separator");
pan.add(over);
JSeparator s=new JSeparator(SwingConstants.HORIZONTAL );
pan.add(s);
frame.getContentPane().add(pan);
frame.setSize(450,150);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
 

The Container Classes

Swing Containers Build On AWT Counterparts

Container classes are like the foundation in a building.
Everything is built on them. Given that neither the simplest
or most complex GUI can be presented on screen without
one of these container types, it is an a very important set
of classes to look at. 

The Container component are subclasses of AWT and
as such are called heavy-weight, peer-based and opaque
components. The container classes are heavy-weight in
that they use the native resources of the operating system
to render themselves visually on screen.

The four component, JFrame, JDialog, JWindow, and
JApplet are the only heavyweight containers in the Swing
library. Other JComponents are painted on the surface of
these components and don't need to make appeals to
native counterparts for their existence. For this reason,
the other JComponents are called light-weight
components.

The Four Heavy Weight Components of the Swing Package

• JFrame
• JDialog
• JWindow
• JApplet

Look at the Container Hierarchy and it is evident that heavy-
weight components are directly subclassed from AWT's
Window class. JWindow descends from Window. JFrame
descends from Frame which in turn descends from Window.
The other type of heavyweight components described in
the tree are the JDialog and FileDialog classes.

An Applet is also a container class. However, it has a unique
place in the component hierarchy, (probably due to it's early
invention in the history of Java.) Applet and JApplet are quite
unique and are treated as separate topics.
 
The fact that these heavyweight components are based on
AWT components is one of a number of reasons that we
should think of Swing as 'building on' rather than replacing
AWT.

The Swing Container Component Hierarchy Depends on AWT

    Object
         |
Component
         |
 Container
         |
  Window
         |
         |____JWindow
         |
         |____ Frame
         |              |____ JFrame
         |
         |____Dialog
                         |___JDialog
                         |___FileDialog

Applet Hierarchy     

Object
     |
Component
     |
Container
     |
 Panel
     |
 Applet
     |
JApplet


// Component, Container and Panel are in the java.awt package, 
// Applet is in  java.applet, and JApplet is in javax.swing

JFrame

Differences Between Frames

If you instantiate JWindow the first thing you will notice it
doesn't have a top bar that permits adding an external
label to the frame nor does it have controls to close,
shrink or iconify the window. AWT's Frame is a descendant
of Window and adds these specialized features. Keep in
mind that you may wish to use the uncluttered look of
Window and JWindow to do more graphically oriented
presentations.

// JFrame extends Window and adds  label bar and
// closing & iconifying controls

JFrame goes on to differentiate from AWT's Frame class
by providing a sophisticated layered structure made up
of different container objects that enable features like
drag and drop, tooltips and pop-up menus to be added.

Two JFrame Variations  

JFrame variations are the practical beginning of building
GUIs that run at the command line. JFrame is the common
base window that Java uses to build GUIs. It can be used
in a variety of ways. 

In the following example JFrame is instantiated inside a
regular Java class.
 

Example of a Frame Created using Composition

import javax.swing.*;
import java.awt.*;

public class FrameTester {
      public static void main (String args[]) {
             JFrame f = new JFrame ("A Frame Created Inside a Class");
             Container c = f.getContentPane( ); 
             c.add (new JLabel ("A Label in a Frame "));
              f.setSize (300, 70);
             f.setVisible(true);
                   }
              }

In the above example there is no constructor and everything
is done inside main(  ). A constructor could have been used
like the following example.

In the next example a JFrame class is created as an extension
of JFrame.

Example of a Frame Creation Based on Inheritance

import javax.swing.*;
import java.awt.*;

 public class FrameTester extends JFrame {
                       FrameTester(String s ){
                          // call to super to invoke label handling constructor
                          super(s);
                          JLabel jl= new JLabel(" A class extending JFrame");
                         getContentPane( ).add (jl);
                         setSize(300,70);
                         setVisible(true);
                         }
                      public static void main (String args[]) {
                         new FrameTester("A class extending JFrame" );
                         }
                  }

Base Requirements

While each of these examples have different features, both show
that JFrame requires having it's size set and must be made visible,
using the setSize( ) and setVisible( ) methods. The setVisible( ) can
be replaced with the older show( ) method.

 Have to Have Methods

• setSize( )
• setVisible( )  
  

The Deprecated show( ) Method

The show( ) method of Component class was deprecated a long
time ago ( JDK1.1 ) but it still alive and well. Being deprecated is
never fatal it seems. Deprecation is like a sentence that is infinitely
commuted!

The Java designers would rather you use the setVisible( ) method,
using the JavaBean 'get / set' form that treats visibility as a property
and clearly describes what the method is doing.

// show( ) and hide( ) has been replaced by setVisible( ) 

Both examples show the getContentPane( ) method being used.
In one case a the ContentPane object is returned to a Container
reference and in the other case the add call is made right off the
getContentPane( ) method.

Notice as well in the example with the Constructor, the constructor
form of super( ) is called to invoke the parent's constructor of the
form that takes a String to label the top bar of the frame.

A final point to observe, notice methods in the constructor are not
prefixed with a reference. The reference that is implicitly supplied
is this.

Example   

this.getContentPane( ).add(component);

Summary of Key Features Using JFrame

• extend JFrame of some other container
• include swing and awt imports
• setSize( )  and setVisible( ), // set Closing Operation
  
• with Swing add sub-units to content Pane // getContentPane( )
  

JFrame Structure

With old AWT's Frame a call to getContentPane( ) was
not necessary as there was no ContentPane to call. With
JFrame, for a long time this call was necessary as the
internal composition of the newer JFrame is composed of
several sub-components. The same is true for the other
heavyweight components. The four heavy weight components,
JFrame, JApplet, JWindow and JDialog along with a fifth
component, JInternalFrame all implement the
RootPaneContainer interface.

The result is each of these components have a set of
methods that return the different panes associated with
JRootPane. (i.e getContentPane( )  returns the content
pane, getGlassPane( )  returns the glass pane. )

New in JDK 1.5, 'Old Habits Die Hard'

It seems that old habits die hard, and in JDK 1.5 plain add( )
was revived, in a form that hides the call to getContentPane( ).

Example

getContentPane( ).add (jl);

// becomes just

add(jl);

It is probably good form to retain the call to getContentPane( )
to  communicate clearly the component that is being called.

JRootPane  // lower-case i.e. glassPane, used in J2SDK docs 

Following is a diagram of the hierarchical arrangement of
JRootPane.

Diagram of the JRootPane Hierarchy

JRootPane
        |___glassPane
        |___layeredPane
                       |___jmenubar [ optional ]
                       |___contentPane

The glassPane is transparent and as such is not visible.
It is located on top of everything, where it can intercept
mouse events in association with actions like displaying
tooltips.

The menubar is an optional component. If added it will appear
at the top edge of the frame. Notice because it has it's own
place in the root pane structure a call to getContentPane(  )
is not necessary to add a menubar. We see later menubars
are set using the setMenuBar( ) method.

For a time any child classes added to the structure would
be added via the content pane with add methods. Now the
following examples may be simplified as was shown above.

Example     

getContentPane( ).add(child_component);

// the same is true for adding layout managers
.

Example   

getContentPane().setLayout(new GridLayout( 3, 2));
 

JLayeredPane  // layers details primarily for reference

It is early in the course to worry about layers. For the now we
just survey some of it's architectural features so what possibilities
there are become apparent. 

JLayeredPane is the parent class of all children in the JRootPane
other than it's sibling, glassPane. The class allows components
to be located at different depths in the container by placing them
in different layers. 

JLayeredPane Constants are Stored as Integer Wrapper Objects

The default layer is represented by the constant value,
JLayeredPane.DEFAULT_LAYER. Unlike other constants,
these layers are referenced via static instances of the
Integer wrapper class. This is a nice example of the use
of wrapper classes in use. 

JMenuBar and the contentPane are each added to the
JLayeredPane object at the layer represented by the
JLayeredPane.FRAME_CONTENT_LAYER constant.
This capability is used to allow menu pop-ups, dialog
boxes, and dragging and dropping to occur at appropriate
visual layers.

The set of convenience layers defined by by the following
table of constants, each representing a static Integer object.
(If you print to console one of these constants the toString( )
method is automatically called and the contents of the
wrapper class is rendered to screen.)
 
 

// JLayeredPane.FRAME_CONTENT_LAYER has a value of -30000.
// Seems the designers really want to leave some room for layers!
// this is counting by 100s so that leaves room for 300 sub-layers.

JLayeredPane Methods // add components to layers

JLayeredPane manages it's set of components like other containers
with the added feature of allowing layers to be defined within itself.
Components in higher layers are painted over objects placed in
lower layers. Each layer is represented by a distinct integer. This
number can be passed in to an add method via the Integer wrapper
class to set the layer an object will be added to. Java documentation
shows the following two examples.

Example   

layeredPaneObject.add(labelObject, JLayeredPane.PALETTE_LAYER);

The Integer wrapper class can be used to create an equivalent
expression.

Example

JLabel label=new JLabel("layered label");
JLayeredPane pane=this.getLayeredPane( );
pane.add(label, new Integer(100));

JLayeredPane also has methods to reposition a component inside
it's layer and to set the layer or the layer and position of a component.

Layering  Example

A complicated but interesting demonstration of layers can be
found at the following site. This demo uses a loop to set up
layers at different levels. The layout layers are each designated
with graphics entered using the setBounds( ) methods. Then
an image takes it's cue from listings in a combo box to decide
which layer to show up under. This example is ahead of where
we are as it uses event handling. Interesting is the use of a
MouseMotion Listener that is inlined as an anonymous inner
class.

Layering Example

http://www.lkn.ei.tum.de/arbeiten/faq/man/JAVA-tutorial/ui/swingComponents/layeredpane.html

Close Operations    // as of JDK ~ 1.4.x

JFrame defines a setDefaultCloseOperation( ) method. Supplying
constants defined in the WindowsConstants class will cause the
Frame to do nothing on when the close button is clicked, to hide
the frame when the button is activated or to hide and dispose the
frame.

These constants are

• DO_NOTHING_ON_CLOSE
• HIDE_ON_CLOSE
• DISPOSE_ON_CLOSE
• EXIT_ON_CLOSE
  

The first three constants do not cause the application to exit and
close the command line session. EXIT_ON_CLOSE will close
the dispose of the Window and close the DOS session.

The New Effective Way to Close a Frame // as of ~JDK 1.4

Example    // inside a JFrame constructor

setDefaultCloseOperation(EXIT_ON_CLOSE); 

Notice this example presumes you are in a JFrame constructor.
If you build a frame outside a constructor via an instantiation the
form will be something like the following example.


Example

 
// Something you don't have to worry about. In earlier versions of Java,
// pre- 1.4, DISPOSE_ON_CLOSE would hide and free resources associated
// with visual components but would not close the System process. (The
// command line remained running.) This required an additional call
// System.exit( ) in a windowClosed( ) method. Fortunately, setDefaultCloseOperation( )
// closes everything out so we no longer have to be concerned about this issue.

Self Test                                                      Self Test With Answers

1) Which of following features was not only a Swing feature but also available in AWT.

a) add icons
b) set tooltips
c) change layout managers
d) layer pop-up menus

2) Like Icon, the Border interface has three methods. Which of the following is not a
    Border interface method.

a) getBorderInsets( )
b) isBorderOpaque( )
c) setBorderInsets( )
d) paintBorder ( )

3) Pick the incorrect statement?

a ) Borders can be customized by extending AbstractBorder
b) JComponent provides the setBorder method
c) Swing defines six preset border classes.
d) JComponent implements the Border interface
 

4 ) Select the incorrect statement regarding JLabel.

a) An icon can be set in a JLabel using setIcon( ).
b) The background of a label by default is transparent.
c) Set methods can be used to position text relative to icon in 6 different ways.
d) horizontal and vertical alignment methods can set the relative position of the
    text and icon as a group.
 

5) Which of the following statements is not true regarding JPanel?
a) JPanel's default layout manager is flow layout.
b) Like JFrame,  JPanel can be made visible to screen without
    being added to another container.
c) JPanel descends directly from  JComponent.
d) JPanel supports double buffering?

6 )  Only one of the following components is considered heavyweight? Which is it?

a) JPanel
b) JComponent
c) JDialog
d) JLabel

7) True or False.

If AWT and Swing Components are mixed  in the same GUI a compiler error results.  _____

8) True or False

Peer-based means a corresponding component is built on the underlying system  ____
 

Exercise

1) Create a panel inside a JFrame.

2) Set the panel's layout to a 3 by 3 grid.

// We cover layout managers separately. For now modify
// this line found in the code sample in the note to the
// following form

Example

setLayout(new GridLayout(3,3));

3) Find an image on the web that can be iconified. Using 
the methods, setVerticalTextPosition( ) and
setHorizontalTextPosition( ) methods create 9 labels with
the icon and text. Show all the ways that text can be
positioned relative to the icon.

// get rid of the alignment methods in the example in the note
// these are not involved with this exercise

4) Add a tooltip for each label indicating the positioning
strategy adopted in each label.

5) Use the  setDefaultCloseOperation(EXIT_ON_CLOSE)
method to provide a closing mechanism for the frame.

6) Change the borders on the components to two different
border variations. In one case use BorderFactory methods.
In the second case use an instantiation of a Border class.