Swing

Prepared by:-Jaydeep R.Viradiya
Asst Prof
Parul University,Baroda
1
Swing in java
Unit -1

The Abstract Windowing Toolkit
2
Since Java was first released, its user interface
facilities have been a significant weakness
The Abstract Windowing Toolkit (AWT) was part of the
JDK form the beginning, but it really was not sufficient
to support a complex user interface
JDK 1.1 fixed a number of problems, and most
notably, it introduced a new event model. It did
not make any major additions to the basic
components

Java Foundation Classes
3
In April 1997, JavaSoft announced the Java
Foundation Classes (JFC).
a major part of the JFC is a new set of user interface
components called Swing.
AWT Swing Accessibility
Java
2D
Drag
And
Drop

Swing
4
The Swing classes are used to build GUIs
Swing does not stand for anything
Swing is built on top of the 1.1/1.2 AWT libraries
Swing makes 3 major improvements on the AWT
does not rely on the platform’s native components
it supports “Pluggable Look-and-Feel” or PLAF
it is based on the Model-View-Controller (MVC)
AWT
Swing
JFC
JDK 1.2

GUI Packages
5
AWT
java.awt
java.awt.color
java.awt.datatransfer
java.awt.event
java.awt.font
java.awt.geom
java.awt.image
...
Swing
javax.accessibility
javax.swing
javax.swing.colorchooser
javax.swing.event
javax.swing.filechooser
javax.swing.plaf
javax.swing.table
javax.swing.text.html
javax.swing.tree
...

Components
6
A GUI consists of different graphic Component
objects which are combined into a hierarchy using
Container objects.
Component class
An abstract class for GUI components such as menus,
buttons, labels, lists, etc.
Container
An abstract class that extends Component. Containers
can hold multiple components.

Weighing Components
7
Sun makes a distinction between lightweight and
heavyweight components
Lightweight components are not dependent on native
peers to render themselves. They are coded in Java.
Heavyweight components are rendered by the host
operating system. They are resources managed by the
underlying window manager.

Heavyweight Components
8
Heavyweight components were unwieldy for two
reasons
Equivalent components on different platforms do not
necessarily act alike.
The look and feel of each component was tied to the host
operating system
Almost all Swing components are lightweight except
JApplet, JFrame, JDialog, and JWindow

Additional Swing Features
9
Swing also provides
A wide variety of components (tables, trees, sliders, progress
bars, internal frame, …)
Swing components can have tooltips placed over them.
Arbitrary keyboard events can be bound to components.
Additional debugging support.
Support for parsing and displaying HTML based information.

Applets versus Applications
10
Using Swing it is possible to create two different types of
GUI programs
Standalone applications
Programs that are started from the command line
Code resides on the machine on which they are run
Applets
Programs run inside a web browser
Code is downloaded from a web server
JVM is contained inside the web browser
For security purposes Applets are normally prevented from doing certain
things (for example opening files)
For now we will write standalone applications

Three Types of GUI Classes
11
1. Containers
JFrame, JPanel, JApplet
1. Components
JButton, JTextField, JComboBox, JList, etc.
1. Helpers
Graphics, Color, Font, Dimension, etc.

JFrames
12
A JFrame is a Window with all of the adornments added.
JFrame inherits from Frame, Window,
Container, Component, and Object
A JFrame provides the basic building block for screen-
oriented applications.
JFrame win = new JFrame( “title” );

Creating a JFrame
13
import javax.swing.*;
public class SwingFrame {
public static void main( String args[] ) {
JFrame win = new JFrame( "My First GUI Program" );
win.setVisible(true);
}
} // SwingFrame

JFrame
14
Sizing a Frame
You can specify the size
Height and width given in pixels
The size of a pixel will vary based on the resolution of the device on
which the frame is rendered
Usually one uses an instance of the Dimension class.
The method pack() will set the size of the frame
automatically, based on the size of the components contained in
the content pane
Note that pack does not look at the title bar
Sometimes pack() does not work as you might expect; try it and see.

Creating a JFrame
15
import java.awt.*;
static Dimension windowSize = new Dimension( 250, 150 );
win.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
win.setSize( windowSize );
}
} // SwingFrame

