NEWT/AWT Focus traversal enhancement/fix (incl. OS X fixes)

- MacWindow/OffscreeSurface
  - Exclude native NEWT window calls in case it's an offscreen surface

- MacWindow/DriverClearFocus
  - Introduce driver detail DriverClearFocus interface
  - OS X needs to clear the focus, before another TK (eg. AWT) can claim it's (native parent window focus)

- MacWindow/KeyCode:
  - Move OS X keyCode utils to MacKeyUtil
  - MacKeyUtil now uses OS X virtual key codes first, before matching keyChar -> keyCode

- NewtCanvasAWT
  - Issue all AWT 'requestFocus()' on current thread,
    Newt-EDT -> AWT-EDT may freeze Window's native peer requestFocus() impl.

  - FocusAction directly issue action on Newt-EDT,
    also request AWT focus if not having it (proper AWT traversal)

  - Add an FocusPropertyChangeListener, detecting focus lost
    to issue DriverClearFocus's clearFocus() if available.

  - merge configureNewtChildInputEventHandler() code into configureNewtChild()
    to simplify call tree.

- WindowImplAccess: Use getDelegatedWindow()

3 files changed, 348 insertions, 193 deletions

diff --git a/src/newt/classes/jogamp/newt/driver/DriverClearFocus.java b/src/newt/classes/jogamp/newt/driver/DriverClearFocus.java
new file mode 100644
index 000000000..4d23c4ea8
--- /dev/null
+++ b/src/newt/classes/jogamp/newt/driver/DriverClearFocus.java
@@ -0,0 +1,12 @@
+package jogamp.newt.driver;
+
+/** 
+ * Interface tagging driver feature / requirement of clearing the focus.
+ * <p>
+ * Some drivers require a programmatic {@link #clearFocus()} when traversing the focus. 
+ * </p>   
+ */
+public interface DriverClearFocus {
+    /** Programmatic clear the focus */
+    void clearFocus();
+}
diff --git a/src/newt/classes/jogamp/newt/driver/macosx/MacKeyUtil.java b/src/newt/classes/jogamp/newt/driver/macosx/MacKeyUtil.java
new file mode 100644
index 000000000..46625f7a9
--- /dev/null
+++ b/src/newt/classes/jogamp/newt/driver/macosx/MacKeyUtil.java
@@ -0,0 +1,262 @@
+package jogamp.newt.driver.macosx;
+
+import com.jogamp.newt.event.KeyEvent;
+
+public class MacKeyUtil {
+      
+    // KeyCodes (independent)
+    private static final int kVK_Return                    = 0x24;
+    private static final int kVK_Tab                       = 0x30;
+    private static final int kVK_Space                     = 0x31;
+    private static final int kVK_Delete                    = 0x33;
+    private static final int kVK_Escape                    = 0x35;
+    private static final int kVK_Command                   = 0x37;
+    private static final int kVK_Shift                     = 0x38;
+    private static final int kVK_CapsLock                  = 0x39;
+    private static final int kVK_Option                    = 0x3A;
+    private static final int kVK_Control                   = 0x3B;
+    private static final int kVK_RightShift                = 0x3C;
+    private static final int kVK_RightOption               = 0x3D;
+    private static final int kVK_RightControl              = 0x3E;
+    private static final int kVK_Function                  = 0x3F;
+    private static final int kVK_F17                       = 0x40;
+    private static final int kVK_VolumeUp                  = 0x48;
+    private static final int kVK_VolumeDown                = 0x49;
+    private static final int kVK_Mute                      = 0x4A;
+    private static final int kVK_F18                       = 0x4F;
+    private static final int kVK_F19                       = 0x50;
+    private static final int kVK_F20                       = 0x5A;
+    private static final int kVK_F5                        = 0x60;
+    private static final int kVK_F6                        = 0x61;
+    private static final int kVK_F7                        = 0x62;
+    private static final int kVK_F3                        = 0x63;
+    private static final int kVK_F8                        = 0x64;
+    private static final int kVK_F9                        = 0x65;
+    private static final int kVK_F11                       = 0x67;
+    private static final int kVK_F13                       = 0x69;
+    private static final int kVK_F16                       = 0x6A;
+    private static final int kVK_F14                       = 0x6B;
+    private static final int kVK_F10                       = 0x6D;
+    private static final int kVK_F12                       = 0x6F;
+    private static final int kVK_F15                       = 0x71;
+    private static final int kVK_Help                      = 0x72;
+    private static final int kVK_Home                      = 0x73;
+    private static final int kVK_PageUp                    = 0x74;
+    private static final int kVK_ForwardDelete             = 0x75;
+    private static final int kVK_F4                        = 0x76;
+    private static final int kVK_End                       = 0x77;
+    private static final int kVK_F2                        = 0x78;
+    private static final int kVK_PageDown                  = 0x79;
+    private static final int kVK_F1                        = 0x7A;
+    private static final int kVK_LeftArrow                 = 0x7B;
+    private static final int kVK_RightArrow                = 0x7C;
+    private static final int kVK_DownArrow                 = 0x7D;
+    private static final int kVK_UpArrow                   = 0x7E;
+  
+    // Key constants handled differently on Mac OS X than other platforms
+    private static final char NSUpArrowFunctionKey        = 0xF700;
+    private static final char NSDownArrowFunctionKey      = 0xF701;
+    private static final char NSLeftArrowFunctionKey      = 0xF702;
+    private static final char NSRightArrowFunctionKey     = 0xF703;
+    private static final char NSF1FunctionKey             = 0xF704;
+    private static final char NSF2FunctionKey             = 0xF705;
+    private static final char NSF3FunctionKey             = 0xF706;
+    private static final char NSF4FunctionKey             = 0xF707;
+    private static final char NSF5FunctionKey             = 0xF708;
+    private static final char NSF6FunctionKey             = 0xF709;
+    private static final char NSF7FunctionKey             = 0xF70A;
+    private static final char NSF8FunctionKey             = 0xF70B;
+    private static final char NSF9FunctionKey             = 0xF70C;
+    private static final char NSF10FunctionKey            = 0xF70D;
+    private static final char NSF11FunctionKey            = 0xF70E;
+    private static final char NSF12FunctionKey            = 0xF70F;
+    private static final char NSF13FunctionKey            = 0xF710;
+    private static final char NSF14FunctionKey            = 0xF711;
+    private static final char NSF15FunctionKey            = 0xF712;
+    private static final char NSF16FunctionKey            = 0xF713;
+    private static final char NSF17FunctionKey            = 0xF714;
+    private static final char NSF18FunctionKey            = 0xF715;
+    private static final char NSF19FunctionKey            = 0xF716;
+    private static final char NSF20FunctionKey            = 0xF717;
+    private static final char NSF21FunctionKey            = 0xF718;
+    private static final char NSF22FunctionKey            = 0xF719;
+    private static final char NSF23FunctionKey            = 0xF71A;
+    private static final char NSF24FunctionKey            = 0xF71B;
+    private static final char NSF25FunctionKey            = 0xF71C;
+    private static final char NSF26FunctionKey            = 0xF71D;
+    private static final char NSF27FunctionKey            = 0xF71E;
+    private static final char NSF28FunctionKey            = 0xF71F;
+    private static final char NSF29FunctionKey            = 0xF720;
+    private static final char NSF30FunctionKey            = 0xF721;
+    private static final char NSF31FunctionKey            = 0xF722;
+    private static final char NSF32FunctionKey            = 0xF723;
+    private static final char NSF33FunctionKey            = 0xF724;
+    private static final char NSF34FunctionKey            = 0xF725;
+    private static final char NSF35FunctionKey            = 0xF726;
+    private static final char NSInsertFunctionKey         = 0xF727;
+    private static final char NSDeleteFunctionKey         = 0xF728;
+    private static final char NSHomeFunctionKey           = 0xF729;
+    private static final char NSBeginFunctionKey          = 0xF72A;
+    private static final char NSEndFunctionKey            = 0xF72B;
+    private static final char NSPageUpFunctionKey         = 0xF72C;
+    private static final char NSPageDownFunctionKey       = 0xF72D;
+    private static final char NSPrintScreenFunctionKey    = 0xF72E;
+    private static final char NSScrollLockFunctionKey     = 0xF72F;
+    private static final char NSPauseFunctionKey          = 0xF730;
+    private static final char NSSysReqFunctionKey         = 0xF731;
+    private static final char NSBreakFunctionKey          = 0xF732;
+    private static final char NSResetFunctionKey          = 0xF733;
+    private static final char NSStopFunctionKey           = 0xF734;
+    private static final char NSMenuFunctionKey           = 0xF735;
+    private static final char NSUserFunctionKey           = 0xF736;
+    private static final char NSSystemFunctionKey         = 0xF737;
+    private static final char NSPrintFunctionKey          = 0xF738;
+    private static final char NSClearLineFunctionKey      = 0xF739;
+    private static final char NSClearDisplayFunctionKey   = 0xF73A;
+    private static final char NSInsertLineFunctionKey     = 0xF73B;
+    private static final char NSDeleteLineFunctionKey     = 0xF73C;
+    private static final char NSInsertCharFunctionKey     = 0xF73D;
+    private static final char NSDeleteCharFunctionKey     = 0xF73E;
+    private static final char NSPrevFunctionKey           = 0xF73F;
+    private static final char NSNextFunctionKey           = 0xF740;
+    private static final char NSSelectFunctionKey         = 0xF741;
+    private static final char NSExecuteFunctionKey        = 0xF742;
+    private static final char NSUndoFunctionKey           = 0xF743;
+    private static final char NSRedoFunctionKey           = 0xF744;
+    private static final char NSFindFunctionKey           = 0xF745;
+    private static final char NSHelpFunctionKey           = 0xF746;
+    private static final char NSModeSwitchFunctionKey     = 0xF747;
+    
+    static int validateKeyCode(int keyCode, char keyChar) {        
+        // OS X Virtual Keycodes
+        switch(keyCode) {
+            case kVK_Return:               return KeyEvent.VK_ENTER;
+            case kVK_Tab:                  return KeyEvent.VK_TAB;
+            case kVK_Space:                return KeyEvent.VK_SPACE;
+            case kVK_Delete:               return KeyEvent.VK_BACK_SPACE;
+            case kVK_Escape:               return KeyEvent.VK_ESCAPE;
+            case kVK_Command:              return KeyEvent.VK_ALT;
+            case kVK_Shift:                return KeyEvent.VK_SHIFT;
+            case kVK_CapsLock:             return KeyEvent.VK_CAPS_LOCK;
+            case kVK_Option:               return KeyEvent.VK_WINDOWS;
+            case kVK_Control:              return KeyEvent.VK_CONTROL;
+            case kVK_RightShift:           return KeyEvent.VK_SHIFT;
+            case kVK_RightOption:          return KeyEvent.VK_WINDOWS;
+            case kVK_RightControl:         return KeyEvent.VK_CONTROL;
+            // case kVK_Function:             return KeyEvent.VK_F;
+            case kVK_F17:                  return KeyEvent.VK_F17;
+            // case kVK_VolumeUp:        
+            // case kVK_VolumeDown:
+            // case kVK_Mute:
+            case kVK_F18:                  return KeyEvent.VK_F18;
+            case kVK_F19:                  return KeyEvent.VK_F19;
+            case kVK_F20:                  return KeyEvent.VK_F20;
+            case kVK_F5:                   return KeyEvent.VK_F5;
+            case kVK_F6:                   return KeyEvent.VK_F6;
+            case kVK_F7:                   return KeyEvent.VK_F7;
+            case kVK_F3:                   return KeyEvent.VK_F3;
+            case kVK_F8:                   return KeyEvent.VK_F8;
+            case kVK_F9:                   return KeyEvent.VK_F9;
+            case kVK_F11:                  return KeyEvent.VK_F11;
+            case kVK_F13:                  return KeyEvent.VK_F13;
+            case kVK_F16:                  return KeyEvent.VK_F16;
+            case kVK_F14:                  return KeyEvent.VK_F14;
+            case kVK_F10:                  return KeyEvent.VK_F10;
+            case kVK_F12:                  return KeyEvent.VK_F12;
+            case kVK_F15:                  return KeyEvent.VK_F15;
+            case kVK_Help:                 return KeyEvent.VK_HELP;
+            case kVK_Home:                 return KeyEvent.VK_HOME;
+            case kVK_PageUp:               return KeyEvent.VK_PAGE_UP;
+            case kVK_ForwardDelete:        return KeyEvent.VK_DELETE;
+            case kVK_F4:                   return KeyEvent.VK_F4;
+            case kVK_End:                  return KeyEvent.VK_END;
+            case kVK_F2:                   return KeyEvent.VK_F2;
+            case kVK_PageDown:             return KeyEvent.VK_PAGE_DOWN;
+            case kVK_F1:                   return KeyEvent.VK_F1;
+            case kVK_LeftArrow:            return KeyEvent.VK_LEFT;
+            case kVK_RightArrow:           return KeyEvent.VK_RIGHT;
+            case kVK_DownArrow:            return KeyEvent.VK_DOWN;
+            case kVK_UpArrow:              return KeyEvent.VK_UP;
+        }
+        
+        if (keyChar == '\r') {
+            // Turn these into \n
+            return KeyEvent.VK_ENTER;
+        }
+
+        if (keyChar >= NSUpArrowFunctionKey && keyChar <= NSModeSwitchFunctionKey) {
+            switch (keyChar) {
+                case NSUpArrowFunctionKey:     return KeyEvent.VK_UP;
+                case NSDownArrowFunctionKey:   return KeyEvent.VK_DOWN;
+                case NSLeftArrowFunctionKey:   return KeyEvent.VK_LEFT;
+                case NSRightArrowFunctionKey:  return KeyEvent.VK_RIGHT;
+                case NSF1FunctionKey:          return KeyEvent.VK_F1;
+                case NSF2FunctionKey:          return KeyEvent.VK_F2;
+                case NSF3FunctionKey:          return KeyEvent.VK_F3;
+                case NSF4FunctionKey:          return KeyEvent.VK_F4;
+                case NSF5FunctionKey:          return KeyEvent.VK_F5;
+                case NSF6FunctionKey:          return KeyEvent.VK_F6;
+                case NSF7FunctionKey:          return KeyEvent.VK_F7;
+                case NSF8FunctionKey:          return KeyEvent.VK_F8;
+                case NSF9FunctionKey:          return KeyEvent.VK_F9;
+                case NSF10FunctionKey:         return KeyEvent.VK_F10;
+                case NSF11FunctionKey:         return KeyEvent.VK_F11;
+                case NSF12FunctionKey:         return KeyEvent.VK_F12;
+                case NSF13FunctionKey:         return KeyEvent.VK_F13;
+                case NSF14FunctionKey:         return KeyEvent.VK_F14;
+                case NSF15FunctionKey:         return KeyEvent.VK_F15;
+                case NSF16FunctionKey:         return KeyEvent.VK_F16;
+                case NSF17FunctionKey:         return KeyEvent.VK_F17;
+                case NSF18FunctionKey:         return KeyEvent.VK_F18;
+                case NSF19FunctionKey:         return KeyEvent.VK_F19;
+                case NSF20FunctionKey:         return KeyEvent.VK_F20;
+                case NSF21FunctionKey:         return KeyEvent.VK_F21;
+                case NSF22FunctionKey:         return KeyEvent.VK_F22;
+                case NSF23FunctionKey:         return KeyEvent.VK_F23;
+                case NSF24FunctionKey:         return KeyEvent.VK_F24;
+                case NSInsertFunctionKey:      return KeyEvent.VK_INSERT;
+                case NSDeleteFunctionKey:      return KeyEvent.VK_DELETE;
+                case NSHomeFunctionKey:        return KeyEvent.VK_HOME;
+                case NSBeginFunctionKey:       return KeyEvent.VK_BEGIN;
+                case NSEndFunctionKey:         return KeyEvent.VK_END;
+                case NSPageUpFunctionKey:      return KeyEvent.VK_PAGE_UP;
+                case NSPageDownFunctionKey:    return KeyEvent.VK_PAGE_DOWN;
+                case NSPrintScreenFunctionKey: return KeyEvent.VK_PRINTSCREEN;
+                case NSScrollLockFunctionKey:  return KeyEvent.VK_SCROLL_LOCK;
+                case NSPauseFunctionKey:       return KeyEvent.VK_PAUSE;
+                // Not handled:
+                // NSSysReqFunctionKey
+                // NSBreakFunctionKey
+                // NSResetFunctionKey
+                case NSStopFunctionKey:        return KeyEvent.VK_STOP;
+                // Not handled:
+                // NSMenuFunctionKey
+                // NSUserFunctionKey
+                // NSSystemFunctionKey
+                // NSPrintFunctionKey
+                // NSClearLineFunctionKey
+                // NSClearDisplayFunctionKey
+                // NSInsertLineFunctionKey
+                // NSDeleteLineFunctionKey
+                // NSInsertCharFunctionKey
+                // NSDeleteCharFunctionKey
+                // NSPrevFunctionKey
+                // NSNextFunctionKey
+                // NSSelectFunctionKey
+                // NSExecuteFunctionKey
+                // NSUndoFunctionKey
+                // NSRedoFunctionKey
+                // NSFindFunctionKey
+                // NSHelpFunctionKey
+                // NSModeSwitchFunctionKey
+                default: break;
+            }
+        }
+
+        if ('a' <= keyChar && keyChar <= 'z') {
+            return KeyEvent.VK_A + ( keyChar - 'a' ) ;
+        }
+
+        return (int) keyChar; // let's hope for the best (compatibility of keyChar/keyCode's)
+    }   
+}
diff --git a/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java b/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java
index e1b2ef87d..1076c5aac 100644
--- a/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java
+++ b/src/newt/classes/jogamp/newt/driver/macosx/MacWindow.java
@@ -44,100 +44,12 @@ import javax.media.nativewindow.util.Point;
 import javax.media.nativewindow.util.PointImmutable;
 
 import jogamp.newt.WindowImpl;
