Chapter 1 swings

The Origins of Swing
Swing did not exist in the early days of Java. Rather, it
was a response to deficiencies present In Java’s original
GUI subsystem the Abstract Window Toolkit.
The AWT defines a basic set of controls, windows, and
dialog boxes that support a usable, but limited graphical
interface.
One reason for the limited nature of the AWT is that it
translates its various visual components into their
corresponding, platform-specific equivalents, or peers.
This means that the look and feel of a component is
defined by the platform, not by Java

DRAWBACK OF AWT
• Because of variations between operating
systems, a component might look, or even
act, differently on different platforms.
• The look and feel of each component was
fixed (because it is defined by the platform)
and could not be (easily) changed.
• The use of heavyweight components caused
some frustrating restrictions

SWING
 Swing. Introduced in 1997, Swing was
included as part of the Java Foundation
Classes (JFC).
 Swing was initially available for use
with Java 1.1 as a separate library.
 However, beginning with Java 1.2,
Swing (and the rest of the JFC) was
fully integrated into Java.

 Swing is a set of classes that provides
more powerful and flexible GUI
components than does the AWT.
 Swing provides the look and feel of
the modern Java GUI.
Definition of SWING

Swing Is Built on the AWT
 Swing eliminates a number of the limitations
inherent in the AWT, Swing does not replace it.
 Instead, Swing is built on the foundation of the
AWT. This is why the AWT is still a crucial part of
Java.

Two Key Swing Features
 Swing Components Are Lightweight
 Swing Supports a Pluggable Look and Feel

Swing Components Are Lightweight
 This means that they are written entirely in Java and
do not map directly to platform-specific peers.
 Lightweight components are more efficient and more
flexible.
 Lightweight components do not translate into native
peers, the look and feel of each component is
determined by Swing, not by the underlying operating
system.
 This means that each component will work in a
consistent manner across all platforms.

Swing Supports a Pluggable Look and Feel
 Swing supports a pluggable look and feel (PLAF). Because
each Swing component is rendered by Java code rather than by
native peers, the look and feel of a component is under the
control of Swing.
 This fact means that it is possible to separate the look and feel
of a component from the logic of the component, and this is
what Swing does.
 In other words, it is possible to “plug in” a new look and feel for
any given component without creating any side effects in the
code that uses that component. Moreover, it becomes possible
to define entire sets of look-and-feels that represent different
GUI styles.
 To use a specific style, its look and feel is simply “plugged in.”
Once this is done, all components are automatically rendered
using that style

Model View Controller (MVC) Connection
 A visual component is a composite of three
distinct aspects:
 The way that the component looks when
rendered on the screen
 The way that the component reacts to the
user
 The state information associated with the
component

 The MVC architecture is successful because each piece of the
design corresponds to an aspect of a component.
 In MVC terminology, the model corresponds to the state
information associated with the component. For example, in the
case of a check box, the model contains a field that indicates if
the box is checked or unchecked.
 The view determines how the component is displayed on the
screen, including any aspects of the view that are affected by the
current state of the model.
 The controller determines how the component reacts to the user.
For example, when the user clicks a check box, the controller
reacts by changing the model to reflect the user’s choice
(checked or unchecked).
Model View Controller (MVC) Connection

 Swing uses a modified version of MVC that
combines the view and the controller into a
single logical entity called the UI delegate.
 For this reason, Swing’s approach is called
either the Model-Delegate architecture or the
Separable Model architecture.
 Swing’s pluggable look and feel is made
possible by its Model-Delegate architecture.
Because the view (look) and controller (feel)
are separate from the model, the look and
feel can be changed without affecting how
the component is used within a program.

Swing components contain two objects.
 The first represents the model.
 The second represents the UI delegate.
Models are defined by interfaces. For example, the
model for a button is defined by the ButtonModel
interface.
UI delegates are classes that inherit ComponentUI.
For example, the UI delegate for a button is ButtonUI.
Normally, your programs will not interact directly with
the UI delegate.

