CSE 331 Software Design & Implementation Dan Grossman Spring 2015 GUI Event-Driven Programming (Based on slides by Mike Ernst, Dan Grossman, David Notkin,

Slides:



Advertisements
Similar presentations
Event handling and listeners What is an event? user actions and context event sources and listeners Why should my programs be event- driven? User interaction.
Advertisements

Mouse Listeners We continue our examination of GUIs by looking at how to interact with the mouse –Just as Java creates Events when the user interacts with.
1 Frameworks. 2 Framework Set of cooperating classes/interfaces –Structure essential mechanisms of a problem domain –Programmer can extend framework classes,
Event Handling. In this class we will cover: Basics of event handling The AWT event hierarchy Semantic and low-level events in the AWT.
Event Handling Events and Listeners Timers and Animation.
Events ● Anything that happens in a GUI is an event. For example: – User clicks a button, presses return when typing text, or chooses a menu item ( ActionEvent.
Event-Driven Programming
Graphical User Interface (GUI) Nelson Padua-Perez Chau-Wen Tseng Department of Computer Science University of Maryland, College Park.
Lecture 18 Review the difference between abstract classes and interfaces The Cloneable interface Shallow and deep copies The ActionListener interface,
Object-Oriented Analysis and Design
ACM/JETT Workshop - August 4-5, ExceptionHandling and User Interfaces (Event Delegation, Inner classes) using Swing.
Welcome to CIS 083 ! Events CIS 068.
1 CSC111H Graphical User Interfaces (GUIs) Introduction GUIs in Java Understanding Events A Simple Application The Containment Hierarchy Layout Managers.
(c) University of Washington08-1 CSC 143 Models and Views Reading: Ch. 18.
Liang, Introduction to Java Programming, Eighth Edition, (c) 2011 Pearson Education, Inc. All rights reserved Event Driven Programming, The.
Java Programming: Guided Learning with Early Objects
CS 11 java track: lecture 4 This week: arrays interfaces listener classes inner classes GUI callbacks.
Java GUI’s are event driven, meaning they generate events when the user interacts with the program. Typical events are moving the mouse, clicking a mouse.
(c) University of Washington07b-1 CSC 143 Java Events, Event Handlers, and Threads Reading: Ch. 17.
Dale Roberts GUI Programming using Java - Event Handling Dale Roberts, Lecturer Computer Science, IUPUI Department of Computer.
GUIs in Java Swing, Events CS2110, SW Development Methods Readings: MSD, Chapter 12 Lab Exercise.
Ch 3-4: GUI Basics Java Software Solutions Foundations of Program Design Sixth Edition by Lewis & Loftus Coming up: GUI Components.
– Advanced Programming P ROGRAMMING IN Lecture 21 Introduction to Swing.
1 Outline 1 Introduction 2 Overview of Swing Components 3 JLabel 4 Event Handling 5 TextFields 6 How Event Handling Works 7 JButton 8 JCheckBox and JRadioButton.
Graphic User Interface. Graphic User Interface (GUI) Most of us interact with computers using GUIs. GUIs are visual representations of the actions you.
Graphics and Event-Driven Programming in Java John C. Ramirez Department of Computer Science University of Pittsburgh.
MSc Workshop - © S. Kamin, U.Reddy Lect 4 - Events - 1 Lecture 4 – Event Handling r Painting r Event types r Catching different event types.
COMP 321 Week 2. Outline Event-Driven Programming Events, Event Sources, Event Listeners Button and Timer Events Mouse Events, Adapters.
Concurrent Programming and Threads Threads Blocking a User Interface.
Omer Boyaci.  GUIs are event driven.  When the user interacts with a GUI component, the interaction—known as an event—drives the program to perform.
Object-Oriented Program Development Using Java: A Class-Centered Approach, Enhanced Edition.
© Copyright by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved. 1 Outline 21.1 Test-Driving the Painter Application.
Creating a GUI with JFC/Swing. What are the JFC and Swing? JFC –Java Foundation Classes –a group of features to help people build graphical user interfaces.
UID – Event Handling and Listeners Boriana Koleva
CS-1020 Dr. Mark L. Hornick 1 Event-Driven Programming.
Introduction to Java Programming
Anonymous Classes An anonymous class is a local class that does not have a name. An anonymous class allows an object to be created using an expression.
Object Oriented Programming.  Interface  Event Handling.
CSE 331 Software Design & Implementation Hal Perkins Autumn 2012 Event-Driven Programming 1.
Agenda Introduction. Event Model. Creating GUI Application. Event Examples.
Index Event Handling Events Event Source Event Listener Event Classes Action Event Class Adjustment event Class Event Source Event Listener Interface Using.
Liang, Introduction to Java Programming, Tenth Edition, (c) 2015 Pearson Education, Inc. All rights reserved. 1 Chapter 15 Event-Driven Programming and.
Liang, Introduction to Java Programming, Tenth Edition, (c) 2015 Pearson Education, Inc. All rights reserved. 1 Chapter 15 Event-Driven Programming and.
1 Event Driven Programs Rick Mercer. 2 So what happens next?  You can layout a real pretty GUI  You can click on buttons, enter text into a text field,
What Is an Event? Events – Objects that describe what happened Event sources – The generator of an event Event handlers – A method that receives an event.
Mouse Events GUI. Types of Events  Below, are some of the many kinds of events, swing components generate. Act causing EventListener Type User clicks.
Lesson 28: More on the GUI button, frame and actions.
Jozef Goetz Credits: Copyright  Pearson Education, Inc. All rights reserved. expanded by J. Goetz, 2016.
Sep 181 Example Program DemoTranslateEnglishGUI.java.
12-Jun-16 Event loops. 2 Programming in prehistoric times Earliest programs were all “batch” processing There was no interaction with the user Input Output.
Event Driven (Asynchronous) Programming. Event handling in Unity Subclass a class that contains event handling methods, and then override those methods.
Prepared by: Dr. Abdallah Mohamed, AOU-KW Unit7: Event-driven programming 1.
GUI Programming using Java - Event Handling
Events and Event Handling
Chapter 14 Event-Driven Programming
CompSci 230 S Programming Techniques
CSE 331 Software Design & Implementation
CSE 331 Software Design & Implementation
CSE 331 Software Design and Implementation
Programming in Java Event Handling
Ellen Walker Hiram College
Event Driven Programming
Chapter 15 Event-Driven Programming and Animations
CSE 331 Software Design and Implementation
CSE 331 Software Design and Implementation
Event loops 17-Jan-19.
Events, Event Handlers, and Threads
Constructors, GUI’s(Using Swing) and ActionListner
Model, View, Controller design pattern
CSE 331 Software Design & Implementation
Presentation transcript:

CSE 331 Software Design & Implementation Dan Grossman Spring 2015 GUI Event-Driven Programming (Based on slides by Mike Ernst, Dan Grossman, David Notkin, Hal Perkins)

The plan User events and callbacks –Event objects –Event listeners –Registering listeners to handle events Anonymous inner classes Proper interaction between UI and program threads 2CSE331 Spring 2015

Event-driven programming Many applications are event-driven GUI programs: –Program initializes itself on startup then enters an event loop –Abstractly: do { e = getNextEvent(); process event e; } while (e != quit); Contrast with application- or algorithm-driven control where program expects input data in a particular order –Typical of large non-GUI applications like web crawling, payroll, data simulation, … 3CSE331 Spring 2015

Kinds of GUI events Typical events handled by a GUI program: –Mouse move/drag/click, button press, button release –Keyboard: key press or release, sometimes with modifiers like shift/control/alt/etc. –Finger tap or drag on a touchscreen –Joystick, drawing tablet, other device inputs –Window resize/minimize/restore/close –Network activity or file I/O (start, done, error) –Timer interrupt (including animations) 4CSE331 Spring 2015

Events in Java AWT/Swing Many (most?) of the GUI widgets can generate events (button clicks, menu picks, key press, etc.) Handled using the Observer Pattern: –Objects wishing to handle events register as observers with the objects that generates them –When an event happens, appropriate method in each observer is called –As expected, multiple observers can watch for and be notified of an event generated by an object 5CSE331 Spring 2015

Event objects A Java GUI event is represented by an event object –Superclass is AWTEvent –Some subclasses: ActionEvent – GUI-button press KeyEvent – keyboard MouseEvent – mouse move/drag/click/button Event objects contain information about the event –UI object that triggered the event –Other information depending on event. Examples: ActionEvent – text string from a button MouseEvent – mouse coordinates 6CSE331 Spring 2015

Event listeners Event listeners must implement the proper interface: KeyListener, ActionListener, MouseListener (buttons), MouseMotionListener (move/drag), … –Or extend the appropriate library abstract class that provides empty implementations of the interface methods When an event occurs, the appropriate method specified in the interface is called: actionPerformed, keyPressed, mouseClicked, mouseDragged, … An event object is passed as a parameter to the event listener method 7CSE331 Spring 2015

Example: button Create a JButton and add it to a window Create an object that implements ActionListener –(containing an actionPerformed method) Add the listener object to the button’s listeners ButtonDemo1.java 8CSE331 Spring 2015

Which button is which? Q: A single button listener object often handles several buttons. How to tell which button generated the event? A: an ActionEvent has a getActionCommand method that returns (for a button) the “action command” string –Default is the button name (text), but usually better to set it to some string that will remain the same inside the program code even if the UI is changed or translated. See button example. Similar mechanisms to decode other events 9CSE331 Spring 2015

Listener classes ButtonDemo1.java defines a class that is used only once to create a listener for a single button –Could have been a top-level class, but in this example it was an inner class since it wasn’t needed elsewhere –But why a full-scale class when all we want is to create a method to be called after a button click? Alas, no lambdas (function closures) before Java 8 A more convenient shortcut: anonymous inner classes 10CSE331 Spring 2015

Anonymous inner classes Idea: define a new class directly in the new expression that creates an object of the (new) anonymous inner class –Specify the superclass to be extended or interface to be implemented –Override or implement methods needed in the anonymous class instance –Can have methods, fields, etc., but not constructors –But if it starts to get complex, use an ordinary class for clarity (nested inner class if appropriate) Warning: ghastly syntax ahead 11CSE331 Spring 2015

Example button.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e) { model.doSomething() } ); 12 new expression to create class instance Brackets surrounding new class definition Implementation of method for this anonymous class Method call parameter list Class or interface being extended/implemented (can include constructor parameters) CSE331 Spring 2015

