Name: moC74494 Date: 05/21/98


The two main issues are: (1) When a
lightweight component gets focus, the
applet that contains it never gets a
lostFocus message, even though it no
longer has focus. (2) It is not possible
for the applet to regain focus after
this point.

The following code describes the problem
in detail in the comments. There are
two parts to the example. The first
part (PART A) will work as is. The
second part (PART B) requires the un-
commenting of some code, as indicated.

/* ---- cut here ---- */

/**
 * ----------------------------------------------------
 *
 * This demonstration Applet shows that Lightweight Components
 * behave "poorly" with respect to Focus.<p>
 *
 * ----------------------------------------------------
 *
 * PART A:
 * The applet consists of a simple lightweight button and a
 * simple lightweight "focus stealer". When the applet is
 * started, it does not have focus. This is proven by the
 * fact that keys pressed on the keyboard will not be
 * "heard". Try this to verify it yourself. So far, so good.
 * Now, click on the simple button which says "Click To
 * Focus Applet". This sends an ActionEvent to the applet,
 * which in response calls requestFocus(). Now the applet
 * has focus, and this can be proven by typing on the keyboard.
 * You will find the applet reports it has focus and reports
 * what keys are being pressed. Again: so far, so good.<p>
 *
 * Now, click the "focus stealer" which is a component on the
 * applet that says "FOCUS NOT STOLEN". When it is clicked on,
 * it calls requestFocus() itself. It's label will change to
 * read "FOCUS STOLEN". Now we have seen our first problem -
 * the applet itself <em>never gets its lostFocus method
 * called, even though it no longer has focus.</em> We can
 * also prove that the applet no longer has focus - typing
 * keys will also not be "heard" by the applet.<p>
 *
 * There is yet another problem. Clicking on the simple button
 * (the one that says "Click To Focus Applet") no longer will
 * work. It now cannot receive MouseEvents itself, and is
 * therefore unable to send the focus back to the Applet!<p>
 *
 * In summary, once a lightweight component has gotten focus,
 * it doesn't seem to be possible for it to lose focus via the
 * normal ways a user would expect it to (i.e. clicking on other
 * components). We have also tried a variant, where the "focus
 * stealer" calls requestFocus on its parent the second time
 * it is clicked, and this doesn't make it lose focus, either!
 *
 * ----------------------------------------------------
 *
 * PART B:
 * Un-comment the two seconds of code below which state they
 * need to be un-commented for PART B and re-compile and run.
 * This launches a separate thread during the initialization
 * of the applet. This thread issues a requestFocus() on the
 * applet every three seconds. You can tell this works
 * because without clicking on the applet, it will get the
 * focus itself after starting. Now try clicking on the "focus
 * stealer". The focus is taken, as before. However, even
 * the new "FocusForcer" thread cannot give the applet focus
 * again.
 *
 * ----------------------------------------------------
 *
 * To see this applet, use the following HTML code:
 * <APPLET CODE="FocusStealApplet.class" WIDTH=430 HEIGHT=270></APPLET>
 *
 * This has been tested with the JDK 1.1.5 appletviewer on
 * Windows NT Server 4.0 and Windows 95 on a Pentium Pro
 * 180 with 64 megabytes.
 *
 * Jeff Lind, ###@###.###
 * Dario Laverde, ###@###.###
 * David Levine, ###@###.### (main contact)
 *
 * 27-February-1998
 *
 * ----------------------------------------------------
 */

import java.applet.Applet;
import java.awt.event.FocusListener;
import java.awt.event.KeyListener;
import java.awt.event.ActionListener;
import java.awt.Color;
import java.awt.event.FocusEvent;
import java.awt.event.KeyEvent;
import java.awt.event.ActionEvent;
import java.awt.Graphics;
import java.awt.Component;
import java.awt.event.MouseListener;
import java.awt.AWTEventMulticaster;
import java.awt.AWTEvent;
import java.awt.event.MouseEvent;

// This is the main applet to demonstrate the problem.
public class FocusStealApplet extends Applet implements FocusListener, KeyListener, ActionListener
{
    FocusStealer stealer;
    SimpleButton simplebutton;
    boolean inFocus = false;
    char lastKey = ' ';

    public void init( )
    {
        // basic setup
        setLayout( null);
        setBackground( Color.white);
        setForeground( Color.black);
        setSize( 430, 270);

        // add the focus and key listeners
        addFocusListener( this);
     addKeyListener( this);

     // add the "focus stealer" to the applet
        stealer = new FocusStealer( );
        stealer.setBounds( 36, 26, 144, 24);
        add( stealer);

        // add the "simple button" to the applet
        simplebutton = new SimpleButton( );
        simplebutton.setBounds( 36, 56, 144, 24);
        simplebutton.addActionListener( this);
        add( simplebutton);

/*
Un-comment this for PART B

        // set up a component to give us back focus every now and then
        FocusForcer forcer = new FocusForcer( this);
        forcer.start( );
*/

        // make sure we're showing everything!
        validate( );
        repaint( );
    }

    // set our internal state to know we've got the focus, then repaint
    public void focusGained( FocusEvent evt)
    {
        inFocus = true;
        repaint( );
    }