Components and Containers
 A Swing GUI consists of two key items: components and
containers.
Difference between components and containers.
Component Container
component is an independent
visual control, such as a push
button or slider.
A container holds a group of components.
Thus, a container is a special type of
component that is designed to hold other
Components
All Swing GUIs will have at least one container. Because containers
are components, a container can also hold other containers. This
enables Swing to define what is called a containment hierarchy

Components
 Swing components are derived from the JComponent class.
 JComponent provides the functionality that is common to all
components.
 For example, JComponent supports the pluggable look and feel.
JComponent inherits the AWT classes Container and
Component.
 All of Swing’s components are represented by classes defined
within the package javax.swing.

The following table shows the class names for Swing
components (including those used as containers).

Containers
 Swing defines two types of containers.
1. top-level containers
2. lightweight containers.
 The first are top-level containers: JFrame, JApplet,
JWindow, and JDialog. These containers do not
inherit JComponent.
 The one most commonly used for applications is
JFrame. The one used for applets is JApplet.

 The second are lightweight containers.
Lightweight containers do inherit JComponent. An
example of a lightweight container is JPanel, which is
a general-purpose container.
Lightweight containers are often used to organize and
manage groups of related components because a
lightweight container can be contained within another
container.
Swing defines two types of containers.

The Top-Level Container Panes
 Each top-level container defines a set of panes.
 At the top of the hierarchy is an instance of
JRootPane.
 JRootPane is a lightweight container whose
purpose is to manage the other panes.
 It also helps manage the optional menu bar.
 The panes that comprise the root pane are
called the glass pane, the content pane, and the
layered pane.

panes that comprise the root pane
 Glass pane : The glass pane is the top-level
pane. It sits above and completely covers all
other panes. By default, it is a transparent
instance of JPanel.
 layered pane : The layered pane is an
instance of JLayeredPane. The layered pane
allows components to be given a depth value.
This value determines which component
overlays another.

 Content pane: The pane with which
your application will interact the most is
the content pane
In other words, when you add a
component, such as a button, to a top-
level container, you will add it to the
content pane. By default, the content
pane is an opaque instance of JPanel.

The Swing Packages
 Swing is a very large subsystem and makes use of
many packages. These are the packages used by
Swing that are defined by Java SE 6.
The main package is javax.swing. This package must be
imported into any program that uses Swing. It contains the
classes that implement the basic Swing components, such as push
buttons, labels, and check boxes.

A Simple Swing Application
 There are two types of Java programs in
which Swing is typically used.
 Desktop application.
 Applet.
This section shows how to create a
Swing application.

create a Swing application.
// A simple Swing application.
import javax.swing.*;
class SwingDemo
{
SwingDemo()
{
// Create a new JFrame container.
JFrame jfrm = new JFrame("A Simple Swing Application");
jfrm.setSize(275, 100); // Give the frame an initial size.
// Terminate the program when the user closes the application.
jfrm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Create a text-based label.
JLabel jlab = new JLabel(" Swing means powerful GUIs.");
jfrm.add(jlab); // Add the label to the content pane.
jfrm.setVisible(true); // Display the frame.
}
public static void main(String args[])
{
// Create the frame on the event dispatching thread.
SwingUtilities.invokeLater(new Runnable() {
public void run() {
new SwingDemo();
}
});
}
}

 Swing programs are compiled and run in the same way as
other Java applications. Thus, to compile this program,
you can use this command line:
javac SwingDemo.java
 To run the program, use this command line:
java SwingDemo
 When the program is run, it will produce the window
shown.

 SwingDemo program illustrates several core
Swing concepts, we will examine it carefully,
line by line.
 The program begins by importing javax.swing.
As mentioned,
 This package contains the components and
models defined by Swing. For example,
javax.swing defines classes that implement
labels, buttons, text controls, and menus.
 It will be included in all programs that use
Swing.

 Next, the program declares the SwingDemo class and a
