Unit-I Abstract Window Toolkit

Unit Outcomes
 Develop GUI programs using AWT Components for the

given problem

 Create Frame Window with the specified AWT components

 Arrange the GUI Components using specific layout managers

 Develop a program using Menu and Dialog Boxes for the

given problem
Sub-Topics
 Component, container, window, frame, panel.

 Creating windowed programs & applets.

 AWT controls

 Understanding the use of AWT controls: labels, buttons,

checkbox, checkbox group, scroll bars, text field, text area,

 Use of layout managers: flowLayout, borderLayout, gridLayout,

cardLayout, gridbagLayout, menubars, menus, dialog boxes, file

dialog.
AWT Basics
 Java AWT (Abstract Window Toolkit) is an API to develop GUI or
window-based applications in java.
 Java AWT is an API that contains large number of classes and methods to
create and manage graphical user interface ( GUI ) applications.
 The AWT was designed to provide a common set of tools for GUI
design that could work on a variety of platforms.
 The tools provided by the AWT are implemented using each platform's
native GUI toolkit, hence preserving the look and feel of each platform.
This is an advantage of using AWT.
AWT Basics
 But the disadvantage of such an approach is that GUI designed on one

platform may look different when displayed on another platform that

means AWT component are platform dependent.

 Java AWT components are platform-dependent i.e. components are

displayed according to the view of operating system. AWT is

heavyweight i.e. its components are using the resources of OS.

 The java.awt package provides classes for AWT api such

as TextField, Label, TextArea, RadioButton, CheckBox, Choice, List etc.
GUI

 Graphical User Interface (GUI) offers user interaction via some graphical components
such as window,frame,Panel, Button, Textfield, TextArea, Listbox, Combobox, Label,
Checkbox etc.

 Using these components we can create an interactive user interface for an application.

 GUI provides result to end user in response to raised events.GUI is entirely based events.
For example clicking over a button, closing a window, opening a window, typing
something in a textarea etc. These activities are known as events.
AWT Classes
 The AWT classes are contained in the java.awt package
 It is one of Java’s largest packages.
AWT Class Hierachy
Windows Fundamental
 The most common windows are derived from :
 Panel : Used by Applet
 Frame : Creates standard Window
 Component

 The Component is abstract class that encapsulates all the

attributes of visual component.
 All User interface (UI) elements that are displayed on screen are
subclasses of Component.

• It defines over a hundred public methods that are responsible for managing
events, such as mouse and keyboard input, positioning and sizing the
window, and repainting.

• Component is responsible for remembering the current foreground and

background color and the currently selected text font.
13
 Methods of Component class
Method Description

public void setBackground(Color c) Sets the background color of this

component.

public void setSize(int width, int height) sets the size (width and height) of
the component.

public void setForeground(Color c) Sets the foreground color of this

component.

public void setVisible(boolean status) changes the visibility of the

component, by default false.

void remove(Component c) Remove a component

void setBounds(int x,int y, int width, int Set the location and size of single
height) component and useful only with null
layout.

14
Container
• The Container is a component in AWT that can contain another

components like buttons, textfields, labels etc.

• The classes that extends Container class are known as container such

as Frame, Dialog and Panel.

• Container is responsible for laying out any components that it

contains through the use of layout managers.

• Methods:

• void setFont(Font f)

• void setLayout(LayoutManager mgr)

Window
 The window is the container that have no borders and menu
bars. You must use frame, dialog or another window for
creating a window.
 Top level window without
 borders,
 menubar
 show() makes window visible
 pack() resizes window to fit components in it
 dispose() frees resources when window is not needed
 Example use: pop-up menu
Panel
 The Panel is the container that doesn't contain title bar and menu bars. It can
have other components like button, textfield etc.
 Alternative to window
 e.g., for display of Applet in Web browser
 A Panel is a rectangular Container whose sole purpose is to hold and manage
components within a GUI.

Panel p1 = new Panel();

p1.add(new Button("Ok"));
aPanel.add(new Button("Cancel"));

Frame f = new Frame("Button Test");

