Event handling in java

Document Sample
Event handling in java Powered By Docstoc
					                                                                                                   GUI are Event Driven

                    Event Handling

                                                                                                   Some event classes of
                                    Events                                                            java.awt.event
       • GUIs generate events when the user interacts with GUI

       • For example,                                                                    java.lang.Object              ActionEvent      ContainerEvent

          – Clicking a button                                                                                         AdjustmentEvent     FocusEvent
          – Moving the mouse
          – Closing Window etc                                                                                          ItemEvent         PaintEvent

       • In java, events are represented by Objects                                                                   ComponentEvent     WindowEvent

          – These objects tells us about event and its source. Examples are                                                               InputEvent
              • ActionEvent (Clicking a button)                                                      Class name
              • WindowEvent (Doing something with window e.g. closing , minimizing)
                                                                                                     Interface name          KeyEvent     MouseEvent

       • Both AWT and swing components (not all) generate events
          – java.awt.event.*;
          – javax.swing.event .*;

                 Event Handling Model                                                              Event Handling Steps
         • Common for both AWT and Swing components                                   • For a programmer the event Handling is a three
                                                                                        step process in terms of code
         • Event Delegation Model
                                                                                      • Step 1
            – Processing of an event is delegated to a particular                       – Create components which can generate events
              object (handlers ) in the program
                                                                                      • Step 2
            – Publish-Subscribe                                                         – Build component (objects) that can handle events
                                                                                          (Event Handlers)
            – Separate UI code from program logic

                                                                                      • Step 3
                                                                                        – Register handlers with generators