constructor for that class.
 The constructor is where most of the action of the program
occurs. It begins by creating a JFrame, using this line of
code:
JFrame jfrm = new JFrame("A Simple Swing Application");
 This creates a container called jfrm that defines a
rectangular window complete with a title bar; close,
minimize, maximize, and restore buttons; and a system
menu.
 It creates a standard, top-level window. The title of the
window is passed to the constructor.

 Next, the window is sized using this statement:
jfrm.setSize(275, 100);
 The setSize( ) method (which is inherited by
JFrame from the AWT class Component) sets
the dimensions of the window, which are
specified in pixels. Its general form is shown
here:
void setSize(int width, int height)
 In this example, the width of the window is set
to 275 and the height is set to 100.

 By default, when a top-level window is closed (such as
when the user clicks the close box), the window is removed
from the screen, but the application is not terminated.
 While this default behavior is useful in some situations, it is
not what is needed for most applications.
 Instead, you will usually want the entire application to
terminate when its top-level window is closed.
 There are a couple of ways to achieve this. The easiest
way is to call setDefaultCloseOperation( ), as the program
does:
jfrm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 The next line of code creates a Swing JLabel
component:
JLabel jlab = new JLabel(" Swing means powerful GUIs.");
 JLabel is the simplest and easiest-to-use component
because it does not accept user input. It simply displays
information,
 The next line of code adds the label to the content pane
of the frame:
jfrm.add(jlab);
 The last statement in the SwingDemo constructor
causes the window to become visible:
jfrm.setVisible(true);

 Inside main( ), a SwingDemo object is created, which
causes the window and the label to be displayed.
 Notice that the SwingDemo constructor is invoked
using these lines of code:
SwingUtilities.invokeLater(new Runnable()
{
public void run() {
new SwingDemo();
}
});

Create a Swing Applet
 Swing-based applets are similar to AWT-
based applets.
 A Swing applet extends JApplet rather than
Applet.
 JApplet is derived from Applet.
 JApplet is a top-level Swing container.

 Swing applets use the same four lifecycle
methods as described in Applets:
init( ),start( ), stop( ), and destroy( )
 All interaction with components in a Swing
applet must take place on the event
dispatching thread.

// A simple Swing-based applet
import java.awt.*;
import java.awt.event.*;
/*
This HTML can be used to launch the applet:
<object code="MySwingApplet" width=220 height=90>
</object>
*/
public class MySwingApplet extends JApplet {
JButton jbtnAlpha;
JButton jbtnBeta;
JLabel jlab;

// Initialize the applet.
public void init() {
try {
SwingUtilities.invokeAndWait(new Runnable () {
public void run() {
makeGUI(); // initialize the GUI
}
});
} catch(Exception exc) {
System.out.println("Can't create because of "+ exc);
}
}
// This applet does not need to override start(), stop(),
// or destroy().
// Setup and initialize the GUI.
private void makeGUI() {
// Set the applet to use flow layout.
setLayout(new FlowLayout());

// Make two buttons.
jbtnAlpha = new JButton("Alpha");
jbtnBeta = new JButton("Beta");
// Add action listener for Alpha.
jbtnAlpha.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent le) {
jlab.setText("Alpha was pressed.");
}
});
// Add action listener for Beta.
jbtnBeta.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent le) {
jlab.setText("Beta was pressed.");
}
});

// Add the buttons to the content pane.
add(jbtnAlpha);
add(jbtnBeta);
// Create a text-based label.
jlab = new JLabel("Press a button.");
// Add the label to the content pane.
add(jlab);
}
}

Exploring Swing
Some of the Swing component classes:
 All are lightweight and are derived from
JComponent.

JLabel and Image Icon
 JLabel can be used to display text and/or an icon.
 It does not respond to user input.
 JLabel defines several constructors:
JLabel(Icon icon)
JLabel(String str)
JLabel(String str, Icon icon, int align)
 The align argument specifies the horizontal alignment