f.setSize(100,100);
f.setLocation(10,10);
f.add(p1);
Frame
 The Frame is the container that contain title bar and can have
menu bars. It can have other components like button,
textfield etc.
 A window with title, menubar, icon, cursor
AWT Components
Working with Frame Window

 Constructor are:
 Frame()

 Frame(String title)

 Setting and Getting window size:

 void setSize(int width, int height)

 void setSize(Dimension newsize)

 Showing and Hiding Frame

 void setVisible(boolean visibleFlag)
Frame Class
 We can create stand-alone AWT based applications.

 A Frame provides main window for the GUI application.

 There are two ways to create a Frame :

1. By instantiating Frame Class

2. By extending Frame class

 Program using Frames
import java.awt.*; public static void main
class First extends Frame{ (String args[]){
First f=new First();
First(){ }
Button b=new Button("click me"); }
b.setBounds(30,100,80,30);
add(b);
setSize(300,300);
setLayout(null);
setVisible(true);
}
AWT Controls
 Controls are components that allow a user to interact with your

application. AWT supports following types of controls

 Labels

 Push Buttons

 Check boxes

 Choice lists

 Lists

 Text Editing (TextField,TextFieldArea)

 Scroll bars
 Adding and Removing Controls
 After creating control that needs to be added to window by calling add()

method which is defined by Container.

 Syntax:

Component add(Component compObj)

 compOb : instance of the control

 A reference to the compObj is returned by add() method

 Once that control is added it is automatically get visible

 Control can be removed by using remove() method defined by Container

class.

 Syntax:

void remove(Component obj)

Label
 The easiest control to use is a label.

 A label is an object of type Label, and it contains a string, which it

displays.

 Labels are passive controls that do not support any interaction

with the user.

Labels : Constructor
 Label defines the following constructors:

 Label( )

 Label(String str)

 Label(String str, int how)

 The first version creates a blank label.

 The second version creates a label that contains the string specified by str. This string is

left-justified.

 The third version creates a label that contains the string specified by str using the

alignment specified by how. The value of how must be one of these three constants:
Label.LEFT, Label.RIGHT, or Label.CENTER.
Label : Methods

 void setText(String str)

 String getText( )

 void setAlignment(int how)

 int getAlignment( )
