AWT & SWINGS IN JAVA

IMPLEMENTING GUIS IN JAVA

 The Java Foundation Classes (JFC) are a set of
packages encompassing the following APIs:
 Abstract Window Toolkit (AWT): native GUI
components
 Swing: lightweight GUI components
 2D: rendering two-dimensional shapes, text, and images
 Accessibility: allowing compatibility with, for example,
screen readers and screen magnifiers
ABSTRACT WINDOW TOOLKIT (AWT)
 Provides basic UI components:
 Buttons, lists, menus, textfields, etc
 Event handling mechanism
 Clipboard and data transfer
 Image manipulation
 Font manipulation
 Graphics
 Platform independence is achieved through peers, or
native GUI components
 AWT PACKAGES
java.awt Basic component functionality
java.awt.accessibility Assistive technologies
java.awt.color Colors and color spaces
java.awt.datatransfer Clipboard and data transfer support
java.awt.dnd Drag and drop
java.awt.event Event classes and listeners
java.awt.font 2D API font package
java.awt.geom 2D API geometry package
java.awt.im Input methods
java.awt.image Fundamental image manipulation classes
java.awt.peer Peer interfaces for component peers
java.awt.print 2D API support for printing
java.awt.swing Swing components
THE AWT LIBRARY

 AWT is a general-purpose, multi-platform

windowing library.
 It’s a standard part of Java environment.
 Provides all the basic functionality that may be
needed for use in developing GUI application.
 Provides classes that encapsulate many useful
GUI components.
AWT CLASS
import java.awt.*;
class MyFrame extends Frame
{
public void paint(Graphics g)
{
g.drawString(“Hello world”,50,50);
}
public static void main(String args[])
{
Frame f = new MyFrame();
f.setSize(100,100);
f.show();
}
}
 THE COLOR CLASS

 Defines methods & constants for manipulating

colors in a Java program.
 Every color is created from a red, green & blue
component.
 To change color, you must create a Color object or
use one of the predefined Color constants.
THE FONT CLASS

 Allows to create a font object that will display

text in a particular font.
 The number of fonts varies greatly across
systems.
 Java uses standardized font names & maps these
into system-specific font names for portability.
THE COLOR & FONT CLASS

public void paint(Graphics g)

{
g.setColor(Color.blue);
Font f = new
Font(“TimesRoman”,Font.BOLD,20);
g.setFont(f);
g.drawString(“Hello World”, 50,50);
}
GRAPHICS CLASS
 Graphics is an abstract class.
 A graphics context enables drawing on screen in
Java.
 A Graphics object encapsulates state info needed
for the basic rendering options that java supports.
 It remembers a collection of settings for drawing
images &text.
 All drawing in Java must go through a Graphics
object.
GRAPHICS CLASS
 Why is Graphics class an abstract class ?
 Reason is : Java’s Portability
 Graphics capabilities that enable a PC running
windows are different from ones that enable a UNIX
workstation to draw a rectangle.
 When Java is implemented on each platform, a
derived class of Graphics is created that actually
implements the drawing capabilities.
E.g. WGraphics class for Windows
AWT(COMPONENTS)

 Button  Canvas
 Checkbox  CheckboxGroup
 Choice  List
 Menu  Label
 TextField  TextArea
 Scrollbar  ScrollPane
COMPONENT HIERARCHY IN AWT
Object

Component Scrollbar

Canvas

Checkbox

Choice

Label

Text Component
Text Area

List
Text Field
Container
AWT (CONTAINER)

Component

Container

Panel Window

Frame Dialog

FileDialog
 EXAMPLE: A SIMPLE FRAMED WINDOW
import java.awt.*;
import javax.swing.*;

public class SwingTest {

public static void main(String[] args) {

JFrame frame = new JFrame("Test Frame");
frame.setSize(new Dimension(300,200));
frame.setLocation(100,100);
frame.setVisible(true);
}

}
JAVA
Swing Programming
SWING COMPONENTS
 Swing is a collection of libraries that
contains primitive widgets or controls
used for designing Graphical User
Interfaces (GUIs).

 Commonly used classes in javax.swing

package:
 JButton, JTextBox, JTextArea, JPanel,
JFrame, JMenu, JSlider, JLabel, JIcon, …
 There are many, many such classes to do
anything imaginable with GUIs
 Here we only study the basic architecture and
do simple examples
SWING COMPONENTS, CONT.
 Each component is a Java class with a fairly
extensive inheritency hierarchy:

Object

Component

Container

JComponent Window

JPanel Frame

JFrame
USING SWING COMPONENTS
 Very simple, just create object from appropriate
class – examples:
 JButton but = new JButton();
 JTextField text = new JTextField();
 JTextArea text = new JTextArea();
 JLabel lab = new JLabel();
 Many more classes. Don’t need to know every one
to get started.
 See ch. 9 Hortsmann
ADDING COMPONENTS
 Oncea component is created, it can be
added to a container by calling the
container’s add method:

Container cp = getContentPane(); This is required

cp.add(new JButton(“cancel”));
cp.add(new JButton(“go”));

How these are laid out is determined by the layout manager.

LAYING OUT COMPONENTS
 Not so difficult but takes a little practice
 Do not use absolute positioning – not very
portable, does not resize well, etc.
LAYING OUT COMPONENTS
 Use layout managers – basically tells
form how to align components when
they’re added.
 Each Container has a layout manager
associated with it.
 A JPanel is a Container – to have