Swing Components
16
JComponent
JComboBox, JLabel, JList, JMenuBar,
JPanel, JPopupMenu, JScrollBar,
JScrollPane, JTable, JTree,
JInternalFrame, JOptionPane,
JProgressBar, JRootPane, JSeparator,
JSlider, JSplitPane, JTabbedPane,
JToolBar, JToolTip, Jviewport,
JColorChooser, JTextComponent, …

JLabels
17
JLabels are components that you can fill with text.
When creating a label you can specify the initial value and
the alignment you wish to use within the label.
You can use getText() and setText() to get and
change the value of the label.
lbl = new JLabel( ”text", JLabel.RIGHT );

Hello World
18
JLabel label = new JLabel( "Hello World" );
win.getContentPane().add( label );
}
} // SwingFrame

JButtons
19
JButton extends Component , displays a string, and
delivers an ActionEvent for each mouse click.
Normally buttons are displayed with a border
In addition to text, JButtons can also display icons
button = new JButton( ”text“ );

Buttons
20
JButton button = new JButton( "Click Me!!" );
win.getContentPane().add( button );
}
} // SwingFrame

Layout Manager
21
Layout Manager
An interface that defines methods for positioning and sizing
objects within a container. Java defines several default
implementations of LayoutManager.
Geometrical placement in a Container is controlled by a
LayoutManager object

Components, Containers, and Layout
Managers
22
Containers may contain components (which means
containers can contain containers!!).
All containers come equipped with a layout manager which
positions and shapes (lays out) the container's components.
Much of the action in Swing occurs between components,
containers, and their layout managers.

Layout Managers
23
Layouts allow you to format components on the screen
in a platform-independent way
The standard JDK provides many classes that implement
the LayoutManager interface, including:
FlowLayout
GridLayout
BorderLayout
BoxLayout

Changing the Layout
24
1. To change the layout used in a container you first need
to create the layout.
2. Then you invoke the setLayout() method on the
container to use the new layout.
 The layout manager should be established before any
components are added to the container
JPanel p = new JPanel() ;
p.setLayout( new FlowLayout() );

FlowLayout
25
FlowLayout is the default layout for the JPanel
class.
When you add components to the screen, they flow left
to right (centered) based on the order added and the
width of the screen.
Very similar to word wrap and full justification on a
word processor.
If the screen is resized, the components' flow will
change based on the new width and height

Flow Layout
26
import java.awt.*;
public class ShowFlowLayout {
win.getContentPane().setLayout( new FlowLayout() );
for ( int i = 0; i < 10; i++ ) {
win.getContentPane().add(
new JButton( String.valueOf( i ) ) );
}
}
} // ShowFlowLayout

GridLayout
28
Arranges components in rows and columns
If the number of rows is specified
columns = number of components / rows
If the number of columns is specified
Rows = number of components / columns
The number of columns is ignored unless the number of rows
is zero.
The order in which you add components matters
Component 1  (0,0), Component 2  (0,1), …...
Components are resized to fit the row-column area

Grid Layout
29
import java.awt.*;
public class ShowGridLayout {
win.getContentPane().setLayout( new GridLayout( 2, 0 ) );
for ( int i = 0; i < 10; i++ ){
win.getContentPane().add(
new JButton( String.valueOf( i ) ) );
}
}
} // ShowGridLayout

GridLayout
30
gridLayout( 2, 4 )
gridLayout( 0, 4 ) gridLayout( 4, 4 ) gridLayout( 10, 10 )

BoxLayout
31
BoxLayout provides an easy way to lay out components
horizontally or vertically.
Components are added in order.
BoxLayout attempts to arrange components at their
preferred widths (for horizontal layout) or
preferred heights (for vertical layout).

BoxLayout example
32
import java.awt.*;
public class ShowBoxLayout {
win.getContentPane().setLayout(
new BoxLayout( win.getContentPane(), BoxLayout.X_AXIS ) );
for ( int i = 0; i < 10; i++ ){
win.getContentPane().add( new JButton( String.valueOf( i ) ) );
win.getContentPane().add( Box.createHorizontalGlue() );
}
win.pack();
}
} // ShowBoxLayout