Label : Program
// Demonstrate Labels
public void init()
import java.awt.*; {
import java.applet.*; Label one = new Label("One");
/* Label two = new Label("Two");
<applet code="LabelDemo" Label three = new Label("Three");
width=300 height=200> // add labels to applet window
</applet> add(one);
*/ add(two);
add(three);
public class LabelDemo extends
Applet }
}
{
Buttons

 The most widely used control is the push button.

 A push button is a component that contains a label and that

generates an event when it is pressed.

 Push buttons are objects of type Button.

 Button defines these two constructors:

 Button( )
 Button(String str)
Buttons : Methods
 String getLabel()

 void setLabel(String str)

 void setEnabled(Boolean enable)

 void addActionListener(ActionListener l)

 void removeActionListener(ActionListener l)

 String getActionCommand()

 void setActionCommand(String Cmd)

 Buttons : Program
Button yes, no, maybe;
// Demonstrate Buttons public void init()
import java.awt.*; {
import java.applet.*; yes = new Button("Yes");
/* no = new Button("No");
<applet code="ButtonDemo" maybe = new Button(“Understand");
width=250 height=150> add(yes);
</applet> add(no);
*/ add(maybe);
public class ButtonDemo extends }
Applet public void paint(Graphics g)
{ {
String msg = ""; g.drawString(msg, 6, 100);
}
}
 Check Boxes
 A check box is a control that is used to turn an option on or off.

 It consists of a small box that can either contain a check mark or

not.
 There is a label associated with each check box that describes what
option the box represents.
 We change the state of a check box by clicking on it. Check boxes
can be used individually or as part of a group.
Checkbox : Constructors

 Checkbox( )

 Checkbox(String str)

 Checkbox(String str, boolean on)

 Checkbox(String str, boolean on, CheckboxGroup cbGroup)

 Checkbox(String str, CheckboxGroup cbGroup, boolean on)

Checkbox : Methods

 boolean getState( )
 void setState(boolean on)
 String getLabel( )
 void setLabel(String str)
 void addItemListener(ItemListener l)
 void removeItemListener(ItemListener l)
 void setCheckboxGroup(CheckboxGroup g)
 CheckboxGroup getCheckboxGroup()
 Checkbox : Program
public void init()
// Demonstrate check boxes. {
import java.awt.*; Win98 = new Checkbox("Windows 98/XP",
import java.applet.*; null, true);
winNT = new Checkbox("Windows
/*
NT/2000");
<applet code="CheckboxDemo" solaris = new Checkbox("Solaris");
width=250 height=200> mac = new Checkbox("MacOS");
</applet> add(Win98);
*/ add(winNT);
public class CheckboxDemo extends add(solaris);
add(mac);
Applet
}
{ public void paint(Graphics g)
String msg = ""; {}
Checkbox Win98, winNT, solaris, mac; }
CheckboxGroup
 It is possible to create a set of mutually exclusive check boxes in

which one and only one check box in the group can be checked
at any one time.

 These check boxes are often called radio button.

 Check box groups are objects of type CheckboxGroup.

 Only the default constructor is defined, which creates an empty

group.
CheckboxGroup : Methods

 Checkbox getSelectedCheckbox( )

 void setSelectedCheckbox(Checkbox wh)

 CheckboxGroup : Program
public void init()
{
import java.awt.*; cbg = new CheckboxGroup();
import java.applet.*;
/* Win98 = new Checkbox("Windows 98/XP", cbg,
<applet code="CBGroup" true);
width=250 height=200> winNT = new Checkbox("Windows NT/2000", cbg,
</applet> false);
*/ solaris = new Checkbox("Solaris", cbg,
public class CBGroup extends Applet
{ false);
String msg = ""; mac = new Checkbox("MacOS", cbg, false);
Checkbox Win98, winNT, add(Win98); add(winNT);
solaris, mac; add(solaris); add(mac);}
CheckboxGroup cbg; public void paint(Graphics g)
{
msg = "Current selection: ";
msg += cbg.getSelectedCheckbox().getLabel();
g.drawString(msg, 6, 100);
}}
 Choice Controls
 The Choice class is used to create a pop-up list of items from which the

user may choose.

 Thus, a Choice control is a form of menu.

 When inactive, a Choice component takes up only enough space to

show the currently selected item.

 Each item in the list is a string that appears as a left justified label in the

order it is added to the Choice object.

 Choice only defines the default constructor, which creates an empty list
Methods

 void add(String name)

 String getSelectedItem( )

 int getSelectedIndex( )

 int getItemCount( )

 void select(int index)

 void select(String name)

 String getItem(int index)

import java.awt.*;
import java.applet.*; os.add("Solaris");
/* os.add("MacOS");
<applet code="ChoiceDemo" browser.add("Netscape 3.x");
width=300 height=180> browser.add("Netscape 4.x");
</applet> browser.add("Netscape 5.x");
*/ browser.add("Netscape 6.x");
public class ChoiceDemo extends browser.add("Internet Explorer 4.0");
Applet browser.add("Internet Explorer 5.0");
{ browser.add("Internet Explorer 6.0");
Choice os, browser; browser.add("Lynx 2.4");
String msg = ""; browser.select("Netscape 4.x");
public void init() add(os);
{ add(browser);
os = new Choice(); }
browser = new Choice(); public void paint(Graphics g)
os.add("Windows 98/XP"); {}}
os.add("Windows NT/2000");
Lists

 The List class provides a compact, multiple-choice, scrolling

selection list.

 Unlike the Choice object, which shows only the single selected

item in the menu, a List object can be constructed to show any

number of choices in the visible Window.

 It can also be created to allow multiple selections.

 List :Constructor

 List( )
 List(int numRows)
 List(int numRows, boolean multipleSelect)

 The first version creates a List control that allows only one item to be
selected at any one time.
 In the second form, the value of numRows specifies the number of
entries in the list that will always be visible (others can be scrolled into
view as needed).
 In the third form, if multipleSelect is true, then the user may select two
or more items at a time.
List : Methods
 void add(String name)

 void add(String name, int index)

 String getSelectedItem( )

 int getSelectedIndex( )

 String[ ] getSelectedItems( )

 int[ ] getSelectedIndexes( )

 int getItemCount( )

 void select(int index)

 String getItem(int index)

 ScrollBars
 Scroll bars are used to select continuous values between a specified

minimum and maximum.

 Scroll bars may be oriented horizontally or vertically.

 A scroll bar is actually a composite of several individual parts.

slider box (or thumb) for the scroll bar.

 The slider box can be dragged by the user to a new position, this

action translates into some form of page up and page down.

ScrollBars : Constructors
 Scrollbar( )

 Scrollbar(int style)

 Scrollbar(int style, int iValue, int tSize, int min, int max)

 The first form creates a vertical scroll bar.

 The second and third forms allow us to specify style Scrollbar.VERTICAL,
Scrollbar.HORIZONTAL.
 In the third form, the initial value of the scroll bar is passed in iValue.
The number of units represented by the height of the thumb is passed in
tSize. The minimum and maximum values for the scroll bar are specified
by min and max.
 ScrollBars : Methods
 void setValues(int iValue, int tSize, int min, int max)

 int getValue( )

 void setValue(int newValue)

 int getMinimum( )

 int getMaximum( )

 void setUnitIncrement(int newIncr)

 void setBlockIncrement(int newIncr)

TextField

 The TextField class implements a single-line text-entry area,

called an edit control.

 Text fields allow the user to enter strings and to edit the text

using the arrow keys, cut and paste keys, and mouse

selections.

 TextField is a subclass of TextComponent.

TextField : Constructors
 TextField( )

 TextField(int numChars)

 TextField(String str)

 TextField(String str, int numChars)

 First creates default text field

 Second form creates a textfield that is numChars characters wide

 Third form initializes textfield with string contained in str

 Fourth form initializes textfield with string contained in str and sets

its width.
TextField : Methods
 String getText( )

 void setText(String str)

 String getSelectedText( )

 void select(int startIndex, int endIndex)

 boolean isEditable( )

 void setEditable(boolean canEdit)

 void setEchoChar(char ch)

 boolean echoCharIsSet( )

 char getEchoChar( )
TextArea
 Sometimes a single line of text input is not enough for a given task.

 To handle these situations, the AWT includes a simple multiline editor called TextArea.

 Following are the constructors for TextArea:

 TextArea( )
 TextArea(int numLines, int numChars)
 TextArea(String str)
 TextArea(String str, int numLines, int numChars)
 TextArea(String str, int numLines, int numChars, int sBars)
Methods
 TextArea is a subclass of TextComponent.
 Therefore, it supports the getText( ), setText( ), getSelectedText(
), select( ), isEditable( ), and setEditable( ) methods as of
TextField.
 TextArea adds the following methods:
 void append(String str)
 void insert(String str, int index)
 void replaceRange(String str, int startIndex, int
endIndex)
Layout Managers
 All components that we have seen so far have been positioned by the
default layout manager
 Layout manager automatically arranges AWT controls within a window
by using some type of algorithm.
 It is possible to layout controls manually, but generally avoided due to:

 Tedious in case of large numbers of controls

 Sometime height and width information is not available

 Each container has a layout manager associated with it.

 Layout Manager is an instance of any class that implements

LayoutManager interface
Layout Managers
 Layout means arranging the components within the container.

 The task of lay outing can be done automatically by the Layout

manager.
 The layout manager is set by the setLayout( ) method.

 If no call to setLayout( ) is made, then the default layout manager

is used.
 Whenever a container is resized (or sized for the first time), the
layout manager is used to position each of the components
within it.
 The setLayout( ) method has the following general form:

void setLayout(LayoutManager layoutObj)

 Here, layoutObj is a reference to the desired layout manager.

 If we wish to disable the layout manager and position

components manually, pass null for layoutObj.

 LayoutManager
 LayoutManager is an interface that is implemented by all the classes

of layout managers. There are following classes that represents the

layout managers:

 FlowLayout

 BorderLayout

 GridLayout

 CardLayout

 GridBagLayout
FlowLayout
 FlowLayout is the default layout manager.

 FlowLayout implements a simple layout style, which is similar to

how words flow in a text editor.
 Components are laid out from the upper-left corner, left to right
and top to bottom.
 When no more components fit on a line, the next one appears on
the next line.
 A small space is left between each component, above and below, as
well as left and right.
 FlowLayout Constructors
 FlowLayout( )
 FlowLayout(int how)
 FlowLayout(int how, int horz, int vert)
 The first is default, which centers components and leaves five
pixels of space between each component.
 The second form lets us specify how each line is aligned. Valid
values for how are as follows:
 FlowLayout.LEFT
 FlowLayout.CENTER
 FlowLayout.RIGHT
 The third form allows us to specify the horizontal and vertical
space left between components
FlowLayout Methods
 int getAlignment()
 int getHgap()
 int getVgap()
 int setAlignment(int align)
 int setHgap(int hgap)
 int setVgap(int vgap)
public class FlowLayoutDemo extends Applet
{
Checkbox Win98, winNT, solaris, mac;
public void init()
{
Win98 = new Checkbox("Windows 98/XP", null, true);
winNT = new Checkbox("Windows NT/2000");
solaris = new Checkbox("Solaris");
mac = new Checkbox("MacOS");
setLayout(new FlowLayout(FlowLayout.CENTER));
add(Win98); add(winNT);add(solaris);add(mac);
}}
BorderLayout
 The BorderLayout class implements a common layout style
for top-level windows.
 It has four narrow, fixed-width components at the edges and
one large area in the center.
 The four sides are referred to as
 north,
 south,
 east, and
 west.
 The middle area is called the center.
BorderLayout Constructors
 BorderLayout( )
 BorderLayout(int horz, int vert)

 The first form creates a default border layout.

 The second allows us to specify the horizontal and vertical
space left between components in horz and vert, respectively.
 BorderLayout
• BorderLayout defines the following constants that specify the
regions:
• BorderLayout.CENTER
• BorderLayout.SOUTH
• BorderLayout.EAST
• BorderLayout.WEST
• BorderLayout.NORTH
• To add components, we use these constants with the following form
of add( ), which is defined by Container:
• void add(Component compObj, Object region);
• Here, compObj is the component to be added, and region specifies
where the component will be added.
public class BorderLayoutDemo extends Applet {
public void init() {
setLayout(new BorderLayout());
add(new Button("This is across the top."), BorderLayout.NORTH);
add(new Label("The footer message."), BorderLayout.SOUTH);
add(new Button("Right"), BorderLayout.EAST);
add(new Button("Left"), BorderLayout.WEST);
String msg = "The reasonable man adapts himself to the world;\n" +
"the unreasonable one persists in trying to adapt the world to himself.\n" +
"Therefore all progress depends on the unreasonable man.\n\n" + " - George
Bernard Shaw\n\n";
add(new TextArea(msg), BorderLayout.CENTER);
}
}
GridLayout
 GridLayout lays out components in a two-dimensional grid.
 When we instantiate a GridLayout, we define the number of
rows and columns.
 GridLayout constructors
 GridLayout( )
 GridLayout(int numRows, int numColumns )
 GridLayout(int numRows, int numColumns, int horz, int vert)
 The first form creates a single-column grid layout.
 The second creates a grid layout with specified number of rows and
columns.
 Either numRows or numColumns can be zero.
 Specifying numRows as zero allows for unlimited-length columns.
 Specifying numColumns as zero allows for unlimited-length rows.
public class GridLayoutDemo extends Applet {
static final int n = 4;
public void init(){
setLayout(new GridLayout(n, n));
setFont(new Font("SansSerif", Font.BOLD, 24));
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
int k = i * n + j;
if(k > 0)
add(new Button("" + k));
} }}}
 CardLayout
 The CardLayout class is unique among the other layout managers