of the text. i.e; LEFT, RIGHT, CENTER, LEADING, or
TRAILING.

 icons are specified by objects of type Icon, which is an
interface defined by Swing. The easiest way to obtain an
icon is to use the ImageIcon class. ImageIcon implements
Icon and encapsulates an image.
 ImageIcon constructor : ImageIcon(String filename)
 The icon and text associated with the label can be
obtained by the following methods:
Icon getIcon( )
String getText( )
 The icon and text associated with a label can be set by
these methods:
void setIcon(Icon icon)
void setText(String str)

// Demonstrate JLabel and ImageIcon.
import java.awt.*;
/*
<applet code="JLabelDemo" width=250 height=150>
</applet>
*/
public class JLabelDemo extends JApplet {
Try
{
SwingUtilities.invokeAndWait(
new Runnable() {
public void run() {
makeGUI();
}
}

);
} catch (Exception exc) {
System.out.println("Can't create because of " + exc);
}
}
// Create an icon.
ImageIcon ii = new ImageIcon("france.gif");
// Create a label.
JLabel jl = new JLabel("France", ii, JLabel.CENTER);
add(jl);
}
}

JTextField
• Is the simplest Swing text component.
• Allows us to edit one line of text.
• Derived from JTextComponent.
• Uses the Document interface for its model.
Three of JTextField’s constructors:
JTextField(int cols)
JTextField(String str , int cols)
JTextField(String str)
String getText() - obtain the text currently in the text
field.

// Demonstrate JTextField.
import java.awt.*;
/*
<applet code="JTextFieldDemo" width=300 height=50>
</applet>
*/
public class JTextFieldDemo extends JApplet {
JTextField jtf;
try {
new Runnable() {
public void run() {
makeGUI();
}
}
);
}
}

// Change to flow layout.
// Add text field to content pane.
jtf = new JTextField(15);
add(jtf);
jtf.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
// Show text when user presses ENTER.
showStatus(jtf.getText());
}
});
}
}

The Swing Buttons
 Swing defines four types of buttons:
◦ JButton,
◦ JToggleButton
◦ JCheckBox
◦ JRadioButton
 All are subclasses of the AbstractButton class,
which extends JComponent.
 AbstractButton contains many methods that allow
you to control the behavior of buttons.

Methods:
 void setDisabledIcon(Icon di)
 void setPressedIcon(Icon pi)
 void setSelectedIcon(Icon si)
 void setRolloverIcon(Icon ri)
The text associated with a button can be read and
written using,
 String getText( )
 void setText(String str)

JButton
JButton inherits AbstractButton and provides
several constructors to create buttons.
javax.swing.JButton
+JButton()
+JButton(icon: javax.swing.Icon)
+JButton(text: String)
+JButton(text: String, icon: Icon)
Creates a default button with no text and icon.
Creates a button with an icon.
Creates a button with text.
Creates a button with text and an icon.
javax.swing.AbstractButton

The following are JButton constructors:
 JButton()
JButton(String text)
JButton(String text, Icon icon)
JButton(Icon icon)
JButton Methods :
◦ String getText()
◦ void setText(String str)
◦ setActionCommand()
◦ getActionCommand()

// Demonstrate an icon-based JButton.
import java.awt.*;
/*
<applet code="JButtonDemo" width=250 height=450>
</applet>
*/
public class JButtonDemo extends JApplet
implements ActionListener {
JLabel jlab;
try {
new Runnable() {
public void run() {
makeGUI();
}
}
);
}
}

setLayout(new FlowLayout()); // Change to flow layout.
// Add buttons to content pane.
ImageIcon france = new ImageIcon("france.gif");
JButton jb = new JButton(france);
jb.setActionCommand("France");
jb.addActionListener(this);
add(jb);
ImageIcon germany = new ImageIcon("germany.gif");
jb = new JButton(germany);
jb.setActionCommand("Germany");
add(jb);
ImageIcon italy = new ImageIcon("italy.gif");
jb = new JButton(italy);
jb.setActionCommand("Italy");