BoxLayout
33
Note that components retain their preferred size.

BorderLayout
34
BorderLayout provides 5 areas to hold
components. These are named after the four different
borders of the screen, North, South, East, West, and
Center.
When a Component is added to the layout, you must
specify which area to place it in. The order in which
components are added is not important.
The center area will always be resized to be as large as
possible

BorderLayout
35
import java.awt.*;
public class ShowBorderLayout {
Container content = win.getContentPane();
content.setLayout( new BorderLayout() );
content.add( BorderLayout.NORTH, new JButton( "North" ) );
content.add( "South", new JButton( "South" ) );
content.add( "East", new JButton( "East" ) );
content.add( "West", new JButton( "West" ) );
content.add( "Center", new JButton( "Center" ) );
}
} // ShowBorderLayout

Containers
37
A JFrame is not the only type of container that you
can use in Swing
The subclasses of Container are:
JPanel
JWindow
JApplet
Window is subclassed as follows:
JDialog
JFrame

38
Making components active
Most components already appear to do something--buttons click,
text appears
To associate an action with a component, attach a listener to it
Components send events, listeners listen for events
Different components may send different events, and require
different listeners

39
Listeners
Listeners are interfaces, not classes
class MyButtonListener implements
ActionListener {
An interface is a group of methods that must be supplied
When you say implements, you are promising to supply those
methods

40
Writing a Listener
For a Button, you need an ActionListener
b1.addActionListener
(new MyButtonListener ( ));
An ActionListener must have an
actionPerformed(ActionEvent) method
public void actionPerformed(ActionEvent e) {
…
}

41
MyButtonListener
public void init () {
...
b1.addActionListener (new MyButtonListener ());
}
class MyButtonListener implements ActionListener {
public void actionPerformed (ActionEvent e) {
showStatus ("Ouch!");
}
}

42
Listeners for TextFields
An ActionListener listens for someone hitting the Enter key
An ActionListener requires this method:
public void actionPerformed (ActionEvent e)
You can use getText( ) to get the text
A TextListener listens for any and all keys
A TextListener requires this method:
public void textValueChanged(TextEvent e)

43
Summary I: Building a GUI
Create a container, such as Frame or Applet
Choose a layout manager
Create more complex layouts by adding Panels; each Panel can
have its own layout manager
Create other components and add them to whichever Panels
you like

44
Vocabulary
AWT – The Abstract Window Toolkit provides basic graphics
tools (tools for putting information on the screen)
Swing – A much better set of graphics tools
Container – a graphic element that can hold other graphic
elements (and is itself a Component)
Component – a graphic element (such as a Button or a
TextArea) provided by a graphics toolkit
listener – A piece of code that is activated when a particular kind
of event occurs
layout manager – An object whose job it is to arrange
Components in a Container

A Simple 4 Function Calculator
45

Swing Components
46
JFrame
with BorderLayout
JButton
JLabel
JPanel
with GridLayout

CalcGui.java (pg. 1)
47
import java.awt.*;
import java.awt.event.*;
public class CalcGui {
// Labels for the buttons
private static final String labels = "789X456/123-0C=+";
private static final int NUMROWS = 4;
private static final int NUMCOLS = 4;
private JLabel display; // The display
public CalcGui( String name ) {
// A Frame for the calculator
JFrame win = new JFrame(name);

48
// Create the button panel
JPanel buttons = new JPanel();
buttons.setLayout(new GridLayout(NUMROWS, NUMCOLS));
JButton b;
for ( int i = 0 ; i < labels.length() ; i++ ) {
b = new JButton( labels.substring( i, i + 1 ) );
buttons.add( b );
}
// Create the display
display = new JLabel( "0", JLabel.RIGHT );
display.setFont( new Font( "Courier", Font.BOLD, 24 ) );

49
// "Assemble" the calculator
Container content = win.getContentPane();
content.setLayout( new BorderLayout() );
content.add( "North", display );
content.add( "Center", buttons );
// Display it and let the user run with it :-)
win.pack();
}

Swing

More Related Content

Swing