    // set our internal state to know we've lost the focus, then repaint
    public void focusLost( FocusEvent evt)
    {
        inFocus = false;
        repaint( );
    }

    // set our internal record of the key that was typed, then repaint
    public void keyTyped( KeyEvent evt)
    {
        lastKey = evt.getKeyChar( );
        repaint( );
    }

    // these two methods aren't used
    public void keyPressed( KeyEvent evt) {}
    public void keyReleased( KeyEvent evt) {}

    // if the simplebutton has been pressed, make the applet request focus
    public void actionPerformed( ActionEvent evt)
    {
        requestFocus( );
    }

    public synchronized void update( Graphics g)
    {
        paint( g);
    }

    public void paint( Graphics g)
    {
        // paint the background
        g.setColor( getBackground( ));
        g.fillRect( 0, 0, 430, 270);

        // paint what the last key typed was
        g.setColor( getForeground( ));
        g.drawString( "Last Key: " + lastKey, 20, 150);

        // paint whether or not we have focus
        if( inFocus)
        {
            g.drawString( "Applet Has Focus", 20, 170);
        }
        else
        {
            g.drawString( "Applet Does Not Have Focus", 20, 170);
        }

        // paint the "focus stealer" and simplebutton
        super.paint( g);
    }
}

// This is an exceptionally simple lightweight button
class SimpleButton extends Component implements MouseListener
{
    ActionListener actionListener;

    public SimpleButton( )
    {
        // get ready to listen for clicks
        addMouseListener( this);
    }

    public synchronized void addActionListener( ActionListener l)
    {
        // find out who we should notify
        actionListener = AWTEventMulticaster.add(actionListener, l);
        enableEvents( AWTEvent.MOUSE_EVENT_MASK);
    }

    public synchronized void removeActionListener( ActionListener l)
    {
        // remove from notification list - not used, but included for completeness
        actionListener = AWTEventMulticaster.remove(actionListener, l);
    }

    // these methods are not used
    public void mouseClicked( MouseEvent e) {}
    public void mouseEntered( MouseEvent e) {}
    public void mouseExited( MouseEvent e) {}
    public void mousePressed( MouseEvent e) {}
    
    // if the button was clicked, let our listeners know
    public void mouseReleased( MouseEvent e)
    {
        actionListener.actionPerformed( new ActionEvent(
                                        this,
                                        ActionEvent.ACTION_PERFORMED,
                                        "go"));
    }
    
    // paint the simplebutton
    public void paint( Graphics g)
    {
        g.setColor( getBackground( ));
        g.fillRect( 0, 0, getSize( ).width, getSize( ).height);
        g.setColor( getForeground( ));
        g.drawString( "Click To Focus Applet", 5, getSize( ).height - 3);
        g.drawRect( 0, 0, getSize( ).width - 1, getSize( ).height - 1);
    }
}

// this is the "focus stealer" - it is a lightweight component that requests focus when it is clicked on
class FocusStealer extends Component implements FocusListener, MouseListener
{
    boolean inFocus = false;
    
    public FocusStealer( )
    {
        // listen to our own focus and listen for mouse clicks
        addFocusListener( this);
        addMouseListener( this);
    }
    
    public boolean isFocusTraversable( )
    {
        return true;
    }

    // these methods are not used
    public void mouseClicked( MouseEvent e) {}
    public void mouseEntered( MouseEvent e) {}
    public void mouseExited( MouseEvent e) {}
    public void mousePressed( MouseEvent e) {}
    
    // if the "focus stealer" was clicked, ask for focus
    public void mouseReleased( MouseEvent e)
    {
        requestFocus( );
    }
    
    // when focus is gained, set our internal state to know it, and repaint
    public void focusGained( FocusEvent e)
    {
        inFocus = true;
        repaint( );
    }

    // when focus is lost, set our internal state to know it, and repaint
    public void focusLost( FocusEvent e)
    {
        inFocus = false;
        repaint( );
    }
    
    // paint the "focus stealer"
    public void paint( Graphics g)
    {
        g.setColor( getBackground( ));
        g.fillRect( 0, 0, getSize( ).width, getSize( ).height);
        g.setColor( getForeground( ));
        if( inFocus)
        {
            g.drawString( "FOCUS STOLEN", 5, getSize( ).height - 3);
        }
        else
        {
            g.drawString( "FOCUS NOT STOLEN", 5, getSize( ).height - 3);
        }
        g.drawRect( 0, 0, getSize( ).width - 1, getSize( ).height - 1);
    }
}

/*
Un-comment this for PART B

// This class runs as a separate thread and calls requestFocus() on a specified component every three seconds
class FocusForcer extends Thread
{
    Component c;
    
    public FocusForcer( Component c)
    {
        this.c = c;
    }
    
    public void run( )
    {
        while( true)
        {
            try
            {
                Thread.sleep( 3000);
            }
            catch( InterruptedException e)
            {
            }
            c.requestFocus( );
        }
    }
}

*/

/* ---- cut here ---- */
(Review ID: 25853)
======================================================================