add(jb);
ImageIcon japan = new ImageIcon("japan.gif");
jb = new JButton(japan);
jb.setActionCommand("Japan");
add(jb);
// Create and add the label to content pane.
jlab = new JLabel("Choose a Flag");
add(jlab);
}
// Handle button events.
jlab.setText("You selected " + ae.getActionCommand());
}
}

JToggleButton
 A useful variation on the push button is called a toggle
button.
 A toggle button looks just like a push button, but it acts
differently because it has two states: pushed and released.
 when you press a toggle button, it stays pressed rather
than popping back up as a regular push button does.
 When you press the toggle button a second time, it
releases (pops up).
 Each time a toggle button is pushed, it toggles between its
two states.

JToggleButton
 Toggle buttons are objects of the JToggleButton
class.
 JToggleButton implements AbstractButton.
 JToggleButton constructors
JToggleButton(String str)

// Demonstrate JToggleButton.
import java.awt.*;
/*
<applet code="JToggleButtonDemo" width=200 height=80>
</applet>
*/
public class JToggleButtonDemo extends JApplet {
JLabel jlab;
JToggleButton jtbn;
try {
new Runnable() {
public void run() {
makeGUI();
}
}
);
}

}
// Create a label.
jlab = new JLabel("Button is off.");
// Make a toggle button.
jtbn = new JToggleButton("On/Off");
// Add an item listener for the toggle button.
jtbn.addItemListener(new ItemListener() {
public void itemStateChanged(ItemEvent ie) {
if(jtbn.isSelected())
jlab.setText("Button is on.");
else
jlab.setText("Button is off.");
}
});

// Add the toggle button and label to the
content pane.
add(jtbn);
add(jlab);
}
}

JCheckBox
 JCheckBox class provides the functionality of a
check box. Its immediate superclass is JToggleButton
 JCheckBox constructors :
JCheckBox(String str)
javax.swing.JCheckBox
+JCheckBox()
+JCheckBox(text: String)
+JCheckBox(text: String, selected:
boolean)
+JCheckBox(icon: Icon)
+JCheckBox(text: String, icon: Icon)
+JCheckBox(text: String, icon: Icon,
selected: boolean)
Creates a default check box button with no text and icon.
Creates a check box with text.
Creates a check box with text and specifies whether the check box is
initially selected.
Creates a checkbox with an icon.
Creates a checkbox with text and an icon.
Creates a check box with text and an icon, and specifies whether the check
box is initially selected.
javax.swing.JToggleButton

Demonstrate JCheckbox.
import java.awt.*;
/*
<applet code="JCheckBoxDemo" width=270 height=50>
</applet>
*/
public class JCheckBoxDemo extends JApplet
implements ItemListener {
JLabel jlab;
try {
new Runnable() {
public void run() {
makeGUI();
} } );
} }

private void makeGUI()
{
// Add check boxes to the content pane.
JCheckBox cb = new JCheckBox("C");
cb.addItemListener(this);
add(cb);
cb = new JCheckBox("C++");
add(cb);
cb = new JCheckBox("Java");
add(cb);
cb = new JCheckBox("Perl");
add(cb);

// Create the label and add it to the content pane.
jlab = new JLabel("Select languages");
add(jlab);
}
// Handle item events for the check boxes.
public void itemStateChanged(ItemEvent ie) {
JCheckBox cb = (JCheckBox)ie.getItem();
if(cb.isSelected())
jlab.setText(cb.getText() + " is selected");
else
jlab.setText(cb.getText() + " is cleared");
}
}

Radio Buttons
 Radio buttons are a group of mutually exclusive
buttons, in which only one button can be selected at
any one time.
 They are supported by the JRadioButton class, which
