The AWT Event Model 9

Similar documents
GUI Event Handling 11. GUI Event Handling. Objectives. What is an Event? Hierarchical Model (JDK1.0) Delegation Model (JDK1.1)

Advanced Java Programming (17625) Event Handling. 20 Marks

Interacción con GUIs

11/7/12. Discussion of Roulette Assignment. Objectives. Compiler s Names of Classes. GUI Review. Window Events

Handling Mouse and Keyboard Events

GUI Program Organization. Sequential vs. Event-driven Programming. Sequential Programming. Outline

Example Programs. COSC 3461 User Interfaces. GUI Program Organization. Outline. DemoHelloWorld.java DemoHelloWorld2.java DemoSwing.

Java Graphical User Interfaces AWT (Abstract Window Toolkit) & Swing

Method Of Key Event Key Listener must implement three methods, keypressed(), keyreleased() & keytyped(). 1) keypressed() : will run whenever a key is

GUI in Java TalentHome Solutions

Event Driven Programming

GUI DYNAMICS Lecture July 26 CS2110 Summer 2011

GUI Event Handlers (Part I)

BM214E Object Oriented Programming Lecture 13

Control Flow: Overview CSE3461. An Example of Sequential Control. Control Flow: Revisited. Control Flow Paradigms: Reacting to the User

UNIT-3 : MULTI THREADED PROGRAMMING, EVENT HANDLING. A Multithreaded program contains two or more parts that can run concurrently.

COMPSCI 230. Software Design and Construction. Swing

Module 4 Multi threaded Programming, Event Handling. OOC 4 th Sem, B Div Prof. Mouna M. Naravani

Dr. Hikmat A. M. AbdelJaber

Chapter 1 GUI Applications

Assignment No 2. Year: Dept.: ComputerTech. Sanjivani Rural Education Society s Sanjivani KBP Polytechnic, Kopargaon

GUI Programming: Swing and Event Handling

Which of the following syntax used to attach an input stream to console?

Packages: Putting Classes Together

G51PGP Programming Paradigms. Lecture 008 Inner classes, anonymous classes, Swing worker thread

CSEN401 Computer Programming Lab. Topics: Graphical User Interface Window Interfaces using Swing

(listener)... MouseListener, ActionLister. (adapter)... MouseAdapter, ActionAdapter. java.awt AWT Abstract Window Toolkit GUI

Advanced Java Programming

SD Module-1 Advanced JAVA

SD Module-1 Advanced JAVA. Assignment No. 4

Bean Communication. COMP434B Software Design. Bean Communication. Bean Communication. Bean Communication. Bean Communication

Graphical User Interfaces 2

10/16/2008. CSG 170 Round 5. Prof. Timothy Bickmore. User Analysis Task Analysis (6) Problem Scenarios (3)

Išdėstymai. Lekt. dr. Pijus Kasparaitis m. m. pavasario semestras.

Event Binding. Different Approaches Global Hooks. 2.5 Event Binding 1

Graphical User Interfaces 2

OBJECT ORIENTED PROGRAMMING. Java GUI part 1 Loredana STANCIU Room B616

Computer Programming Java AWT Lab 18

กล ม API ท ใช. Programming Graphical User Interface (GUI) Containers and Components 22/05/60

Graphical User Interfaces 2

Graphical Interfaces

Graphical Interfaces

public void mouseexited (MouseEvent e) setminute(getminute()+increment); 11.2 public void mouseclicked (MouseEvent e) int x = e.getx(), y = e.gety();

Previously, we have seen GUI components, their relationships, containers, layout managers. Now we will see how to paint graphics on GUI components

GUI Event Handlers (Part II)

GUI 4.1 GUI GUI MouseTest.java import javax.swing.*; import java.awt.*; import java.awt.event.*; /* 1 */

CSE 331 Software Design & Implementation

Programming Mobile Devices J2SE GUI

Lecture 19 GUI Events

G51PRG: Introduction to Programming Second semester Applets and graphics