different layout managers associated with
different parts of a form, tile with JPanels
and set the desired layout manager for
each JPanel, then add components
directly to panels.
LAYOUT MANAGERS
 Java comes with 7 or 8. Most common and easiest
to use are
 FlowLayout
 BorderLayout
 GridLayout
 Using just these three it is possible to attain fairly
precise layout for most simple applications.
SETTING LAYOUT MANAGERS
 Veryeasy to associate a layout manager
with a component. Simply call the
setLayout method on the Container:

JPanel p1 = new JPanel();

p1.setLayout(new FlowLayout(FlowLayout.LEFT));

JPanel p2 = new JPanel();

p2.setLayout(new BorderLayout());

As Components are added to the container, the layout

manager determines their size and positioning.
EVENT HANDLING
WHAT ARE EVENTS?
 Allcomponents can listen for one or more
events.
 Typical examples are:
 Mouse movements
 Mouse clicks
 Hitting any key
 Hitting return key
 etc.
 Tellingthe GUI what to do when a
particular event occurs is the role of the
event handler.
ACTIONEVENT
 In Java, most components have a special event
called an ActionEvent.
 This is loosely speaking the most common or
canonical event for that component.
 A good example is a click for a button.
 To have any component listen for ActionEvents,
you must register the component with an
ActionListener. e.g.
 button.addActionListener(new MyAL());
DELEGATION, CONT.
 This is referred to as the Delegation Model.
 When you register an ActionListener with a
component, you must pass it the class which will
handle the event – that is, do the work when the
event is triggered.
 For an ActionEvent, this class must implement
the ActionListener interface.
 This is simple a way of guaranteeing that the
actionPerformed method is defined.
ACTIONPERFORMED

 The actionPerformed method has the

following signature:
void actionPerformed(ActionEvent)
 The object of type ActionEvent passed to
the event handler is used to query
information about the event.
 Some common methods are:
 getSource()
 object reference to component generating event
 getActionCommand()
 some text associated with event (text on button, etc).
ACTIONPERFORMED, CONT.

 These methods are particularly useful when using

one eventhandler for multiple components.
SIMPLEST GUI

import javax.swing.JFrame;
class SimpleGUI extends JFrame{
SimpleGUI(){
setSize(400,400); //set frames size in pixels
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
}

public static void main(String[] args){

SimpleGUI gui = new SimpleGUI();
System.out.println(“main thread coninues”);
}
}
ANOTHER SIMPLE GUI
import javax.swing.*;
class SimpleGUI extends JFrame{
SimpleGUI(){
setSize(400,400); //set frames size in pixels
setDefaultCloseOperation(EXIT_ON_CLOSE);
JButton but1 = new JButton(“Click me”);
Container cp = getContentPane();//must do this
cp.add(but1);
show();
}

public static void main(String[] args){

SimpleGUI gui = new SimpleGUI();
System.out.println(“main thread coninues”);
}}
ADD LAYOUT MANAGER
import javax.swing.*; import java.awt.*;
class SimpleGUI extends JFrame{
SimpleGUI(){
setSize(400,400); //set frames size in pixels
setDefaultCloseOperation(EXIT_ON_CLOSE);
JButton but1 = new JButton(“Click me”);
Container cp = getContentPane();//must do this
cp.setLayout(new FlowLayout(FlowLayout.CENTER);
cp.add(but1);
show();
}

public static void main(String[] args){

SimpleGUI gui = new SimpleGUI();
System.out.println(“main thread coninues”);
}}
ADD CALL TO EVENT HANDLER
import javax.swing.*; import java.awt.*;
class SimpleGUI extends JFrame{
SimpleGUI(){
setSize(400,400); //set frames size in pixels
setDefaultCloseOperation(EXIT_ON_CLOSE);
JButton but1 = new JButton(“Click me”);
Container cp = getContentPane();//must do this
cp.setLayout(new FlowLayout(FlowLayout.CENTER);
but1.addActionListener(new MyActionListener());
cp.add(but1);
show();
}
public static void main(String[] args){
SimpleGUI gui = new SimpleGUI();
System.out.println(“main thread coninues”);
}}
EVENT HANDLER CODE
class MyActionListener implements ActionListener{
public void actionPerformed(ActionEvent ae){
JOptionPane.showMessageDialog(“I got clicked”, null);
}

}
ADD SECOND BUTTON/EVENT

class SimpleGUI extends JFrame{

SimpleGUI(){
/* .... */
JButton but1 = new JButton(“Click me”);
JButton but2 = new JButton(“exit”);
MyActionListener al = new MyActionListener();
but1.addActionListener(al);
but2.addActionListener(al);
cp.add(but1);
cp.add(but2);
show();
}
}
HOW TO DISTINGUISH EVENTS –LESS
GOOD WAY

class MyActionListener implents ActionListener{

public void actionPerformed(ActionEvent ae){
if (ae.getActionCommand().equals(“Exit”){
System.exit(1);
}
else if (ae.getActionCommand().equals(“Click me”){
JOptionPane.showMessageDialog(null, “I’m clicked”);
}

}
GOOD WAY
class MyActionListener implents ActionListener{
public void actionPerformed(ActionEvent ae){
if (ae.getSource() == b2){
System.exit(1);
}
else if (ae.getSource() == b1){
JOptionPane.showMessageDialog(null, “I’m clicked”);
}
}

Question: How are b1, b2 brought into scope to do this?

Question: Why is this better?