NEWT/AWT Focus Traversal / Deadlock Fix (Windows) ; Harmonized NEWT KeyListener handling (Bug 526)

NativeWindow:
  - expose 'hasFocus()'

Window:
  - 'protected enqueueRequestFocus(..)' -> 'public requestFocus(boolean wait)'

  - New: 'setKeyboardFocusHandler(KeyListener)' allowing focus traversal co-op w/ covered TK (AWT)

WindowImpl:
  - Impl Window changes (see above)
  - Impl 'consumedTag' see commit 3b38957f36d4f89b85730755a41c00892ac70591

NewtCanvasAWT:
  - FocusAction only removes the global AWT focus owner.
    This fixes a deadlock on the Windows platform of AWT's native peer requestFocus impl,
    since it's no more called at this point.

  - NEW FocusTraversalKeyListener is set as the newtChild's KeyboardFocusHandler,
    allowing traversal to the next/previous AWT component.

AWTParentWindowAdapter:
  - focusGained(..) clears AWT focus and propagates focus to Newt child,
    non blocking w/ 'requestFocus(false)' (see above)

KeyEvent:
  - Document limitations of getKeyChar() (Bug 526)

MacWindow:
  - only deliver keyChar on key Typed events, harmonizing platform behavior (Bug 526)

WindowsWindow:
  - regenerate the keyCode for EVENT_KEY_TYPED (Bug 526)

X11Windows:
  - complete keyCode mapping X11 -> Newt - X11KeySym2NewtVKey()
  - only deliver keyChar on key Typed events, harmonizing platform behavior (Bug 526)

Tests:
  - GearsES2: Make focus visible
  - TestParentingFocusTraversal01AWT: unit test for keyboard focus traversal w/ NewtCanvasAWT

4 files changed, 101 insertions, 44 deletions

diff --git a/src/newt/classes/jogamp/newt/WindowImpl.java b/src/newt/classes/jogamp/newt/WindowImpl.java
index 3865cd6c8..ef927ec16 100644
--- a/src/newt/classes/jogamp/newt/WindowImpl.java
+++ b/src/newt/classes/jogamp/newt/WindowImpl.java
@@ -110,6 +110,7 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
 
     private RequestFocusAction requestFocusAction = new RequestFocusAction();
     private FocusRunnable focusAction = null;
+    private KeyListener keyboardFocusHandler = null;
 
     private SurfaceUpdatedHelper surfaceUpdatedHelper = new SurfaceUpdatedHelper();
     
@@ -1415,14 +1416,6 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }
     }
     
-    public void requestFocus() {
-        enqueueRequestFocus(true);
-    }
-
-    public final boolean hasFocus() {
-        return hasFocus;
-    }
-
     public final InsetsImmutable getInsets() {
         if(isUndecorated()) {
             return Insets.getZero();
@@ -1559,15 +1552,18 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }
     }
 
-    protected void enqueueRequestFocus(boolean wait) {
+    public final boolean hasFocus() {
+        return hasFocus;
+    }
+
+    public void requestFocus() {
+        requestFocus(true);
+    }
+
+    public void requestFocus(boolean wait) {
         runOnEDTIfAvail(wait, requestFocusAction);
     }
 
-    /** 
-     * May set to a {@link FocusRunnable}, {@link FocusRunnable#run()} before Newt requests the native focus.
-     * This allows notifying a covered window toolkit like AWT that the focus is requested,
-     * hence focus traversal can be made transparent.
-     */
     public void setFocusAction(FocusRunnable focusAction) {
         this.focusAction = focusAction;
     }
@@ -1588,7 +1584,11 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         }
         return res;
     }
-
+    
+    public void setKeyboardFocusHandler(KeyListener l) {
+        keyboardFocusHandler = l;
+    }
+    
     private class SetPositionActionImpl implements Runnable {
         int x, y;
 
@@ -1830,8 +1830,8 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
                 // queue event in case window is locked, ie in operation
                 if( isWindowLocked() ) {
                     if(DEBUG_IMPLEMENTATION) {
-                        // System.err.println("Window.consumeEvent: queued "+e);
-                        // Thread.dumpStack(); // JAU
+                        System.err.println("Window.consumeEvent: queued "+e);
+                        // Thread.dumpStack();
                     }
                     return false;
                 }
@@ -2021,8 +2021,8 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         if(DEBUG_MOUSE_EVENT) {
             System.err.println("consumeMouseEvent: event:         "+e);
         }
-
-        for(int i = 0; i < mouseListeners.size(); i++ ) {
+        boolean consumed = false;
+        for(int i = 0; !consumed && i < mouseListeners.size(); i++ ) {
             MouseListener l = mouseListeners.get(i);
             switch(e.getEventType()) {
                 case MouseEvent.EVENT_MOUSE_CLICKED:
@@ -2052,13 +2052,13 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
                 default:
                     throw new NativeWindowException("Unexpected mouse event type " + e.getEventType());
             }
+            consumed = InputEvent.consumedTag == e.getAttachment();
         }
     }
 
     //
     // KeyListener/Event Support
     //
-
     public void sendKeyEvent(int eventType, int modifiers, int keyCode, char keyChar) {
         consumeKeyEvent(new KeyEvent(eventType, this, System.currentTimeMillis(), modifiers, keyCode, keyChar) );
     }
@@ -2107,26 +2107,39 @@ public abstract class WindowImpl implements Window, NEWTEventConsumer
         return (KeyListener[]) keyListeners.toArray();
     }
 