in that it stores several different layouts.
 Each layout can be thought of as being on a separate index card in a
deck that can be shuffled so that any card is on top at a given time.
 This can be useful for user interfaces with optional components
that can be dynamically enabled and disabled upon user input.
 We can prepare the other layouts and have them hidden, ready to
be activated when needed.
 CardLayout provides these two constructors:
 CardLayout( )
 CardLayout(int horz, int vert)
 The first form creates a default card layout.
 The second form allows us to specify the horizontal and vertical
space left between components.
Methods
 void add(Component panelObj, Object name);
 Here name is a string that specifies the name of the card whose
panel is specified by panelObj. After we have created a deck, our
program activates a card by calling one of the following methods:
 void first(Container deck)
 void last(Container deck)
 void next(Container deck)
 void previous(Container deck)
 void show(Container deck, String cardName)
 deck is a reference to the container (usually a panel) that holds the
cards, and cardName is the name of a card.
• // Demonstrate CardLayout.
import java.awt.*;
import java.awt.event.*;
public class CardLayoutExample extends Frame implements Action
Listener{
CardLayout card;
Button b1,b2,b3;
CardLayoutExample(){
card=new CardLayout(40,30);
setLayout(card);
b1=new Button("Apple");
b2=new Button("Boy");
b3=new Button("Cat");
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
add(b1,”card1”); add(b2,”card2”); add(b3,”card3”); }
public void actionPerformed(ActionEvent e) {
card.next(this);
}
public static void main(String[] args) {
CardLayoutExample cl=new CardLayoutExample();
cl.setSize(400,400);
cl.setVisible(true);
} }
 GridBagLayout
 Each GridBagLayout object maintains a dynamic rectangular