+import jogamp.newt.driver.DriverClearFocus;
 
 import com.jogamp.newt.event.KeyEvent;
 
-public class MacWindow extends WindowImpl implements SurfaceChangeable {
+public class MacWindow extends WindowImpl implements SurfaceChangeable, DriverClearFocus {
     
-    // Window styles
-    private static final int NSBorderlessWindowMask     = 0;
-    private static final int NSTitledWindowMask         = 1 << 0;
-    private static final int NSClosableWindowMask       = 1 << 1;
-    private static final int NSMiniaturizableWindowMask = 1 << 2;
-    private static final int NSResizableWindowMask      = 1 << 3;
-
-    // Window backing store types
-    private static final int NSBackingStoreRetained     = 0;
-    private static final int NSBackingStoreNonretained  = 1;
-    private static final int NSBackingStoreBuffered     = 2;
-
-    // Key constants handled differently on Mac OS X than other platforms
-    private static final int NSUpArrowFunctionKey        = 0xF700;
-    private static final int NSDownArrowFunctionKey      = 0xF701;
-    private static final int NSLeftArrowFunctionKey      = 0xF702;
-    private static final int NSRightArrowFunctionKey     = 0xF703;
-    private static final int NSF1FunctionKey             = 0xF704;
-    private static final int NSF2FunctionKey             = 0xF705;
-    private static final int NSF3FunctionKey             = 0xF706;
-    private static final int NSF4FunctionKey             = 0xF707;
-    private static final int NSF5FunctionKey             = 0xF708;
-    private static final int NSF6FunctionKey             = 0xF709;
-    private static final int NSF7FunctionKey             = 0xF70A;
-    private static final int NSF8FunctionKey             = 0xF70B;
-    private static final int NSF9FunctionKey             = 0xF70C;
-    private static final int NSF10FunctionKey            = 0xF70D;
-    private static final int NSF11FunctionKey            = 0xF70E;
-    private static final int NSF12FunctionKey            = 0xF70F;
-    private static final int NSF13FunctionKey            = 0xF710;
-    private static final int NSF14FunctionKey            = 0xF711;
-    private static final int NSF15FunctionKey            = 0xF712;
-    private static final int NSF16FunctionKey            = 0xF713;
-    private static final int NSF17FunctionKey            = 0xF714;
-    private static final int NSF18FunctionKey            = 0xF715;
-    private static final int NSF19FunctionKey            = 0xF716;
-    private static final int NSF20FunctionKey            = 0xF717;
-    private static final int NSF21FunctionKey            = 0xF718;
-    private static final int NSF22FunctionKey            = 0xF719;
-    private static final int NSF23FunctionKey            = 0xF71A;
-    private static final int NSF24FunctionKey            = 0xF71B;
-    private static final int NSF25FunctionKey            = 0xF71C;
-    private static final int NSF26FunctionKey            = 0xF71D;
-    private static final int NSF27FunctionKey            = 0xF71E;
-    private static final int NSF28FunctionKey            = 0xF71F;
-    private static final int NSF29FunctionKey            = 0xF720;
-    private static final int NSF30FunctionKey            = 0xF721;
-    private static final int NSF31FunctionKey            = 0xF722;
-    private static final int NSF32FunctionKey            = 0xF723;
-    private static final int NSF33FunctionKey            = 0xF724;
-    private static final int NSF34FunctionKey            = 0xF725;
-    private static final int NSF35FunctionKey            = 0xF726;
-    private static final int NSInsertFunctionKey         = 0xF727;
-    private static final int NSDeleteFunctionKey         = 0xF728;
-    private static final int NSHomeFunctionKey           = 0xF729;
-    private static final int NSBeginFunctionKey          = 0xF72A;
-    private static final int NSEndFunctionKey            = 0xF72B;
-    private static final int NSPageUpFunctionKey         = 0xF72C;
-    private static final int NSPageDownFunctionKey       = 0xF72D;
-    private static final int NSPrintScreenFunctionKey    = 0xF72E;
-    private static final int NSScrollLockFunctionKey     = 0xF72F;
-    private static final int NSPauseFunctionKey          = 0xF730;
-    private static final int NSSysReqFunctionKey         = 0xF731;
-    private static final int NSBreakFunctionKey          = 0xF732;
-    private static final int NSResetFunctionKey          = 0xF733;
-    private static final int NSStopFunctionKey           = 0xF734;
-    private static final int NSMenuFunctionKey           = 0xF735;
-    private static final int NSUserFunctionKey           = 0xF736;
-    private static final int NSSystemFunctionKey         = 0xF737;
-    private static final int NSPrintFunctionKey          = 0xF738;
-    private static final int NSClearLineFunctionKey      = 0xF739;
-    private static final int NSClearDisplayFunctionKey   = 0xF73A;
-    private static final int NSInsertLineFunctionKey     = 0xF73B;
-    private static final int NSDeleteLineFunctionKey     = 0xF73C;
-    private static final int NSInsertCharFunctionKey     = 0xF73D;
-    private static final int NSDeleteCharFunctionKey     = 0xF73E;
-    private static final int NSPrevFunctionKey           = 0xF73F;
-    private static final int NSNextFunctionKey           = 0xF740;
-    private static final int NSSelectFunctionKey         = 0xF741;
-    private static final int NSExecuteFunctionKey        = 0xF742;
-    private static final int NSUndoFunctionKey           = 0xF743;
-    private static final int NSRedoFunctionKey           = 0xF744;
-    private static final int NSFindFunctionKey           = 0xF745;
-    private static final int NSHelpFunctionKey           = 0xF746;
-    private static final int NSModeSwitchFunctionKey     = 0xF747;
-
-    private volatile long surfaceHandle;
-    private long sscSurfaceHandle;
-
     static {
         MacDisplay.initSingleton();
     }
@@ -177,12 +89,17 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     
     @Override
     protected int lockSurfaceImpl() {
-        return lockSurface0(getWindowHandle()) ? LOCK_SUCCESS : LOCK_SURFACE_NOT_READY;
+        if(!isOffscreenInstance) {
+            return lockSurface0(getWindowHandle()) ? LOCK_SUCCESS : LOCK_SURFACE_NOT_READY;
+        }
+        return LOCK_SUCCESS;
     }
 
     @Override
     protected void unlockSurfaceImpl() {
-        unlockSurface0(getWindowHandle());
+        if(!isOffscreenInstance) {
+            unlockSurface0(getWindowHandle());
+        }
     }
     
     @Override
@@ -215,28 +132,43 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     }
 
     protected void requestFocusImpl(boolean force) {
-        requestFocus0(getWindowHandle(), force);
+        if(!isOffscreenInstance) {
+            requestFocus0(getWindowHandle(), force);
+        } else {
+            focusChanged(false, true);
+        }
+    }
+        
+    public final void clearFocus() {
+        if(DEBUG_IMPLEMENTATION) {
+            System.err.println("MacWindow: clearFocus() - requestFocusParent, isOffscreenInstance "+isOffscreenInstance);
+        }
+        if(!isOffscreenInstance) {
+            requestFocusParent0(getWindowHandle());
+        } else {
+            focusChanged(false, false);
+        }
     }
     
     protected boolean reconfigureWindowImpl(int x, int y, int width, int height, int flags) {
         final PointImmutable pS = position2TopLevel(new Point(x, y));
-        final boolean offscreenInstance = 0 != sscSurfaceHandle || isOffscreenInstance(this, this.getParent());
+        isOffscreenInstance = 0 != sscSurfaceHandle || isOffscreenInstance(this, this.getParent());
         
         if(DEBUG_IMPLEMENTATION) {
             System.err.println("MacWindow reconfig: "+x+"/"+y+" -> "+pS+" - "+width+"x"+height+
-                               ", offscreenInstance "+offscreenInstance+
+                               ", offscreenInstance "+isOffscreenInstance+
                                ", "+getReconfigureFlagsAsString(null, flags));
         }
         
         if( getWindowHandle() == 0 ) {
             if( 0 != ( FLAG_IS_VISIBLE & flags) ) {
-                createWindow(offscreenInstance, false, pS, width, height, 0 != ( FLAG_IS_FULLSCREEN & flags));
+                createWindow(isOffscreenInstance, false, pS, width, height, 0 != ( FLAG_IS_FULLSCREEN & flags));
                 // no native event ..
                 visibleChanged(true, true); 
             } /* else { ?? } */
         } else {
             if( 0 != ( FLAG_CHANGE_VISIBILITY & flags) && 0 == ( FLAG_IS_VISIBLE & flags) ) {
-                if ( !offscreenInstance ) {
+                if ( !isOffscreenInstance ) {
                     orderOut0(getWindowHandle());
                 }
                 // no native event ..
@@ -245,27 +177,32 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
             if( 0 != ( FLAG_CHANGE_DECORATION & flags) ||
                 0 != ( FLAG_CHANGE_PARENTING & flags) ||
                 0 != ( FLAG_CHANGE_FULLSCREEN & flags) ) {
-                createWindow(offscreenInstance, true, pS, width, height, 0 != ( FLAG_IS_FULLSCREEN & flags));
+                 // FIXME: need solution for fullscreen ..
+                createWindow(isOffscreenInstance, true, pS, width, height, 0 != ( FLAG_IS_FULLSCREEN & flags));
                 if(isVisible()) { flags |= FLAG_CHANGE_VISIBILITY; } 
             }
             if(x>=0 && y>=0) {
-                setFrameTopLeftPoint0(getParentWindowHandle(), getWindowHandle(), pS.getX(), pS.getY());               
+                if( !isOffscreenInstance ) {                
+                    setFrameTopLeftPoint0(getParentWindowHandle(), getWindowHandle(), pS.getX(), pS.getY());
+                } // FIXME: need solution for position ..
                 // no native event (fullscreen, some reparenting)
                 positionChanged(true, getLocationOnScreenImpl(0, 0)); // incl. validation
             }
             if(width>0 && height>0) {
-                setContentSize0(getWindowHandle(), width, height);
+                if( !isOffscreenInstance ) {                
+                    setContentSize0(getWindowHandle(), width, height);
+                } // FIXME: need solution for size ..
                 // no native event (fullscreen, some reparenting)
                 sizeChanged(true, width, height, false); // incl. validation (incl. repositioning)
             }
             if( 0 != ( FLAG_CHANGE_VISIBILITY & flags) && 0 != ( FLAG_IS_VISIBLE & flags) ) {
-                if( !offscreenInstance ) {                
+                if( !isOffscreenInstance ) {                
                     orderFront0(getWindowHandle());
                 }
                 // no native event ..
                 visibleChanged(true, true);
             } 
-            if( !offscreenInstance ) {                
+            if( !isOffscreenInstance ) {                
                 setAlwaysOnTop0(getWindowHandle(), 0 != ( FLAG_IS_ALWAYSONTOP & flags));
             }
         }
@@ -273,7 +210,8 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     }
 
     protected Point getLocationOnScreenImpl(int x, int y) {
-        return (Point) getLocationOnScreen0(getWindowHandle(), x, y);
+        return position2TopLevel(new Point(x, y)); // allows offscreen ..        
+        // return (Point) getLocationOnScreen0(getWindowHandle(), x, y);
     }
     
     protected void updateInsetsImpl(Insets insets) {
@@ -296,25 +234,33 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     
     @Override
     protected boolean setPointerVisibleImpl(final boolean pointerVisible) {
-        return setPointerVisible0(getWindowHandle(), pointerVisible);
+        if( !isOffscreenInstance ) {                
+            return setPointerVisible0(getWindowHandle(), pointerVisible);
+        } // else FIXME: need solution
+        return false;
     }
 
     @Override
     protected boolean confinePointerImpl(final boolean confine) {
-        return confinePointer0(getWindowHandle(), confine);
+        if( !isOffscreenInstance ) {                
+            return confinePointer0(getWindowHandle(), confine);
+        } // else FIXME: need solution
+        return false;
     }
     
     @Override
     protected void warpPointerImpl(final int x, final int y) {
-        warpPointer0(getWindowHandle(), x, y);
+        if( !isOffscreenInstance ) {                
+            warpPointer0(getWindowHandle(), x, y);
+        } // else FIXME: need solution
     }
     
     @Override
     public void sendKeyEvent(int eventType, int modifiers, int keyCode, char keyChar) {
         // 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
-        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));
+        final int keyCode2 = MacKeyUtil.validateKeyCode(keyCode, keyChar);
+        if(DEBUG_IMPLEMENTATION) System.err.println("MacWindow.sendKeyEvent "+Thread.currentThread().getName()+" char: 0x"+Integer.toHexString(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);        
@@ -324,8 +270,8 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     public void enqueueKeyEvent(boolean wait, int eventType, int modifiers, int keyCode, char keyChar) {
         // 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
-        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));
+        final int keyCode2 = MacKeyUtil.validateKeyCode(keyCode, keyChar);
+        if(DEBUG_IMPLEMENTATION) System.err.println("MacWindow.enqueueKeyEvent "+Thread.currentThread().getName()+" char: 0x"+Integer.toHexString(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);
@@ -335,89 +281,6 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     // Internals only
     //    
     
-    private char convertKeyChar(char keyChar) {
-        if (keyChar == '\r') {
-            // Turn these into \n
-            return '\n';
-        }
-
-        if (keyChar >= NSUpArrowFunctionKey && keyChar <= NSModeSwitchFunctionKey) {
-            switch (keyChar) {
-                case NSUpArrowFunctionKey:     return KeyEvent.VK_UP;
-                case NSDownArrowFunctionKey:   return KeyEvent.VK_DOWN;
-                case NSLeftArrowFunctionKey:   return KeyEvent.VK_LEFT;
-                case NSRightArrowFunctionKey:  return KeyEvent.VK_RIGHT;
-                case NSF1FunctionKey:          return KeyEvent.VK_F1;
-                case NSF2FunctionKey:          return KeyEvent.VK_F2;
-                case NSF3FunctionKey:          return KeyEvent.VK_F3;
-                case NSF4FunctionKey:          return KeyEvent.VK_F4;
-                case NSF5FunctionKey:          return KeyEvent.VK_F5;
-                case NSF6FunctionKey:          return KeyEvent.VK_F6;
-                case NSF7FunctionKey:          return KeyEvent.VK_F7;
-                case NSF8FunctionKey:          return KeyEvent.VK_F8;
-                case NSF9FunctionKey:          return KeyEvent.VK_F9;
-                case NSF10FunctionKey:         return KeyEvent.VK_F10;
-                case NSF11FunctionKey:         return KeyEvent.VK_F11;
-                case NSF12FunctionKey:         return KeyEvent.VK_F12;
-                case NSF13FunctionKey:         return KeyEvent.VK_F13;
-                case NSF14FunctionKey:         return KeyEvent.VK_F14;
-                case NSF15FunctionKey:         return KeyEvent.VK_F15;
-                case NSF16FunctionKey:         return KeyEvent.VK_F16;
-                case NSF17FunctionKey:         return KeyEvent.VK_F17;
-                case NSF18FunctionKey:         return KeyEvent.VK_F18;
-                case NSF19FunctionKey:         return KeyEvent.VK_F19;
-                case NSF20FunctionKey:         return KeyEvent.VK_F20;
-                case NSF21FunctionKey:         return KeyEvent.VK_F21;
-                case NSF22FunctionKey:         return KeyEvent.VK_F22;
-                case NSF23FunctionKey:         return KeyEvent.VK_F23;
-                case NSF24FunctionKey:         return KeyEvent.VK_F24;
-                case NSInsertFunctionKey:      return KeyEvent.VK_INSERT;
-                case NSDeleteFunctionKey:      return KeyEvent.VK_DELETE;
-                case NSHomeFunctionKey:        return KeyEvent.VK_HOME;
-                case NSBeginFunctionKey:       return KeyEvent.VK_BEGIN;
-                case NSEndFunctionKey:         return KeyEvent.VK_END;
-                case NSPageUpFunctionKey:      return KeyEvent.VK_PAGE_UP;
-                case NSPageDownFunctionKey:    return KeyEvent.VK_PAGE_DOWN;
-                case NSPrintScreenFunctionKey: return KeyEvent.VK_PRINTSCREEN;
-                case NSScrollLockFunctionKey:  return KeyEvent.VK_SCROLL_LOCK;
-                case NSPauseFunctionKey:       return KeyEvent.VK_PAUSE;
-                // Not handled:
-                // NSSysReqFunctionKey
-                // NSBreakFunctionKey
-                // NSResetFunctionKey
-                case NSStopFunctionKey:        return KeyEvent.VK_STOP;
-                // Not handled:
-                // NSMenuFunctionKey
-                // NSUserFunctionKey
-                // NSSystemFunctionKey
-                // NSPrintFunctionKey
-                // NSClearLineFunctionKey
-                // NSClearDisplayFunctionKey
-                // NSInsertLineFunctionKey
-                // NSDeleteLineFunctionKey
-                // NSInsertCharFunctionKey
-                // NSDeleteCharFunctionKey
-                // NSPrevFunctionKey
-                // NSNextFunctionKey
-                // NSSelectFunctionKey
-                // NSExecuteFunctionKey
-                // NSUndoFunctionKey
-                // NSRedoFunctionKey
-                // NSFindFunctionKey
-                // NSHelpFunctionKey
-                // NSModeSwitchFunctionKey
-                default: break;
-            }
-        }
-
-        // NSEvent's charactersIgnoringModifiers doesn't ignore the shift key
-        if (keyChar >= 'a' && keyChar <= 'z') {
-            return Character.toUpperCase(keyChar);
-        }
-
-        return keyChar;
-    }
-
     private void createWindow(final boolean offscreenInstance, final boolean recreate, 
                               final PointImmutable pS, final int width, final int height, 
                               final boolean fullscreen) {
@@ -506,6 +369,7 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     private native boolean lockSurface0(long window);
     private native void unlockSurface0(long window);
     private native void requestFocus0(long window, boolean force);
+    private native void requestFocusParent0(long window);
     /** in case of a child window, it actually only issues orderBack(..) */
     private native void orderOut0(long window);
     private native void orderFront0(long window);
@@ -520,4 +384,21 @@ public class MacWindow extends WindowImpl implements SurfaceChangeable {
     private static native boolean setPointerVisible0(long windowHandle, boolean visible);
     private static native boolean confinePointer0(long windowHandle, boolean confine);
     private static native void warpPointer0(long windowHandle, int x, int y);
+    
+    // Window styles
+    private static final int NSBorderlessWindowMask     = 0;
+    private static final int NSTitledWindowMask         = 1 << 0;
+    private static final int NSClosableWindowMask       = 1 << 1;
+    private static final int NSMiniaturizableWindowMask = 1 << 2;
+    private static final int NSResizableWindowMask      = 1 << 3;
+
+    // Window backing store types
+    private static final int NSBackingStoreRetained     = 0;
+    private static final int NSBackingStoreNonretained  = 1;
+    private static final int NSBackingStoreBuffered     = 2;
+
+    private volatile long surfaceHandle;
+    private long sscSurfaceHandle;
+    private boolean isOffscreenInstance;
+    
 }