Example ButtonDemo2.java 13CSE331 Spring 2015

Program thread and UI thread Recall that the program and user interface are running in separate, concurrent threads All UI actions happen in the UI thread – including the callbacks like actionListener or paintComponent, etc. defined in your code After event handling and related work, call repaint() if paintComponent() needs to run. Don’t try to draw anything from inside the event handler itself (as in you must not do this!!!) Remember that paintComponent must be able to do its job by reading data that is available whenever the window manager calls it 14CSE331 Spring 2015

Event handling and repainting 15 programwindow manager (UI) repaint() paintComponent(g) Remember: your program and the window manager are running concurrently: Program thread User Interface thread It’s ok to call repaint from an event handler, but never call paintComponent yourself from either thread. actionPerformed(e) CSE331 Spring 2015

Working in the UI thread Event handlers should not do a lot of work –If the event handler does a lot of computing, the user interface will appear to freeze up (Why?) –If there’s lots to do, the event handler should set a bit that the program thread will notice: Do the heavy work back in the program thread. (Don’t worry – finding a path for campus maps should be fast enough to do in the UI thread) 16CSE331 Spring 2015

Synchronization issues? Yes, there can be synchronization problems –(cf. CSE332, CSE451, …) Not usually an issue in well-behaved programs, but can happen Some advice: –Keep event handling short –Call repaint when data is ready, not when partially updated –Don’t update data in the UI and program threads at the same time (particularly for complex data) –Never call paintComponent directly (Have we mentioned you should never call paintComponent ? And don’t create a new Graphics object either.) 17CSE331 Spring 2015

Larger example – bouncing balls A hand-crafted MVC application. Origin is somewhere back in the CSE142/3 mists. Illustrates how some swing GUI components can be put to use. Disclaimers: –Not the very best design –Unlikely to be directly appropriate for your project –Use it for ideas and inspiration, and feel free to steal small bits if they really fit Enjoy! 18CSE331 Spring 2015