grid of cells, with each component occupying one or more
cells, called its display area.

 Each component managed by a grid bag layout is associated

with an instance of GridBagConstraints that specifies how the
component is laid out within its display area.
 For customize a GridBagConstraints object by setting one or
more of its instance variables:
 gridx, gridy: Specifies the cell at the upper left of the
component's display area, where the upper-left-most cell has
address gridx = 0, gridy = 0.
 gridwidth, gridheight: Specifies the number of cells in a row (for
gridwidth) or column (for gridheight) in the component's display
area. The default value is 1.
 fill: Used when the component's display area is larger than the
component's requested size to determine whether (and how) to
resize the component.
import java.awt.*;
import java.util.*;
import java.applet.Applet;
public class GridBagEx1 extends Applet {
protected void makebutton(String name,
GridBagLayout gridbag,
GridBagConstraints c) {
Button button = new Button(name);
gridbag.setConstraints(button, c);
add(button);
}
public void init() {
GridBagLayout gridbag = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
setLayout(gridbag);
c.fill = GridBagConstraints.BOTH;
c.weightx = 1.0;
makebutton("Button1", gridbag, c);
makebutton("Button2", gridbag, c);
makebutton("Button3", gridbag, c);
c.gridwidth = GridBagConstraints.REMAINDER; //end row
makebutton("Button4", gridbag, c);
c.weightx = 0.0; //reset to the default
makebutton("Button5", gridbag, c); //another row
}
public static void main(String args[]) {
Frame f = new Frame("GridBag Layout Example");
GridBagEx1 ex1 = new GridBagEx1();
ex1.init(); f.add("Center", ex1); f.pack();
f.resize(f.preferredSize());
f.show(); } }
 Menu Bars and Menus
 A menu bar displays a list of top-level menu choices. Each choice