extends JToggleButton.
javax.swing.JRadioButton
+JRadioButton()
+JRadioButton(text: String)
+JRadioButton(text: String, selected:
boolean)
+JRadioButton(icon: Icon)
+JRadioButton(text: String, icon: Icon)
+JRadioButton(text: String, icon: Icon,
selected: boolean)
Creates a default radio button with no text and icon.
Creates a radio button with text.
Creates a radio button with text and specifies whether the radio button is
initially selected.
Creates a radio button with an icon.
Creates a radio button with text and an icon.
Creates a radio button with text and an icon, and specifies whether the radio
button is initially selected.
javax.swing.JToggleButton

// Demonstrate JRadioButton
import java.awt.*;
/*
<applet code="JRadioButtonDemo" width=300 height=50>
</applet>
*/
public class JRadioButtonDemo extends JApplet
implements ActionListener {
JLabel jlab;
try {
new Runnable() {
public void run() {
makeGUI();
} } );
} }

// Create radio buttons and add them to content pane.
JRadioButton b1 = new JRadioButton("A");
b1.addActionListener(this);
add(b1);
JRadioButton b2 = new JRadioButton("B");
add(b2);
JRadioButton b3 = new JRadioButton("C");
add(b3);
// Define a button group.
ButtonGroup bg = new ButtonGroup();
bg.add(b1);
bg.add(b2);
bg.add(b3);

// Create a label and add it to the content pane.
jlab = new JLabel("Select One");
add(jlab);
}
// Handle button selection.
jlab.setText("You selected " + ae.getActionCommand());
}
}

JTabbedPane
 JTabbedPane encapsulates a tabbed pane.
 It manages a set of components by linking them with
tabs.
 Selecting a tab causes the component associated
with that tab to come to the forefront.
The general procedure to use a tabbed pane is
outlined here:
1. Create an instance of JTabbedPane.
2. Add each tab by calling addTab( ).
3. Add the tabbed pane to the content pane.

Demonstrate JTabbedPane.
/*
<applet code="JTabbedPaneDemo" width=400 height=100>
</applet>
*/
public class JTabbedPaneDemo extends JApplet {
try {
new Runnable() {
public void run() {
makeGUI();
}
}
);
}
}

JTabbedPane jtp = new JTabbedPane();
jtp.addTab("Cities", new CitiesPanel());
jtp.addTab("Colors", new ColorsPanel());
jtp.addTab("Flavors", new FlavorsPanel());
add(jtp);
}
}
// Make the panels that will be added to the tabbed pane.
class CitiesPanel extends JPanel {
public CitiesPanel() {
JButton b1 = new JButton("New York");
add(b1);
JButton b2 = new JButton("London");
add(b2);
JButton b3 = new JButton("Hong Kong");
add(b3);
JButton b4 = new JButton("Tokyo");
add(b4);
}
}

class ColorsPanel extends JPanel {
public ColorsPanel() {
JCheckBox cb1 = new JCheckBox("Red");
add(cb1);
JCheckBox cb2 = new JCheckBox("Green");
add(cb2);
JCheckBox cb3 = new JCheckBox("Blue");
add(cb3);
}
}
class FlavorsPanel extends JPanel {
public FlavorsPanel() {
JComboBox jcb = new JComboBox();
jcb.addItem("Vanilla");
jcb.addItem("Chocolate");
jcb.addItem("Strawberry");
add(jcb);
}
}

JScrollPane
 JScrollPane is a lightweight container that
automatically handles the scrolling of another
component.
 The component being scrolled can either be
an individual component, such as a table, or a
group of components contained within another
lightweight container, such as a JPanel.

Demonstrate JScrollPane.
import java.awt.*;
/*
<applet code="JScrollPaneDemo" width=300 height=250>
</applet>
*/
public class JScrollPaneDemo extends JApplet {
try {
new Runnable() {
public void run() {
makeGUI();
}
}
);
}

}
// Add 400 buttons to a panel.
JPanel jp = new JPanel();
jp.setLayout(new GridLayout(20, 20));
int b = 0;
for(int i = 0; i < 20; i++) {
for(int j = 0; j < 20; j++) {
jp.add(new JButton("Button " + b));
++b;
}
}
// Create the scroll pane.
JScrollPane jsp = new JScrollPane(jp);
// Add the scroll pane to the content pane.
// Because the default border layout is used,
// the scroll pane will be added to the center.
add(jsp, BorderLayout.CENTER);
}
}