©Umair Javed CS 391                                                                                                                                      1
             Event Handling Process [1]                                          Event Handling Process [2]
                             Event Generators                                      Event Handlers/ Event Listener
         – You have already seen alot of event generators               • First Technique - By Implementing Listener Interfaces
            • Buttons
            • Mouse                                                          – Java defines interfaces for every event type
            • Key
            • Window                                                         – If a class needs to handle an event. It needs to implement the
            Etc                                                                corresponding listener interface

         – JButton b1 = new JButton(“Hello”);                                – To handle “ActionEvent” a class needs to implement

         – Now b1 can generate events                                        – To handle “KeyEvent” a class needs to implement “ KeyListener”

                                                                             – To handle “MouseEvent” a class needs to implement

                                                                             And so on

             Event Listener interfaces
             of package java.awt.event                                                   Example Listeners
                                                                        public interface ActionListener {
                                                  AdjustmentListener         public void actionPerformed(ActionEvent e);

                                                                        public interface ItemListener {
                                                    FocusListener            public void itemStateChanged(ItemEvent e);

                                                     KeyListener        public interface ComponentListener {
                                                                             public void componentHidden(ComponentEvent e);
                                                                             public void componentMoved(ComponentEvent e);
                                                                             public void componentResized(ComponentEvent e);
                                                     TextListener            public void componentShown(ComponentEvent e);
                           Class name
                           Interface name           WindowListener

             Event Handling Process [3]                                          Event Handling Process [4]
                              Event Handlers                                                    Event Handlers

       • By implementing an interface the class agrees to               • To handle events generated by Button. A class
         implement all the methods that are present in                    needs to implement ActionListener interface.
         that interface.

       • Implementing an interface is like signing a                    • public class Test implements ActionListener{
                                                                             public void actionPerformed(ActionEvent ae){
       • Inside the method the class can do what ever it                           // do something
         wants to do with that event

       • Event Generator and Event Handler can be the                    }
         same or different classes

©Umair Javed CS 391                                                                                                                             2
             Event Handling Process [4]
             Registering Handler with Generator

       • The event generator is told about the
         object which can handle its events                                                Event Handling
                                                                                              Simple Example
       • Event Generators have a method
          – add______Listener(________)

       • b1.addActionListener(objectOfTestClass)

              Event Handling: Simple Example                                              Event Handling: Simple Example
                        Scenario                                                                   Step 1(cont.)
                                                                             /* This program demonstrates the handling of Action Event.
                                                                                 Whenever “Hello” button is presses, a dialog box would
                                                                                 be displayed in response containing some informative

                                                                             import java.awt.*;
                                                                             import javax.swing.*;
                                                                             impor java.awt.event.*;

           When Hello button is pressed, the Dialog box would be displayed   public class ActionEventTest {
                                                                               JFrame frame;
                                                                               JButton bHello;

              Event Handling: Simple Example                                     Event Handling: Simple Example (cont.)
                      Step 1 (cont.)                                                             Step 2
                                                                             // import your packages
          public void initGUI () {
            frame = new JFrame();                                            public class ActionEventTest implements ActionListener {

              // Event Generator                                                …….
              bHello = new JButton(“Hello”);                                    public void initGUI() ….

              Container con = frame.getContenetPane();                          public void actionPerformed (ActionEvent ae ){
              con.add(bHello);                                                          JOptionPane.showMessageDialog(“Hello is pressed”);

       }//end initGUI

©Umair Javed CS 391                                                                                                                          3
                                 Event Handling: Simple Example                                 Event Handling: Simple Example
                                         Step 3 (cont.)                                                     (cont.)
                public void initGUI () {
                   // Event Generator
                                                                                     public ActionEventTest( ) {
                   bHello = new JButton(“Hello”);                                         initGUI ();
                        Container con = frame.getContenetPane();                      }

                        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            public static void main (String args [ ]) {
                                                                                             ActionEventTest aeTest = new ActionEventTest();
                       // Event Registration
                        bH ello.addActionListner(this);                                  }
       }//end initGUI
                                                                                    }//end ActionEvent class

                                 Event Handling: Simple Example
                                        Complete Code
       import java.awt.*;
       import javax.swing.*;
       impor java.awt.event.*;
       public classActionEventTestimplements ActionListner{

        JFrame frame;
        JButton bHello;

            public void initGUI () {

                frame = newJFrame ();
                // Event Generator
                bHello= new JButton(“Hello”;

                Container con = frame.getContenetPane();

                frame.setVisible(true );
                                                                                              Behind the Scenes
                // Event Registration
              bHello.addActionListner(this );
        }//end initGUI

        public void actionPerformed (ActionEvent ae ){
              JOptionPane.showMessageDialog(“Hello ispressed”);

        publicActionEventTest( ) {
           initGUI ();

        public static void main (String args [ ]) {

              ActionEventTest aeTest = new ActionEventTest();

       }//end ActionEventclass

                      Event Handling Participants                                   Event Handling Participants (cont.)
       1. Event Generator / Source                                                  3.       Event Listener/handler
                   –            Swing and awt components                                 –     Receives event objects when notified, then responds
                   –            For example, JButton, JTextField, JFrame etc             –     Each event source can have multiple listeners registered on it
                   –            Generates an event object                                –     Conversely, a single listener can register with multiple event
                   –            Registers listeners with itself                                sources

       2. Event Object
                   –            Encapsulate information about event that occurred
                                and the source of that event
                   –            For example, if you click a button, ActionEvent
                                object is created

©Umair Javed CS 391                                                                                                                                             4
       Event Handling Participants (cont.)                              Event Handling Diagram
                                                                                                                           que               Event Queue
                                                                                                                   nt in
       4. JVM                                                                                               Add
                                                                                                                eve                          (managed by JVM)

           – Receives an event whenever one is generated
           – Looks for the listener/handler of that event                                                   JVM                     DeQueue Event
           – If exist, delegate it for processing

                                                                                                                              Pass ActionEvent to Handler

           – If not, discard it (event).

                                                                                                   Register with
                                                                                                                   Action Hanlder

                                                                                                                                      Action Action Mouse
                                                                                                                                      Handler Handler Handler

                                                                    Event Handling: Small Calculator

          Making Small Calculator
              Example Code

                                                                  • User enters numbers in the provided fields
                                                                  • On pressing “+” button, sum would be displayed in the answer field
                                                                  • On pressing “*” button, product would be displayed in the ans wer field

                  Code: Small Calculator                        Code: Small Calculator (cont.)
       import java.awt.*;                                      // providing definition of interface ActionListner’s methos
       import javax.swing.*;
                                                               public void actionPerformed (ActionEvent event ) {
       impor java.awt.event.*;
       public class SmallCalcApp implements ActionListener {     String oper, result;
          JFrame frame;                                          int num1, num2, res;
          JLabel firstOperand, secondOperand, answer;
          JTextField op1, op2, ans;                              if (event.getSource () == plus) {
          JButton plus, mul;
                                                                    oper = op1.getText();
          public void initGUI () {                                  num1 = Integer.parseInt(oper);
                                                                    oper = op2.getText();
             plus = new JButton(“+”);
             mul = new JButton(“*”);                                num2 = Integer.parseInt (oper);
              …….                                                   res = num1+num2;
             plus.addActionListner(this);                           result = res+"";
             ………                                                    ans.setText(result);
         }//end initGUI
                                                                 } // end if

©Umair Javed CS 391                                                                                                                                             5
        Code: Small Calculator (cont.)             Code: Small Calculator (cont.)
                                                    ………        //write default constructor and call initGUI
         else if ( event.getSource() == mul) {

             oper = op1.getText();                  public static void main (String args[ ]) {
             num1 = Integer.parseInt(oper );
                                                        SmallCalcApp scApp = new SmallCalcApp();
             oper = op2.getText();                  }
             num2 = Integer.parseInt (oper);

             res = num1*num2;                    } // end SmallCalcApp
             result = res+"";



       } // end actionPerformed method


©Umair Javed CS 391                                                                                           6

Shared By: