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
 Once a 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
 Very easy 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?
 All components can listen for one or more 
events.
 Typical examples are:
 Mouse movements
 Mouse clicks
 Hitting any key
 Hitting return key
 etc.
 Telling the 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?