JList
 In Swing, the basic list class is called JList.
It supports the selection of one or more
items from a list.
 Jlist constructors.
JList(Object[ ] items)
This creates a JList that contains the items
in the array specified by items.

JList is based on two models
 ListModel :-
This interface defines how access
to the list data is achieved.
 ListSelectionModel :-
Interface, which defines methods
that determine what list item or items
are selected.

ListSelectionModel:
 SINGLE_SELECTION
 SINGLE_INTERVAL_SELECTION
 MULTIPLE_INTERVAL_SELECTION

// Demonstrate JList.
import javax.swing.event.*;
import java.awt.*;
/*
<applet code="JListDemo" width=200 height=120>
</applet>
*/
public class JListDemo extends JApplet {
JList jlst;
JLabel jlab;
JScrollPane jscrlp;
// Create an array of cities.
String Cities[] = { "New York", "Chicago", "Houston",
"Denver", "Los Angeles", "Seattle",
"London", "Paris", "New Delhi",
"Hong Kong", "Tokyo", "Sydney" };

try {
new Runnable() {
public void run() {
makeGUI();
} }
);
System.out.println("Can't create because of " + exc); } }
// Create a JList.
jlst = new JList(Cities);
// Set the list selection mode to single selection.
jlst.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

// Add the list to a scroll pane.
jscrlp = new JScrollPane(jlst);
// Set the preferred size of the scroll pane.
jscrlp.setPreferredSize(new Dimension(120, 90));
// Make a label that displays the selection.
jlab = new JLabel("Choose a City");
// Add selection listener for the list.
jlst.addListSelectionListener(new
ListSelectionListener() {
public void valueChanged(ListSelectionEvent le) {
// Get the index of the changed item.
int idx = jlst.getSelectedIndex();

// Display selection, if item was selected.
if(idx != -1)
jlab.setText("Current selection: " + Cities[idx]);
else // Otherwise, reprompt.
jlab.setText("Choose a City");
}
});
// Add the list and label to the content pane.
add(jscrlp);
add(jlab);
}
}

JComboBox
 Swing provides a combo box (a combination of a text field
and a drop-down list) through the JComboBox class.
 A combo box normally displays one entry, but it will also
display a drop-down list that allows a user to select a
different entry.
 JComboBox constructor
JComboBox(Object[ ] items)
Here, items is an array that initializes the combo box. Other
constructors are available.

Demonstrate JComboBox.
import java.awt.*;
/*
<applet code="JComboBoxDemo" width=300 height=100>
</applet>
*/
public class JComboBoxDemo extends JApplet {
JLabel jlab;
ImageIcon france, germany, italy, japan;
JComboBox jcb;
String flags[] = { "France", "Germany", "Italy", "Japan" };
try {
new Runnable() {
public void run() {

makeGUI();
} } );
} }
// Instantiate a combo box and add it to the content pane.
jcb = new JComboBox(flags);
add(jcb);
// Handle selections.
jcb.addActionListener(new ActionListener() {
String s = (String) jcb.getSelectedItem();
jlab.setIcon(new ImageIcon(s + ".gif"));
}
});
// Create a label and add it to the content pane.
jlab = new JLabel(new ImageIcon("france.gif"));
add(jlab);
}
}

Trees
 A tree is a component that presents a hierarchical view
of data.
 The user has the ability to expand or collapse
individual subtrees in this display.
 Trees are implemented in Swing by the JTree class.
Trees constructors
 JTree(Object obj[ ])
 JTree(Vector<?> v)
 JTree(TreeNode tn)