-    protected void consumeKeyEvent(KeyEvent e) {
-        if(DEBUG_KEY_EVENT) {
-            System.err.println("consumeKeyEvent: "+e);
+    private final boolean propagateKeyEvent(KeyEvent e, KeyListener l) {
+        switch(e.getEventType()) {
+            case KeyEvent.EVENT_KEY_PRESSED:
+                l.keyPressed(e);
+                break;
+            case KeyEvent.EVENT_KEY_RELEASED:
+                l.keyReleased(e);
+                break;
+            case KeyEvent.EVENT_KEY_TYPED:
+                l.keyTyped(e);
+                break;
+            default:
+                throw new NativeWindowException("Unexpected key event type " + e.getEventType());
         }
-        for(int i = 0; i < keyListeners.size(); i++ ) {
-            KeyListener l = keyListeners.get(i);
-            switch(e.getEventType()) {
-                case KeyEvent.EVENT_KEY_PRESSED:
-                    l.keyPressed(e);
-                    break;
-                case KeyEvent.EVENT_KEY_RELEASED:
-                    l.keyReleased(e);
-                    break;
-                case KeyEvent.EVENT_KEY_TYPED:
-                    l.keyTyped(e);
-                    break;
-                default:
-                    throw new NativeWindowException("Unexpected key event type " + e.getEventType());
+        return InputEvent.consumedTag == e.getAttachment();
+    }
+    
+    protected void consumeKeyEvent(KeyEvent e) {
+        boolean consumed;
+        if(null != keyboardFocusHandler) {
+            consumed = propagateKeyEvent(e, keyboardFocusHandler);
+            if(DEBUG_KEY_EVENT) {
+                System.err.println("consumeKeyEvent: "+e+", keyboardFocusHandler consumed: "+consumed);
+            }
+        } else {
+            consumed = false;
+            if(DEBUG_KEY_EVENT) {
+                System.err.println("consumeKeyEvent: "+e);
             }
         }
+        for(int i = 0; !consumed && i < keyListeners.size(); i++ ) {
+            consumed = propagateKeyEvent(e, keyListeners.get(i));
+        }
     }
 
     //
diff --git a/src/newt/classes/jogamp/newt/awt/event/AWTParentWindowAdapter.java b/src/newt/classes/jogamp/newt/awt/event/AWTParentWindowAdapter.java
index 358864547..313a5e868 100644
--- a/src/newt/classes/jogamp/newt/awt/event/AWTParentWindowAdapter.java
+++ b/src/newt/classes/jogamp/newt/awt/event/AWTParentWindowAdapter.java
@@ -28,6 +28,8 @@
  
 package jogamp.newt.awt.event;
 
+import java.awt.KeyboardFocusManager;
+
 import com.jogamp.newt.event.awt.AWTAdapter;
 import com.jogamp.newt.event.awt.AWTWindowAdapter;
 
@@ -54,9 +56,16 @@ public class AWTParentWindowAdapter
     }
 
     public void focusGained(java.awt.event.FocusEvent e) {
+        // forward focus to NEWT child
+        final com.jogamp.newt.Window newtChild = getNewtWindow();
+        final boolean isOnscreen = newtChild.isNativeValid() && newtChild.getGraphicsConfiguration().getChosenCapabilities().isOnscreen();
         if(DEBUG_IMPLEMENTATION) {
-            System.err.println("AWT: focusGained: "+ e);
+            System.err.println("AWT: focusGained: onscreen "+ isOnscreen+", "+e);
+        }
+        if(isOnscreen) {
+            KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
         }
+        newtChild.requestFocus(false);
     }
 
     public void focusLost(java.awt.event.FocusEvent e) {
diff --git a/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java b/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java
index 292a9c255..e1b2ef87d 100644
--- a/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java
+++ b/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java
@@ -311,20 +311,24 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     
     @Override
     public void sendKeyEvent(int eventType, int modifiers, int keyCode, char keyChar) {
-        final int key = convertKeyChar(keyChar);
-        if(DEBUG_IMPLEMENTATION) System.err.println("MacWindow.sendKeyEvent "+Thread.currentThread().getName());
         // Note that we send the key char for the key code on this
         // platform -- we do not get any useful key codes out of the system
-        super.sendKeyEvent(eventType, modifiers, key, keyChar);        
+        final int keyCode2 = convertKeyChar(keyChar);
+        if(DEBUG_IMPLEMENTATION) System.err.println("MacWindow.sendKeyEvent "+Thread.currentThread().getName()+" char: "+keyChar+", code 0x"+Integer.toHexString(keyCode)+" -> 0x"+Integer.toHexString(keyCode2));
+        // only deliver keyChar on key Typed events, harmonizing platform behavior
+        keyChar = KeyEvent.EVENT_KEY_TYPED == eventType ? keyChar : (char)-1;
+        super.sendKeyEvent(eventType, modifiers, keyCode2, keyChar);        
     }
     
     @Override
     public void enqueueKeyEvent(boolean wait, int eventType, int modifiers, int keyCode, char keyChar) {
-        final int key = convertKeyChar(keyChar);
-        if(DEBUG_IMPLEMENTATION) System.err.println("MacWindow.enqueueKeyEvent "+Thread.currentThread().getName());
         // Note that we send the key char for the key code on this
         // platform -- we do not get any useful key codes out of the system
-        super.enqueueKeyEvent(wait, eventType, modifiers, key, keyChar);
+        final int keyCode2 = convertKeyChar(keyChar);
+        if(DEBUG_IMPLEMENTATION) System.err.println("MacWindow.enqueueKeyEvent "+Thread.currentThread().getName()+" char: "+keyChar+", code 0x"+Integer.toHexString(keyCode)+" -> 0x"+Integer.toHexString(keyCode2));
+        // only deliver keyChar on key Typed events, harmonizing platform behavior
+        keyChar = KeyEvent.EVENT_KEY_TYPED == eventType ? keyChar : (char)-1;
+        super.enqueueKeyEvent(wait, eventType, modifiers, keyCode2, keyChar);
     }
 
     //----------------------------------------------------------------------
diff --git a/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java b/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java
index cd5909d42..28be93acd 100644
--- a/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java
+++ b/src/newt/classes/jogamp/newt/driver/windows/WindowsWindow.java
@@ -42,6 +42,7 @@ import javax.media.nativewindow.util.Insets;
 import javax.media.nativewindow.util.InsetsImmutable;
 import javax.media.nativewindow.util.Point;
 
+import com.jogamp.newt.event.KeyEvent;
 import com.jogamp.newt.event.MouseAdapter;
 import com.jogamp.newt.event.MouseEvent;
 
@@ -244,6 +245,36 @@ public class WindowsWindow extends WindowImpl {
         // nop - using event driven insetsChange(..)         
     }
     
+    private final int validateKeyCode(int eventType, int keyCode) {
+        switch(eventType) {
+            case KeyEvent.EVENT_KEY_PRESSED:
+                lastPressedKeyCode = keyCode;
+                break;
+            case KeyEvent.EVENT_KEY_TYPED:
+                if(-1==keyCode) {
+                    keyCode = lastPressedKeyCode;
+                }
+                lastPressedKeyCode = -1;
+                break;
+        }
+        return keyCode;
+    }
+    private int lastPressedKeyCode = 0;
+    
+    @Override
+    public void sendKeyEvent(int eventType, int modifiers, int keyCode, char keyChar) {
+        // Note that we have to regenerate the keyCode for EVENT_KEY_TYPED on this platform
+        keyCode = validateKeyCode(eventType, keyCode);
+        super.sendKeyEvent(eventType, modifiers, keyCode, keyChar);        
+    }
+    
+    @Override
+    public void enqueueKeyEvent(boolean wait, int eventType, int modifiers, int keyCode, char keyChar) {
+        // Note that we have to regenerate the keyCode for EVENT_KEY_TYPED on this platform
+        keyCode = validateKeyCode(eventType, keyCode);
+        super.enqueueKeyEvent(wait, eventType, modifiers, keyCode, keyChar);
+    }
+    
     //----------------------------------------------------------------------
     // Internals only
     //