is associated with a dropdown menu.
 This concept is implemented in Java by the following classes:

 MenuBar, Menu, and MenuItem.

 In general, a menu bar contains one or more Menu objects. Each

Menu object contains a list of MenuItem objects. Each
MenuItem object represents something that can be selected by
the user.
 MenuBar Class Defines only default constructor.

 Menu Class Constructors

 Menu( )

 Menu(String optionName)

 Menu(String optionName, boolean removable)

 Here, optionName specifies the name of the menu selection.

 Individual menu items constructors:

 MenuItem( )

 MenuItem(String itemName)

 MenuItem(String itemName, MenuShortcut keyAccel)

 Methods
 Disable or enable a menu item by using:
 void setEnabled(boolean enabledFlag)
 boolean isEnabled( )
 Label set and get using:
 void setLabel(String newName)
 String getLabel( )
 Checkable menu item by using a subclass of MenuItem called
CheckboxMenuItem. :
 CheckboxMenuItem( )
 CheckboxMenuItem(String itemName)
 CheckboxMenuItem(String itemName, boolean on)
Methods
 Status about checkable MenuItem:
 boolean getState( )
 void setState(boolean checked)
 For add MenuItem:
 MenuItem add(MenuItem item)
 For add MenuBar
 Menu add(Menu menu)
 To get Item from Menu:
 Object getItem( )