PESIT Bangalore South Campus

Java - Applications. The following code sets up an application with a drop down menu, as yet the menu does not do anything.

3 Events and Listeners

Java Event Handling -- 1

Java for Interfaces and Networks (DT3010, HT10)

CSE 143. Event-driven Programming and Graphical User Interfaces (GUIs) with Swing/AWT

IPM 12/13 P4 Handling Events in AWT

Programming Languages and Techniques (CIS120e)

AP Computer Science Unit 13. Still More Graphics and Animation.

Unit 7: Event driven programming

CS 251 Intermediate Programming GUIs: Event Listeners

CS211 GUI Dynamics. Announcements. Motivation/Overview. Example Revisted

Outline. Topic 9: Swing. GUIs Up to now: line-by-line programs: computer displays text user types text AWT. A. Basics

Java AWT Windows, Text, & Graphics

Virtualians.ning.pk. 2 - Java program code is compiled into form called 1. Machine code 2. native Code 3. Byte Code (From Lectuer # 2) 4.

CSE 331 Software Design and Implementation. Lecture 19 GUI Events

CS 106A, Lecture 14 Events and Instance Variables

GUI Design. Overview of Part 1 of the Course. Overview of Java GUI Programming

Event Handling in JavaFX

CS11 Java. Fall Lecture 3

Course: CMPT 101/104 E.100 Thursday, November 23, 2000

Cheng, CSE870. More Frameworks. Overview. Recap on OOP. Acknowledgements:

Table of Contents. Chapter 1 Getting Started with Java SE 7 1. Chapter 2 Exploring Class Members in Java 15. iii. Introduction of Java SE 7...

JAVA. Object Oriented Programming with. M.T. Somashekara D.S.Guru K.S. Manjunatha

Inheritance. One class inherits from another if it describes a specialized subset of objects Terminology:

Come & Join Us at VUSTUDENTS.net

MIT AITI Swing Event Model Lecture 17

CSE 331. Event-driven Programming and Graphical User Interfaces (GUIs) with Swing/AWT

Events. Dispatch, event-to-code binding. Review: Events Defined 1/17/2014. occurrence.

CS 106A, Lecture 14 Events and Instance Variables

CSA 1019 Imperative and OO Programming

Java: Graphical User Interfaces (GUI)

ECE 462 Object-Oriented Programming using C++ and Java. Key Inputs in Java Games

14.2 Java s New Nimbus Look-and-Feel 551 Sample GUI: The SwingSet3 Demo Application As an example of a GUI, consider Fig. 14.1, which shows the SwingS

Event driven Programming

user-friendly and easy to use.

Programmierpraktikum

Marcin Luckner Warsaw University of Technology Faculty of Mathematics and Information Science

Java GUI Design: the Basics

Java Mouse Actions. C&G criteria: 5.2.1, 5.4.1, 5.4.2,

Java. GUI building with the AWT

GUI Software Architecture

CS 201 Advanced Object-Oriented Programming Lab 10 - Recursion Due: April 21/22, 11:30 PM

CPS122 Lecture: Graphical User Interfaces and Event-Driven Programming

Overloading Example. Overloading. When to Overload. Overloading Example (cont'd) (class Point continued.)

Course Status Networking GUI Wrap-up. CS Java. Introduction to Java. Andy Mroczkowski

1 GUI GUI GUI GUI GUI. GUI(Graphical User Interface) JDK java.awt. ? Component

CHAPTER 2. Java Overview

User interfaces and Swing

CSIS 10A Assignment 14 SOLUTIONS

Transcription:

The AWT Event Model 9 Course Map This module covers the event-based GUI user input mechanism. Getting Started The Java Programming Language Basics Identifiers, Keywords, and Types Expressions and Flow Control Arrays Object-Oriented Programming Objects and Classes Advanced Language Features Exception Handling Exceptions Developing Graphical User Interfaces Building GUIs The AWT Event Model The AWT Component Library Java Foundation Classes Applets Introduction to Java Applets Multithreading Threads Communications Stream I/O and Files Networking 9-1

Relevance Discussion The following questions are relevant to the material presented in this module. What parts are required for a GUI to make it useful? How does a graphical program handle a mouse click or any other type of user interaction? 9-2 Java Programming

Objectives Upon completion of this module, you should be able to Write code to handle events that occur in a GUI Describe the concept of adapter classes, including how and when to use them. Determine the user action that originated the event from the event object details Create the appropriate interface and event handler methods for a variety of event types. The AWT Event Model 9-3

What Is an Event? When the user performs an action at the user interface level (clicks a mouse or presses a key), this causes an event to be issued. Events are objects that describe what has happened. A number of different types of event classes exist to describe different categories of user action. 9-4 Java Programming

What Is an Event? Event Sources An event source is the generator of an event. For example, a mouse click on a Button component will generate an ActionEvent with the button as the source. The ActionEvent instance is an object that contains information about the events that just took place. It contains: getactioncommand Returns the command name associated with the action. getmodifiers Return any modifiers held during the action. Event Handlers An event handler is a method that receives an event object, deciphers it, and processes the user s interaction. The AWT Event Model 9-5

JDK 1.0 Event Model Versus JDK 1.2 Event Model In JDK 1.1, significant changes in the way that events are received and processed were introduced. This section compares the previous event model (JDK 1.0) to the current event model (JDK 1.1 and JDK 1.2). JDK 1.0 uses a hierarchical event model, while JDK 1.1 and beyond use a delegation event model. Hierarchical Model (JDK 1.0) The hierarchical event model is based on containment. Events are sent to the component first, but then propagate up the containment hierarchy. Events that are not handled by the component will automatically continue to propagate to the component s container. 9-6 Java Programming

JDK 1.0 Event Model Versus JDK 1.2 Event Model For example, in the following figure, a mouse click on the Button object (contained by a Panel on a Frame) sends an action event to the Button first. If it is not handled by the Button, the event is then sent to the Panel, and if it is not handled there, the event is sent to the Frame. Frame Panel Button Action event The AWT Event Model 9-7

JDK 1.0 Event Model Versus JDK 1.2 Event Model Hierarchal Model (JDK 1.0) (Continued) There is an obvious advantage to this model: It is simple and well-suited to an object-oriented programming environment; after all, Java software components extend from the java.awt.component class, which is where the handleevent() method is. There are, however, some disadvantages: The event can be handled only by the component from where it originates or by one of the containers that contains it. This restriction violates one of the fundamental principles of objectoriented programming: functionality should reside in the most appropriate class. Often the most appropriate class for handling an event is not a member of the originating component s containment hierarchy. 9-8 Java Programming

DK 1.0 Event Model Versus JDK 1.2 Event Model Hierarchal Model (JDK 1.0) (Continued) A large number of CPU cycles are wasted on unrelated events. Any event unrelated or unimportant to the program would ripple all the way through the containment hierarchy before eventually being discarded. There is no simple way to filter events. In order to handle events, you must either subclass the component that receives the event or create a big handleevent() method at the base container. The AWT Event Model 9-9

JDK 1.0 Event Model Versus JDK 1.2 Event Model Delegation Model (JDK 1.1 and Beyond) The delegation event model came into existence with JDK 1.1. With this model, events are sent to the component from which the event originated, but it is up to each component to register one or more classes called listeners, which contain event handlers that can receive and process the event. In this way the event handler can be in an object separate from the component. Listeners are classes which implement the Listener interface. Frame Panel and Frame event handlers Panel Action event Button Action handler actionperformed (ActionEvent e) {... } Events are objects that are only reported to registered listeners. Every event has a corresponding listener interface which mandates which methods must be defined in a class suited to receiving that type of event. The class that implements the interface defines those methods, and can be registered as a listener. Events from components which have no registered listeners are not propagated. 9-10 Java Programming

JDK 1.0 Event Model Versus JDK 1.2 Event Model Delegation Model (JDK 1.1 and Beyond) (Continued) For example, here is a simple Frame with a single Button on it: 1 import java.awt.*; 2 3 public class TestButton { 4 public static void main(string args[]) { 5 Frame f = new Frame("Test"); 6 Button b = new Button("Press Me!"); 7 b.addactionlistener(new ButtonHandler()); 8 f.add(b,"center"); 9 f.pack(); 10 f.setvisible(true); 11 } 12 } The ButtonHandler class is the handler class to which the event will be delegated. 1 import java.awt.event.*; 2 3 public class ButtonHandler implements ActionListener { 4 public void actionperformed(actionevent e) { 5 System.out.println("Action occurred"); 6 System.out.println("Button s label is : 7 + e.getactioncommand()); 8 } 9 } These two examples have the following characteristics: The Button class has an addactionlistener(actionlistener) method. The ActionListener interface defines a single method, actionperformed, which will receive an ActionEvent. When a Button object is created, that object can register as a listener for ActionEvents through the addactionlistener method. The method is invoked with a parameter of the class that implements the ActionListener interface. The AWT Event Model 9-11

JDK 1.0 Event Model Versus JDK 1.2 Event Model Delegation Model (JDK 1.1 and Beyond) (Continued) When the Button object is clicked on with the mouse, an ActionEvent is sent. The ActionEvent is recieved through the actionperformed() method of any ActionListener that is registered through the addactionlistener() method. The method getactioncommand() of ActionEvent class returns the command name associated with this action. The button click action, for example, returns the label on the Button. There are several advantages to this approach: Events are not accidentally handled. In a hierarchical model it is possible for an event to propagate to a container and get handled at a level that is not expected. It is possible to create filter (adapter) classes to classify event actions. 9-12 Java Programming

JDK 1.0 Event Model Versus JDK 1.2 Event Model Delegation Model (JDK 1.1 and Beyond) (Continued) The delegation model is much better for the distribution of work among classes. The new event model provides support for JavaBeans. There is also a disadvantage to this approach: Although the current JDK supports the JDK 1.0 event model in addition to the delegation model, the JDK 1.0 and JDK 1.1 event models cannot be mixed. The AWT Event Model 9-13

GUI Behavior Event Categories The general mechanism for receiving events from components has been described in the context of a single type of event. The hierarchy of event classes is as shown below. Many of the event classes reside in the java.awt.event package, but others exist elsewhere in the API. java.util.eventobject java.awt.awtevent ActionEvent AdjustmentEvent ComponentEvent ItemEvent ContainerEvent FocusEvent InputEvent WindowEvent KeyEvent MouseEvent TextEvent java.beans.beancontext BeanContextEvent... For each category of events, there is an interface that has to be implemented by the class of objects that wants to receive the events. That interface demands that one or more methods be defined too. Those methods will be called when particular events arise. Table 9-1 lists the categories, giving the interface name for each category and the methods demanded. The method names are mnemonic, indicating the source or conditions that will cause the method to be called. 9-14 Java Programming

GUI Behavior Table 9-1 Method Categories and Interfaces Category Interface Name Methods Action ActionListener actionperformed(actionevent) Item ItemListener itemstatechanged(itemevent) Mouse motion Mouse button MouseMotionListener MouseListener mousedragged(mouseevent) mousemoved(mouseevent) mousepressed(mouseevent) mousereleased(mouseevent) mouseentered(mouseevent) mouseexited(mouseevent) mouseclicked(mouseevent) Key KeyListener keypressed(keyevent) keyreleased(keyevent) keytyped(keyevent) Focus FocusListener focusgained(focusevent) focuslost(focusevent) Adjustment AdjustmentListener adjustmentvaluechanged (AdjustmentEvent) Component ComponentListener componentmoved(componentevent) componenthidden(componentevent) componentresized(componentevent) componentshown(componentevent) The AWT Event Model 9-15

GUI Behavior Table 9-1 Method Categories and Interfaces (Continued) Category Interface Name Methods Window WindowListener windowclosing(windowevent) windowopened(windowevent) windowiconified(windowevent) windowdeiconified(windowevent) windowclosed(windowevent) windowactivated(windowevent) windowdeactivated(windowevent) Container ContainerListener componentadded(containerevent) componentremoved(containerevent) Text TextListener textvaluechanged(textevent) 9-16 Java Programming

GUI Behavior Complex Example This section examines a more complex Java code software example. It tracks the movement of the mouse when the mouse button is pressed (mouse dragging). It also detects mouse movement even when the buttons are not pressed (mouse moving). The events caused by moving the mouse with or without a button pressed can be picked up by objects of a class that implements the MouseMotionListener interface. This interface requires two methods, mousedragged() and mousemoved(). Even if you are only interested in the drag movement, both methods must be provided. The body of the mousemoved() method can be empty, however. To pick up other mouse events, including mouse clicking, the MouseListener interface must be implemented. This interface includes several events including mouseentered, mouseexited, mousepressed, mousereleased, and mouseclicked. When mouse or keyboard events occur, information about the position of the mouse and the key that was pressed is available in the event that it generated. This is the code: 1 import java.awt.*; 2 import java.awt.event.*; 3 4 public class TwoListen implements 5 MouseMotionListener, MouseListener { 6 private Frame f; 7 private TextField tf; 8 9 public static void main(string args[]) { 10 TwoListen two = new TwoListen(); 11 two.go(); 12 } 13 The AWT Event Model 9-17

GUI Behavior Complex Example (Continued) 14 public void go() { 15 f = new Frame("Two listeners example"); 16 f.add (new Label ("Click and drag the mouse"), 17 "BorderLayout.NORTH"); 18 tf = new TextField (30); 19 f.add (tf, "BorderLayout.SOUTH"); 20 21 f.addmousemotionlistener(this); 22 f.addmouselistener (this); 23 f.setsize(300, 200); 24 f.setvisible(true); 25 } 26 27 // These are MouseMotionListener events 28 public void mousedragged (MouseEvent e) { 29 String s = 30 "Mouse dragging: X = " + e.getx() + 31 " Y = " + e.gety(); 32 tf.settext (s); 33 } 34 35 public void mousemoved (MouseEvent e) { 36 } 37 38 // These are MouseListener events 39 public void mouseclicked (MouseEvent e) { 40 } 41 42 public void mouseentered (MouseEvent e) { 43 String s = "The mouse entered"; 44 tf.settext (s); 45 } 9-18 Java Programming

GUI Behavior Complex Example (Continued) 46 public void mouseexited (MouseEvent e) { 47 String s = "The mouse has left the building"; 48 tf.settext (s); 49 } 50 51 public void mousepressed (MouseEvent e) { 52 } 53 54 public void mousereleased (MouseEvent e) { 55 } 56 } A number of points in this example should be noted. These are discussed in the following sections. Declaring Multiple Interfaces The class is declared in line 4 using the following: implements MouseMotionListener, MouseListener Multiple interfaces can be declared by using comma separation. Listening to Multiple Sources If you issue the following method calls in lines 21 and 22: f.addmouselistener(this); f.addmousemotionlistener(this); both types of events cause methods to be called in the TwoListen class. An object can listen to as many event sources as required; its class need only implement the required interfaces. The AWT Event Model 9-19

GUI Behavior Complex Example (Continued) Obtaining Details About the Event The event arguments with which handler methods such as mousedragged() are called contain potentially important information about the original event. To determine the details of what information is available for each category of event, you should check the appropriate class documentation in the java.awt.event package. 9-20 Java Programming

GUI Behavior Multiple Listeners The AWT event listening framework actually allows multiple listeners to be attached to the same component. In general, if you want to write a program that performs multiple actions based on a single event, code that behavior into your handler method. However, sometimes a program s design requires multiple unrelated parts of the same program to react to the same event. This might happen if, for instance, a context-sensitive help system is being added to an existing program. The listener mechanism allows you to call an addxxxlistener method as many times as is needed, and you can specify as many different listeners as your design requires. All registered listeners will have their handler methods called when the event occurs. The AWT Event Model 9-21

GUI Behavior Multiple Listeners (Continued) Note The order in which the handler methods are called is undefined. Generally, if the order of invocation matters, then the handlers are not unrelated. In this case, register only the first listener, and have that one call the others directly. 9-22 Java Programming

Event Adapters It is a lot of work to have to implement all of the methods in each of the Listener interfaces, particularly the MouseListener interface and ComponentListener interface. The MouseListener interface, for example, defines the following methods: mouseclicked (MouseEvent) mouseentered (MouseEvent) mouseexited (MouseEvent) mousepressed (MouseEvent) mousereleased (MouseEvent) The AWT Event Model 9-23

Event Adapters As a convenience, the Java programming language provides adapter classes which implement each interface containing more than one method. The methods in these adapter classes are empty. You can extend the Adapter class and override only those methods that you need. For example: 1 import java.awt.*; 2 import java.awt.event.*; 3 4 public class MouseClickHandler extends MouseAdapter { 5 6 // We just need the mouseclick handler, so we use 7 // the Adapter to avoid having to write all the 8 // event handler methods 9 public void mouseclicked (MouseEvent e) { 10 // Do something with the mouse click... 11 } 12 } 9-24 Java Programming

Anonymous Classes It is possible to include an entire class definition within the scope of an expression. This approach defines what is called an anonymous class and creates the instance all at once. Anonymous classes are generally used in conjuction with AWT event handling. For example: 1 import java.awt.*; 2 import java.awt.event.*; 3 public class AnonTest { 4 private Frame f; 5 private TextField tf; 6 7 public static void main(string args[]) 8 { 9 AnonTest obj = new AnonTest(); 10 obj.go(); 11 } 12 The AWT Event Model 9-25

Anonymous Classes 13 public void go() { 14 f = new Frame("Anonymous classes example"); 15 f.add(new Label("Click and drag the " + 16 " mouse",borderlayout.north); 17 tf = new TextField (30); 18 f.add(tf,borderlayout.south); 19 20 f.addmousemotionlistener (new 21 MouseMotionAdapter() { 22 public void mousedragged (MouseEvent e) { 23 String s = 24 "Mouse dragging: X = " + e.getx() + 25 " Y = " + e.gety(); 26 tf.settext (s); 27 } 28 } ); // <- note the closing parenthesis 29 30 f.addmouselistener (new MouseClickHandler()); 31 f.setsize(300, 200); 32 f.setvisible(true); 33 } 34 } 9-26 Java Programming

Exercise: Working With Events Exercise objective You will write, compile and run the revised Calculator GUI and Account GUI codes to include event handlers. Preparation In order to successfully complete this lab, you must have a clear understanding of how the event model works. Tasks Level 1 Lab: Create a Calculator GUI, Part II 1. Using the GUI code you created from the Module 8 exercise, write an event code that connects the calculator s user interface to the appropriate event handlers for the functions on a calculator. Level 3 Lab: Create an Account GUI, Part II 1. Create an AccountEvent class, objects of which are fired when changes to accounts occur. Then fire the events to the BankManager class. Begin with the Teller.java GUI code you created for the Module 8 lab. The AWT Event Model 9-27

Exercise: Working With Events Exercise Summary Discussion Take a few minutes to discuss what experiences, issues, or discoveries you had during the lab exercises. Experiences Interpretations Conclusions Applications 9-28 Java Programming

Check Your Progress Before continuing on to the next module, check to be sure that you can Write code to handle events that occur in a GUI Describe the concept of adapter classes, including how and when to use them Determine the user action that originated the event from the event object details Create the appropriate interface and event handler methods for a variety of event types. The AWT Event Model 9-29

Think Beyond You now know how to set up a Java software GUI for both graphic output and interactive user input. However, only a few of the components from which GUIs can be built have been described. What other components would be useful in a GUI? 9-30 Java Programming