JTree relies on two models:
 TreeModel
 TreeSelectionModel.
Jtree Events
 TreeExpansionEvent,
 TreeSelectionEvent
 TreeModelEvent.

Jtree Events
 TreeExpansionEvent: events occur when
a node is expanded or collapsed.
 TreeSelectionEvent :- It is generated
when the user selects or deselects a node
within the tree
 TreeModelEvent :- is fired when the data
or structure of the tree changes..

Demonstrate JTree.
import java.awt.*;
import javax.swing.event.*;
import javax.swing.tree.*;
/*
<applet code="JTreeDemo" width=400 height=200>
</applet>
*/
public class JTreeDemo extends JApplet {
JTree tree;
JLabel jlab;
try {
new Runnable() {
public void run() {
makeGUI();
} } );
System.out.println("Can't create because of " + exc); } }

// Create top node of tree.
DefaultMutableTreeNode top = new DefaultMutableTreeNode("Options");
// Create subtree of "A".
DefaultMutableTreeNode a = new DefaultMutableTreeNode("A");
top.add(a);
DefaultMutableTreeNode a1 = new DefaultMutableTreeNode("A1");
a.add(a1);
DefaultMutableTreeNode a2 = new DefaultMutableTreeNode("A2");
a.add(a2);
// Create subtree of "B".
DefaultMutableTreeNode b = new DefaultMutableTreeNode("B");
top.add(b);
DefaultMutableTreeNode b1 = new DefaultMutableTreeNode("B1");
b.add(b1);
b.add(b2);
b.add(b3);
// Create the tree.
tree = new JTree(top);

// Add the tree to a scroll pane.
JScrollPane jsp = new JScrollPane(tree);
add(jsp);
jlab = new JLabel();
add(jlab, BorderLayout.SOUTH);
// Handle tree selection events.
tree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent tse) {
jlab.setText("Selection is " + tse.getPath());
}
});
}
}

JTable
 JTable is a component that displays rows and columns
of data.
 You can drag the cursor on column boundaries to
resize columns. You can also drag a column to a new
position.
 Depending on its configuration, it is also possible to
select a row, column, or cell within the table, and to
change the data within a cell.
Jtable constructors:-
JTable(Object data[ ][ ], Object colHeads[ ])

JTable relies on three models
 TableModel interface:- This model defines
those things related to displaying data in a
two-dimensional format.
 TableColumnModel:- specifies the
characteristics of a column
 ListSelectionModel:- determines how items
are selected

Jtable events.
 ListSelectionEvent:- is generated
when the user selects something in
the table
 TableModelEvent:- is fired when that
table’s data changes in some way

// Demonstrate JTable.
import java.awt.*;
/*
<applet code="JTableDemo" width=400 height=200>
</applet>
*/
public class JTableDemo extends JApplet {
try {
new Runnable() {
public void run() {
makeGUI();
}
}
);
}
}

// Initialize column headings.
String[] colHeads = { "Name", "Extension", "ID#" };
// Initialize data.
Object[][] data = {
{ "Gail", "4567", "865" },
{ "Ken", "7566", "555" },
{ "Viviane", "5634", "587" },
{ "Melanie", "7345", "922" },
{ "Anne", "1237", "333" },
{ "John", "5656", "314" },
{ "Matt", "5672", "217" },
{ "Claire", "6741", "444" },
{ "Erwin", "9023", "519" },
{ "Ellen", "1134", "532" },
{ "Jennifer", "5689", "112" },
{ "Ed", "9030", "133" },
{ "Helen", "6751", "145" }
};

// Create the table.
JTable table = new JTable(data, colHeads);
// Add the table to a scroll pane.
JScrollPane jsp = new JScrollPane(table);
add(jsp);
}
}

Chapter 1 swings

More Related Content

What's hot

Viewers also liked

Similar to Chapter 1 swings

More from Jafar Nesargi

Recently uploaded

Chapter 1 swings