import java.awt.*;
menu.add(i1);
class MenuExample menu.add(i2); menu.add(i3); submenu.add(
{ i4);
submenu.add(i5);
MenuExample(){
menu.add(submenu);
Frame f= new Frame("Menu Example"); mb.add(menu);
MenuBar mb=new MenuBar(); f.setMenuBar(mb);
f.setSize(400,400);
Menu menu=new Menu("Menu"); f.setLayout(null);
Menu submenu=new Menu("Sub Menu"); f.setVisible(true);
MenuItem i1=new MenuItem("Item 1"); }
public static void main(String args[]) {
MenuItem i2=new MenuItem("Item 2"); new MenuExample();
MenuItem i3=new MenuItem("Item 3"); } }
MenuItem i4=new MenuItem("Item 4");
MenuItem i5=new MenuItem("Item 5");
 DialogBox
 Dialog boxes are primarily used to obtain user input.

 They are similar to frame windows, except that dialog boxes are
always child windows of a top-level window.
 Dialog boxes don’t have menu bars.

 In other respects, dialog boxes function like frame windows.

 Dialog boxes may be modal or modeless.

 When a modal dialog box is active, all input is directed to it until it is

closed.
 When a modeless dialog box is active, input focus can be directed to
another window in your program.
 DialogBox : Constructor
 Constructors

 Dialog(Frame parentWindow, boolean mode)

 Dialog(Frame parentWindow, String title, boolean mode)

 To create Dialog Box:

 Create Frame or Applet

 Create another class which extends Dialog class.

 Call this new class from Frame/Applet class.

 In constructor of Extended Dialog class, use super method and pass values
to constructor of Dialog
import java.awt.*;
import java.awt.event.*;
public class DialogExample {
private static Dialog d;
DialogExample() {
Frame f= new Frame();
d = new Dialog(f , "Dialog Example", true);
d.setLayout( new FlowLayout() );
Button b = new Button ("OK");
b.addActionListener ( new ActionListener()
{ public void actionPerformed( ActionEvent e )
{ DialogExample.d.setVisible(false); }
});
d.add( new Label ("Click button to continue."));
d.add(b); d.setSize(300,300);
d.setVisible(true); }
FileDialog
 Java provides a built-in dialog box that lets the user specify a file.
 To create a file dialog box, instantiate an object of type
FileDialog.
 Usually this is standard dialog box provided by OS
 Constructor:
 FileDialog(Frame parent, String boxName)
 FileDialog(Frame parent, String boxName, int how)
 FileDialog(Frame parent)
 Int how: FileDialog.LOAD, FileDialog.SAVE
 Methods:
 String getDirectory( )
 String getFile( )
import java.awt.*;
class SampleFrame extends Frame
{
SampleFrame(String title){
super(title); }}
class FileDialogDemo
{public static void main(String args[]){
Frame f = new SampleFrame("File Dialog Demo");
f.setVisible(true);
f.setSize(100, 100);
FileDialog fd = new FileDialog(f, "File Dialog");
fd.setVisible(true);
}}