iOS: Initial working commit supporting iOS (ipad pro 11)

using our OpenJFK 9 x86_64 and arm64 build.

Test demo class is 'com.jogamp.opengl.demos.ios.Hello',
residing in the new demo folder 'src/demos/com/jogamp/opengl/demos/ios/Hello.java'.

This commit does not yet include a working NEWT
specialization for iOS, but it shall followup soon.

Instead this commit demonstrates JOGL operating on
native UIWindow, UIView and CAEAGLLayer as provided by
Nativewindow's IOSUtil.

Test Video https://www.youtube.com/watch?v=Z4lUQNFTGMI

+++

Notable bug: The FBO used and sharing the COLORBUFFER RENDERBUFFER
memory resources with CAEAGLLayer to be displayed in the UIView
seemingly cannot handle GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24
or GL_DEPTH_COMPONENT32 depth buffer - none at all (Device + Simulation).

Therefor the default demo GLEventListener chosen here
don't require a depth buffer ;-)

This issue can hopefully be mitigated with other means
than using a flat FBO sink similar to FBO multisampling.

4 files changed, 2138 insertions, 0 deletions

diff --git a/src/newt/native/IOSNewtUIWindow.h b/src/newt/native/IOSNewtUIWindow.h
new file mode 100644
index 000000000..27ca7f3c7
--- /dev/null
+++ b/src/newt/native/IOSNewtUIWindow.h
@@ -0,0 +1,152 @@
+/**
+ * Copyright 2019 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+#import <UIKit/UIKit.h>
+#import <QuartzCore/QuartzCore.h>
+#import <pthread.h>
+#import "jni.h"
+
+#include "NewtCommon.h"
+
+// #define VERBOSE_ON 1
+
+#ifdef VERBOSE_ON
+    #define DBG_PRINT(...) NSLog(@ __VA_ARGS__) ; fflush(stderr)
+    // #define DBG_PRINT(...) fprintf(stderr, __VA_ARGS__); fflush(stderr)
+#else
+    #define DBG_PRINT(...)
+#endif
+
+// #define DBG_LIFECYCLE 1
+
+@interface NewtUIView : UIView
+{
+    jobject javaWindowObject;
+
+    volatile BOOL destroyNotifySent;
+    volatile int softLockCount;
+    pthread_mutex_t softLockSync;
+
+    BOOL modsDown[4]; // shift, ctrl, alt/option, win/command
+}
+
+- (id)initWithFrame:(CGRect)frameRect;
+
+#ifdef DBG_LIFECYCLE
+- (void) release;
+#endif
+- (void) dealloc;
+
+/* Register or deregister (NULL) the java Window object, 
+   ie, if NULL, no events are send */
+- (void) setJavaWindowObject: (jobject) javaWindowObj;
+- (jobject) getJavaWindowObject;
+
+- (void) setDestroyNotifySent: (BOOL) v;
+- (BOOL) getDestroyNotifySent;
+
+- (BOOL) softLock;
+- (BOOL) softUnlock;
+
+- (void) drawRect:(CGRect)dirtyRect;
+- (BOOL) acceptsFirstResponder;
+- (BOOL) becomeFirstResponder;
+- (BOOL) resignFirstResponder;
+
+- (void) sendMouseEvent: (UIEvent*) event eventType: (jshort) evType;
+- (CGPoint) screenPos2NewtClientWinPos: (CGPoint) p;
+
+- (void) handleFlagsChanged:(NSUInteger) mods;
+- (void) handleFlagsChanged:(int) keyMask keyIndex: (int) keyIdx keyCode: (int) keyCode modifiers: (NSUInteger) mods;
+- (void) sendKeyEvent: (UIEvent*) event eventType: (jshort) evType;
+- (void) sendKeyEvent: (jshort) keyCode characters: (NSString*) chars modifiers: (NSUInteger)mods eventType: (jshort) evType;
+
+@end
+
+@interface NewtUIWindow : UIWindow
+{
+    BOOL realized;
+    jboolean withinLiveResize;
+@public
+    BOOL hasPresentationSwitch;
+    NSUInteger defaultPresentationOptions;
+    NSUInteger fullscreenPresentationOptions;
+    BOOL isFullscreenWindow;
+    int cachedInsets[4]; // l, r, t, b
+}
+
++ (BOOL) initNatives: (JNIEnv*) env forClass: (jobject) clazz;
+
+- (id) initWithFrame: (CGRect) contentRect
+       styleMask: (NSUInteger) windowStyle
+       backing: (NSUInteger) bufferingType
+       defer: (BOOL) deferCreation
+       isFullscreenWindow:(BOOL)isfs;
+#ifdef DBG_LIFECYCLE
+- (void) release;
+#endif
+- (void) dealloc;
+- (void) setRealized: (BOOL)v;
+- (BOOL) isRealized;
+
+- (void) setAlwaysOn: (BOOL)top bottom:(BOOL)bottom;
+
+- (void) updateInsets: (JNIEnv*) env jwin: (jobject) javaWin;
+- (void) updateSizePosInsets: (JNIEnv*) env jwin: (jobject) javaWin defer: (jboolean)defer;
+- (void) attachToParent: (UIWindow*) parent;
+- (void) detachFromParent: (UIWindow*) parent;
+
+- (CGPoint) newtRelClientTLWinPos2AbsTLScreenPos: (CGPoint) p;
+- (CGSize) newtClientSize2TLSize: (CGSize) nsz;
+- (CGPoint) getLocationOnScreen: (CGPoint) p;
+
+- (void) focusChanged: (BOOL) gained;
+
+- (void) flagsChanged: (UIEvent *) theEvent;
+- (BOOL) acceptsMouseMovedEvents;
+- (BOOL) acceptsFirstResponder;
+- (BOOL) becomeFirstResponder;
+- (BOOL) resignFirstResponder;
+- (BOOL) canBecomeKeyWindow;
+- (void) becomeKeyWindow;
+- (void) resignKeyWindow;
+- (void) windowDidBecomeKey: (NSNotification *) notification;
+- (void) windowDidResignKey: (NSNotification *) notification;
+
+- (void) windowWillStartLiveResize: (NSNotification *) notification;
+- (void) windowDidEndLiveResize: (NSNotification *) notification;
+- (CGSize) windowWillResize: (UIWindow *)sender toSize:(CGSize)frameSize;
+- (void) windowDidResize: (NSNotification*) notification;
+- (void) sendResizeEvent;
+
+- (void) windowDidMove: (NSNotification*) notification;
+- (BOOL) windowClosingImpl: (BOOL) force;
+- (BOOL) windowShouldClose: (id) sender;
+- (void) windowWillClose: (NSNotification*) notification;
+
+@end
diff --git a/src/newt/native/IOSNewtUIWindow.m b/src/newt/native/IOSNewtUIWindow.m
new file mode 100644
index 000000000..6c5031efc
--- /dev/null
+++ b/src/newt/native/IOSNewtUIWindow.m
@@ -0,0 +1,783 @@
+/**
+ * Copyright 2019 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+#import "IOSNewtUIWindow.h"
+#import "InputEvent.h"
+#import "KeyEvent.h"
+#import "MouseEvent.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <math.h>
+
+#define PRINTF(...) NSLog(@ __VA_ARGS__)
+
+static jmethodID enqueueMouseEventID = NULL;
+static jmethodID enqueueKeyEventID = NULL;
+static jmethodID requestFocusID = NULL;
+
+static jmethodID insetsChangedID   = NULL;
+static jmethodID sizeChangedID     = NULL;
+static jmethodID sizeScreenPosInsetsChangedID = NULL;
+static jmethodID updatePixelScaleID = NULL;
+static jmethodID visibleChangedID = NULL;
+static jmethodID screenPositionChangedID = NULL;
+static jmethodID focusChangedID    = NULL;
+static jmethodID windowDestroyNotifyID = NULL;
+static jmethodID windowRepaintID = NULL;
+
+// Need to enqueue all events to EDT,
+// since we may operate on AWT-AppKit (Main Thread)
+// and direct issuing 'requestFocus()' would deadlock:
+//     AWT-AppKit
+//     AWT-EventQueue-0
+
+@implementation NewtUIView
+
+- (id)initWithFrame:(CGRect)frameRect
+{
+    id res = [super initWithFrame:frameRect];
+    javaWindowObject = NULL;
+
+    destroyNotifySent = NO;
+    softLockCount = 0;
+
+    pthread_mutexattr_t softLockSyncAttr;
+    pthread_mutexattr_init(&softLockSyncAttr);
+    pthread_mutexattr_settype(&softLockSyncAttr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&softLockSync, &softLockSyncAttr); // recursive
+
+    modsDown[0] = NO; // shift
+    modsDown[1] = NO; // ctrl
+    modsDown[2] = NO; // alt
+    modsDown[3] = NO; // win
+
+    DBG_PRINT("NewtUIView::create: %p (refcnt %d)\n", res, (int)[res retainCount]);
+    return res;
+}
+
+#ifdef DBG_LIFECYCLE
+- (void) release
+{
+    DBG_PRINT("NewtUIView::release.0: %p (refcnt %d)\n", self, (int)[self retainCount]);
+    [super release];
+}
+#endif
+
+- (void) dealloc
+{
+    DBG_PRINT("NewtUIView::dealloc.0: %p (refcnt %d), ptrTrackingTag %d\n", self, (int)[self retainCount], (int)ptrTrackingTag);
+#ifdef DBG_LIFECYCLE
+    NSLog(@"%@",[NSThread callStackSymbols]);
+#endif
+    if( 0 < softLockCount ) {
+        NSLog(@"NewtUIView::dealloc: softLock still hold @ dealloc!\n");
+    }
+
+    pthread_mutex_destroy(&softLockSync);
+    DBG_PRINT("NewtUIView::dealloc.X: %p\n", self);
+    [super dealloc];
+}
+
+- (void) setJavaWindowObject: (jobject) javaWindowObj
+{
+    javaWindowObject = javaWindowObj;
+}
+
+- (jobject) getJavaWindowObject
+{
+    return javaWindowObject;
+}
+
+- (void) setDestroyNotifySent: (BOOL) v
+{
+    destroyNotifySent = v;
+}
+
+- (BOOL) getDestroyNotifySent
+{
+    return destroyNotifySent;
+}
+
+- (BOOL) softLock
+{
+    // DBG_PRINT("*************** softLock.0: %p\n", (void*)pthread_self());
+    int err;
+    if( 0 != ( err = pthread_mutex_lock(&softLockSync) ) ) {
+        NSLog(@"NewtUIView::softLock failed: errCode %d - %@", err, [NSThread callStackSymbols]);
+        return NO;
+    }
+    softLockCount++;
+    // DBG_PRINT("*************** softLock.X: %p\n", (void*)pthread_self());
+    return 0 < softLockCount;
+}
+
+- (BOOL) softUnlock
+{
+    // DBG_PRINT("*************** softUnlock: %p\n", (void*)pthread_self());
+    softLockCount--;
+    int err;
+    if( 0 != ( err = pthread_mutex_unlock(&softLockSync) ) ) {
+        softLockCount++;
+        NSLog(@"NewtUIView::softUnlock failed: Not locked by current thread - errCode %d -  %@", err, [NSThread callStackSymbols]);
+        return NO;
+    }
+    return YES;
+}
+
+- (void) drawRect:(CGRect)dirtyRect
+{
+    DBG_PRINT("*************** dirtyRect: %p %lf/%lf %lfx%lf\n", 
+        javaWindowObject, dirtyRect.origin.x, dirtyRect.origin.y, dirtyRect.size.width, dirtyRect.size.height);
+
+    if(NULL==javaWindowObject) {
+        DBG_PRINT("drawRect: null javaWindowObject\n");
+        return;
+    }
+    int shallBeDetached = 0;
+    JNIEnv* env = NewtCommon_GetJNIEnv(1 /* asDaemon */, &shallBeDetached);
+    if(NULL==env) {
+        DBG_PRINT("drawRect: null JNIEnv\n");
+        return;
+    }
+
+    CGRect viewFrame = [self frame];
+
+    (*env)->CallVoidMethod(env, javaWindowObject, windowRepaintID, JNI_TRUE, // defer ..
+        (int)dirtyRect.origin.x, (int)viewFrame.size.height - (int)dirtyRect.origin.y, 
+        (int)dirtyRect.size.width, (int)dirtyRect.size.height);
+
+    // detaching thread not required - daemon
+    // NewtCommon_ReleaseJNIEnv(shallBeDetached);
+}
+
+- (BOOL) acceptsFirstResponder 
+{
+    return YES;
+}
+
+- (BOOL) becomeFirstResponder
+{
+    DBG_PRINT( "*************** View.becomeFirstResponder\n");
+    return [super becomeFirstResponder];
+}
+
+- (BOOL) resignFirstResponder
+{
+    DBG_PRINT( "*************** View.resignFirstResponder\n");
+    return [super resignFirstResponder];
+}
+
+- (void) sendMouseEvent: (UIEvent*) event eventType: (jshort) evType
+{
+    if (javaWindowObject == NULL) {
+        DBG_PRINT("sendMouseEvent: null javaWindowObject\n");
+        return;
+    }
+    int shallBeDetached = 0;
+    JNIEnv* env = NewtCommon_GetJNIEnv(1 /* asDaemon */, &shallBeDetached);
+    if(NULL==env) {
+        DBG_PRINT("sendMouseEvent: null JNIEnv\n");
+        return;
+    }
+    jint javaMods[] = { 0 } ;
+    javaMods[0] = 0; // TODO mods2JavaMods([event modifierFlags]);
+
+    // convert to 1-based button number (or use zero if no button is involved)
+    // TODO: detect mouse button when mouse wheel scrolled  
+    jshort javaButtonNum = 1;
+    jfloat scrollDeltaY = 0.0f;
+    /**
+    switch ([event type]) {
+        case NSLeftMouseDown:
+        case NSLeftMouseUp:
+        case NSLeftMouseDragged:
+            javaButtonNum = 1;
+            break;
+        case NSRightMouseDown:
+        case NSRightMouseUp:
+        case NSRightMouseDragged:
+            javaButtonNum = 3;
+            break;
+        case NSOtherMouseDown:
+        case NSOtherMouseUp:
+        case NSOtherMouseDragged:
+            javaButtonNum = 2;
+            break;
+        default:
+            javaButtonNum = 0;
+            break;
+    } */
+    CGPoint location = CGPointMake(0,0); // TODO [self screenPos2NewtClientWinPos: [UIEvent mouseLocation]];
+
+    (*env)->CallVoidMethod(env, javaWindowObject, enqueueMouseEventID, JNI_FALSE,
+                           evType, javaMods[0],
+                           (jint) location.x, (jint) location.y,
+                           javaButtonNum, scrollDeltaY);
+
+    // detaching thread not required - daemon
+    // NewtCommon_ReleaseJNIEnv(shallBeDetached);
+}
+
+- (CGPoint) screenPos2NewtClientWinPos: (CGPoint) p
+{
+    CGRect viewFrame = [self frame];
+
+    CGRect r;
+    r.origin.x = p.x;
+    r.origin.y = p.y;
+    r.size.width = 0;
+    r.size.height = 0;
+    // CGRect rS = [[self window] convertRectFromScreen: r]; // 10.7
+    CGPoint oS = r.origin; // TODO [[self window] convertScreenToBase: r.origin];
+    oS.y = viewFrame.size.height - oS.y; // y-flip
+    return oS;
+}
+
+- (void) handleFlagsChanged:(NSUInteger) mods
+{
+    // TODO [self handleFlagsChanged: NSShiftKeyMask keyIndex: 0 keyCode: kVK_Shift modifiers: mods];
+    // TODO [self handleFlagsChanged: NSControlKeyMask keyIndex: 1 keyCode: kVK_Control modifiers: mods];
+    // TODO [self handleFlagsChanged: NSAlternateKeyMask keyIndex: 2 keyCode: kVK_Option modifiers: mods];
+    // TODO [self handleFlagsChanged: NSCommandKeyMask keyIndex: 3 keyCode: kVK_Command modifiers: mods];
+}
+
+- (void) handleFlagsChanged:(int) keyMask keyIndex: (int) keyIdx keyCode: (int) keyCode modifiers: (NSUInteger) mods
+{
+    if ( NO == modsDown[keyIdx] && 0 != ( mods & keyMask ) )  {
+        modsDown[keyIdx] = YES;
+        [self sendKeyEvent: (jshort)keyCode characters: NULL modifiers: mods|keyMask eventType: (jshort)EVENT_KEY_PRESSED];
+    } else if ( YES == modsDown[keyIdx] && 0 == ( mods & keyMask ) )  {
+        modsDown[keyIdx] = NO;
+        [self sendKeyEvent: (jshort)keyCode characters: NULL modifiers: mods|keyMask eventType: (jshort)EVENT_KEY_RELEASED];
+    }
+}
+
+- (void) sendKeyEvent: (UIEvent*) event eventType: (jshort) evType
+{
+    jshort keyCode = 0; // TODO (jshort) [event keyCode];
+    NSString* chars = NULL; // TODO [event charactersIgnoringModifiers];
+    NSUInteger mods = 0; // TODO [event modifierFlags];
+    [self sendKeyEvent: keyCode characters: chars modifiers: mods eventType: evType];
+}
+
+- (void) sendKeyEvent: (jshort) keyCode characters: (NSString*) chars modifiers: (NSUInteger)mods eventType: (jshort) evType
+{
+    if (javaWindowObject == NULL) {
+        DBG_PRINT("sendKeyEvent: null javaWindowObject\n");
+        return;
+    }
+    int shallBeDetached = 0;
+    JNIEnv* env = NewtCommon_GetJNIEnv(1 /* asDaemon */, &shallBeDetached);
+    if(NULL==env) {
+        DBG_PRINT("sendKeyEvent: null JNIEnv\n");
+        return;
+    }
+
+    int i;
+    int len = NULL != chars ? [chars length] : 0;
+    jint javaMods = 0; // TODO mods2JavaMods(mods);
+
+    if(len > 0) {
+        // printable chars
+        for (i = 0; i < len; i++) {
+            // Note: the key code in the UIEvent does not map to anything we can use
+            UniChar keyChar = (UniChar) [chars characterAtIndex: i];
+            UniChar keySymChar = 0; // TODO CKCH_CharForKeyCode(keyCode);
+
+            DBG_PRINT("sendKeyEvent: %d/%d code 0x%X, char 0x%X, mods 0x%X/0x%X -> keySymChar 0x%X\n", i, len, (int)keyCode, (int)keyChar, 
+                      (int)mods, (int)javaMods, (int)keySymChar);
+
+            (*env)->CallVoidMethod(env, javaWindowObject, enqueueKeyEventID, JNI_FALSE,
+                                   evType, javaMods, keyCode, (jchar)keyChar, (jchar)keySymChar);
+        }
+    } else {
+        // non-printable chars
+        jchar keyChar = (jchar) 0;
+
+        DBG_PRINT("sendKeyEvent: code 0x%X\n", (int)keyCode);
+
+        (*env)->CallVoidMethod(env, javaWindowObject, enqueueKeyEventID, JNI_FALSE,
+                               evType, javaMods, keyCode, keyChar, keyChar);
+    }
+
+    // detaching thread not required - daemon
+    // NewtCommon_ReleaseJNIEnv(shallBeDetached);
+}
+
+@end
+
+@implementation NewtUIWindow
+
++ (BOOL) initNatives: (JNIEnv*) env forClass: (jclass) clazz
+{
+    enqueueMouseEventID = (*env)->GetMethodID(env, clazz, "enqueueMouseEvent", "(ZSIIISF)V");
+    enqueueKeyEventID = (*env)->GetMethodID(env, clazz, "enqueueKeyEvent", "(ZSISCC)V");
+    sizeChangedID = (*env)->GetMethodID(env, clazz, "sizeChanged", "(ZIIZ)V");
+    updatePixelScaleID = (*env)->GetMethodID(env, clazz, "updatePixelScale", "(ZFF)V");
+    visibleChangedID = (*env)->GetMethodID(env, clazz, "visibleChanged", "(ZZ)V");
+    insetsChangedID = (*env)->GetMethodID(env, clazz, "insetsChanged", "(ZIIII)V");
+    sizeScreenPosInsetsChangedID = (*env)->GetMethodID(env, clazz, "sizeScreenPosInsetsChanged", "(ZIIIIIIIIZZ)V");
+    screenPositionChangedID = (*env)->GetMethodID(env, clazz, "screenPositionChanged", "(ZII)V");
+    focusChangedID = (*env)->GetMethodID(env, clazz, "focusChanged", "(ZZ)V");
+    windowDestroyNotifyID = (*env)->GetMethodID(env, clazz, "windowDestroyNotify", "(Z)Z");
+    windowRepaintID = (*env)->GetMethodID(env, clazz, "windowRepaint", "(ZIIII)V");
+    requestFocusID = (*env)->GetMethodID(env, clazz, "requestFocus", "(Z)V");
+    if (enqueueMouseEventID && enqueueKeyEventID && sizeChangedID && updatePixelScaleID && visibleChangedID && 
+        insetsChangedID && sizeScreenPosInsetsChangedID &&
+        screenPositionChangedID && focusChangedID && windowDestroyNotifyID && requestFocusID && windowRepaintID)
+    {
+        // TODO CKCH_CreateDictionaries();
+        return YES;
+    }
+    return NO;
+}
+
+- (id) initWithFrame: (CGRect) contentRect
+       styleMask: (NSUInteger) windowStyle
+       backing: (NSUInteger) bufferingType
+       defer: (BOOL) deferCreation
+       isFullscreenWindow:(BOOL)isfs
+{
+    /**
+    id res = [super initWithContentRect: contentRect
+                    styleMask: windowStyle
+                    backing: bufferingType
+                    defer: deferCreation];
+     */
+    id res = [super initWithFrame: contentRect];
+    // OSX 10.6
+    /** TODO
+    if ( [NSApp respondsToSelector:@selector(currentSystemPresentationOptions)] &&
+         [NSApp respondsToSelector:@selector(setPresentationOptions:)] ) {
+        hasPresentationSwitch = YES;
+        defaultPresentationOptions = [NSApp currentSystemPresentationOptions];
+        fullscreenPresentationOptions = 
+                // NSApplicationPresentationDefault|
+                // NSApplicationPresentationAutoHideDock|
+                NSApplicationPresentationHideDock|
+                // NSApplicationPresentationAutoHideMenuBar|
+                NSApplicationPresentationHideMenuBar|
+                NSApplicationPresentationDisableAppleMenu|
+                // NSApplicationPresentationDisableProcessSwitching|
+                // NSApplicationPresentationDisableSessionTermination|
+                NSApplicationPresentationDisableHideApplication|
+                // NSApplicationPresentationDisableMenuBarTransparency|
+                // NSApplicationPresentationFullScreen| // OSX 10.7
+                0 ;
+    } else {
+    */
+        hasPresentationSwitch = NO;
+        defaultPresentationOptions = 0;
+        fullscreenPresentationOptions = 0; 
+    // }
+
+    isFullscreenWindow = NO; // TODO isfs;
+    // Why is this necessary? Without it we don't get any of the
+    // delegate methods like resizing and window movement.
+    // TODO [self setDelegate: self];
+
+    cachedInsets[0] = 0; // l
+    cachedInsets[1] = 0; // r
+    cachedInsets[2] = 0; // t
+    cachedInsets[3] = 0; // b
+
+    realized = YES;
+    withinLiveResize = JNI_FALSE;
+    DBG_PRINT("NewtWindow::create: %p, realized %d, hasPresentationSwitch %d[defaultOptions 0x%X, fullscreenOptions 0x%X], (refcnt %d)\n", 
+        res, realized, (int)hasPresentationSwitch, (int)defaultPresentationOptions, (int)fullscreenPresentationOptions, (int)[res retainCount]);
+    return res;
+}
+
+#ifdef DBG_LIFECYCLE
+- (void) release
+{
+    DBG_PRINT("NewtWindow::release.0: %p (refcnt %d)\n", self, (int)[self retainCount]);
+    // NSLog(@"%@",[NSThread callStackSymbols]);
+    [super release];
+}
+#endif
+
+- (void) dealloc
+{
+    DBG_PRINT("NewtWindow::dealloc.0: %p (refcnt %d)\n", self, (int)[self retainCount]);
+#ifdef DBG_LIFECYCLE
+    NSLog(@"%@",[NSThread callStackSymbols]);
+#endif
+
+    /**
+    NewtUIView* mView = (NewtUIView *)self; // TODO [self contentView];
+    if( NULL != mView ) {
+        [mView release];
+    }
+    */
+    [super dealloc];
+    DBG_PRINT("NewtWindow::dealloc.X: %p\n", self);
+}
+
+- (void) setRealized: (BOOL)v
+{
+    realized = v;
+}
+
+- (BOOL) isRealized
+{
+    return realized;
+}
+
+- (void) setAlwaysOn: (BOOL)top bottom:(BOOL)bottom
+{
+    /**
+    if( top ) {
+        DBG_PRINT( "*************** setAlwaysOn -> top\n");
+        [self setLevel: kCGMaximumWindowLevel];
+    } else if ( bottom ) {
+        DBG_PRINT( "*************** setAlwaysOn -> bottom\n");
+        [self setLevel: kCGDesktopIconWindowLevel]; // w/ input
+    } else {
+        DBG_PRINT( "*************** setAlwaysOn -> normal\n");
+        [self setLevel:NSNormalWindowLevel];
+    } */
+}
+
+- (void) updateInsets: (JNIEnv*) env jwin: (jobject) javaWin
+{
+    /**
+    CGRect frameRect = [self frame];
+    CGRect contentRect = [self contentRectForFrameRect: frameRect];
+
+    // note: this is a simplistic implementation which doesn't take
+    // into account DPI and scaling factor
+    CGFloat l = contentRect.origin.x - frameRect.origin.x;
+    cachedInsets[0] = (int)l;                                                     // l
+    cachedInsets[1] = (int)(frameRect.size.width - (contentRect.size.width + l)); // r
+    cachedInsets[2] = (jint)(frameRect.size.height - contentRect.size.height);    // t
+    cachedInsets[3] = (jint)(contentRect.origin.y - frameRect.origin.y);          // b
+    */
+    UIEdgeInsets uiInsets = [self safeAreaInsets];
+    cachedInsets[0] = uiInsets.left;
+    cachedInsets[1] = uiInsets.right;
+    cachedInsets[2] = uiInsets.top;
+    cachedInsets[3] = uiInsets.bottom;
+    DBG_PRINT( "updateInsets: [ l %d, r %d, t %d, b %d ]\n", cachedInsets[0], cachedInsets[1], cachedInsets[2], cachedInsets[3]);
+
+    if( NULL != env && NULL != javaWin ) {
+        (*env)->CallVoidMethod(env, javaWin, insetsChangedID, JNI_FALSE, cachedInsets[0], cachedInsets[1], cachedInsets[2], cachedInsets[3]);
+    }
+}
+
+- (void) updateSizePosInsets: (JNIEnv*) env jwin: (jobject) javaWin defer: (jboolean)defer
+{
+    // update insets on every window resize for lack of better hook place
+    [self updateInsets: NULL jwin:NULL];
+
+    CGRect frameRect = [self frame];
+
+    UIScreen* screen = [self screen];
+    CGPoint pS = [self convertPoint: frameRect.origin toCoordinateSpace: screen.fixedCoordinateSpace];
+
+    DBG_PRINT( "updateSize: [ w %d, h %d ], liveResize %d\n", (jint) frameRect.size.width, (jint) frameRect.size.height, (jint)withinLiveResize);
+    DBG_PRINT( "updatePos: [ x %d, y %d ]\n", (jint) pS.x, (jint) pS.y);
+
+    if( NULL != env && NULL != javaWin ) {
+        (*env)->CallVoidMethod(env, javaWin, sizeScreenPosInsetsChangedID, defer,
+                               (jint) pS.x, (jint) pS.y,
+                               (jint) frameRect.size.width, (jint) frameRect.size.height,
+                               cachedInsets[0], cachedInsets[1], cachedInsets[2], cachedInsets[3],
+                               JNI_FALSE, // force
+                               withinLiveResize
+                              );
+    }
+}
+
+
+- (void) attachToParent: (UIWindow*) parent
+{
+    /** TODO 
+    DBG_PRINT( "attachToParent.1\n");
+    [parent addChildWindow: self ordered: UIWindowAbove];
+    DBG_PRINT( "attachToParent.2\n");
+    [self setParentWindow: parent];
+    DBG_PRINT( "attachToParent.X\n");
+    */
+}
+
+- (void) detachFromParent: (UIWindow*) parent
+{
+    /** TODO 
+    DBG_PRINT( "detachFromParent.1\n");
+    [self setParentWindow: nil];
+    if(NULL != parent) {
+        DBG_PRINT( "detachFromParent.2\n");
+        [parent removeChildWindow: self];
+    }
+    DBG_PRINT( "detachFromParent.X\n");
+    */
+}
+
+/**
+ * p rel client window position w/ top-left origin
+ * returns: abs screen position w/ bottom-left origin
+ */
+- (CGPoint) newtRelClientTLWinPos2AbsTLScreenPos: (CGPoint) p
+{
+    return [self getLocationOnScreen: p];
+}
+
+- (CGSize) newtClientSize2TLSize: (CGSize) nsz
+{
+    CGSize topSZ = { nsz.width, nsz.height + cachedInsets[2] + cachedInsets[3] }; // height + insets.top + insets.bottom
+    return topSZ;
+}
+
+/**
+ * p rel client window position w/ top-left origin
+ * returns: location in 0/0 top-left space.
+ */
+- (CGPoint) getLocationOnScreen: (CGPoint) p
+{
+    UIScreen* screen = [self screen];
+    CGPoint pS = [self convertPoint: p toCoordinateSpace: screen.fixedCoordinateSpace];
+
+#ifdef VERBOSE_ON
+    CGRect winFrame = [self frame];
+    DBG_PRINT( "getLocationOnScreen: point-in[%d/%d], winFrame[%d/%d %dx%d] -> %d/%d\n",
+        (int)p.x, (int)p.y,
+        (int)winFrame.origin.x, (int)winFrame.origin.y, (int)winFrame.size.width, (int)winFrame.size.height,
+        (int)pS.x, (int)pS.y);
+#endif
+
+    return pS;
+}
+
+- (void) focusChanged: (BOOL) gained
+{
+    DBG_PRINT( "focusChanged: gained %d\n", gained);
+    NewtUIView* newtView = (NewtUIView *) self; // TODO [self contentView];
+    jobject javaWindowObject = [newtView getJavaWindowObject];
+    if (javaWindowObject == NULL) {
+        DBG_PRINT("focusChanged: null javaWindowObject\n");
+        return;
+    }
+    int shallBeDetached = 0;
+    JNIEnv* env = NewtCommon_GetJNIEnv(1 /* asDaemon */, &shallBeDetached);
+    if(NULL==env) {
+        DBG_PRINT("focusChanged: null JNIEnv\n");
+        return;
+    }
+
+    (*env)->CallVoidMethod(env, javaWindowObject, focusChangedID, JNI_FALSE, (gained == YES) ? JNI_TRUE : JNI_FALSE);
+
+    // detaching thread not required - daemon
+    // NewtCommon_ReleaseJNIEnv(shallBeDetached);
+}
+
+- (void) flagsChanged:(UIEvent *) theEvent
+{
+    NSUInteger mods = [theEvent modifierFlags];
+    NewtUIView* newtView = (NewtUIView *) [self contentView];
+    if( [newtView isKindOfClass:[NewtUIView class]] ) {
+        [newtView handleFlagsChanged: mods];
+    }
+}
+
+- (BOOL) acceptsMouseMovedEvents
+{
+    return YES;
+}
+
+- (BOOL) acceptsFirstResponder 
+{
+    return YES;
+}
+
+- (BOOL) becomeFirstResponder
+{
+    DBG_PRINT( "*************** Win.becomeFirstResponder\n");
+    return [super becomeFirstResponder];
+}
+
+- (BOOL) resignFirstResponder
+{
+    DBG_PRINT( "*************** Win.resignFirstResponder\n");
+    return [super resignFirstResponder];
+}
+
+- (BOOL) canBecomeKeyWindow
+{
+    // Even if the window is borderless, we still want it to be able
+    // to become the key window to receive keyboard events
+    return YES;
+}
+
+- (void) becomeKeyWindow
+{
+    DBG_PRINT( "*************** becomeKeyWindow\n");
+    [super becomeKeyWindow];
+}
+
+- (void) resignKeyWindow
+{
+    DBG_PRINT( "*************** resignKeyWindow: isFullscreen %d\n", (int)isFullscreenWindow);
+    if(!isFullscreenWindow) {
+        [super resignKeyWindow];
+    }
+}
+
+- (void) windowDidResignKey: (NSNotification *) notification
+{
+    DBG_PRINT( "*************** windowDidResignKey\n");
+    // Implicit mouse exit by OS X
+    [self focusChanged: NO];
+}
+
+- (void) windowWillStartLiveResize: (NSNotification *) notification
+{
+    DBG_PRINT( "*************** windowWillStartLiveResize\n");
+    withinLiveResize = JNI_TRUE;
+}
+- (void) windowDidEndLiveResize: (NSNotification *) notification
+{
+    DBG_PRINT( "*************** windowDidEndLiveResize\n");
+    withinLiveResize = JNI_FALSE;
+    [self sendResizeEvent];
+}
+- (CGSize) windowWillResize: (UIWindow *)sender toSize:(CGSize)frameSize
+{
+    DBG_PRINT( "*************** windowWillResize %lfx%lf\n", frameSize.width, frameSize.height);
+    return frameSize;
+}
+- (void)windowDidResize: (NSNotification*) notification
+{
+    DBG_PRINT( "*************** windowDidResize\n");
+    [self sendResizeEvent];
+}
+
+- (void) sendResizeEvent
+{
+    jobject javaWindowObject = NULL;
+    int shallBeDetached = 0;
+    JNIEnv* env = NewtCommon_GetJNIEnv(1 /* asDaemon */, &shallBeDetached);
+
+    if( NULL == env ) {
+        DBG_PRINT("windowDidResize: null JNIEnv\n");
+        return;
+    }
+    NewtUIView* newtView = (NewtUIView *) [self contentView];
+    if( [newtView isKindOfClass:[NewtUIView class]] ) {
+        javaWindowObject = [newtView getJavaWindowObject];
+    }
+    if( NULL != javaWindowObject ) {
+        [self updateSizePosInsets: env jwin: javaWindowObject defer:JNI_TRUE];
+    }
+    // detaching thread not required - daemon
+    // NewtCommon_ReleaseJNIEnv(shallBeDetached);
+}
+
+- (void)windowDidMove: (NSNotification*) notification
+{
+    NewtUIView* newtView = (NewtUIView *) [self contentView];
+    if( ! [newtView isKindOfClass:[NewtUIView class]] ) {
+        return;
+    }
+    jobject javaWindowObject = [newtView getJavaWindowObject];
+    if (javaWindowObject == NULL) {
+        DBG_PRINT("windowDidMove: null javaWindowObject\n");
+        return;
+    }
+    int shallBeDetached = 0;
+    JNIEnv* env = NewtCommon_GetJNIEnv(1 /* asDaemon */, &shallBeDetached);
+    if(NULL==env) {
+        DBG_PRINT("windowDidMove: null JNIEnv\n");
+        return;
+    }
+
+    CGPoint p0 = { 0, 0 };
+    p0 = [self getLocationOnScreen: p0];
+    DBG_PRINT( "windowDidMove: [ x %d, y %d ]\n", (jint) p0.x, (jint) p0.y);
+    (*env)->CallVoidMethod(env, javaWindowObject, screenPositionChangedID, JNI_TRUE, (jint) p0.x, (jint) p0.y);
+
+    // detaching thread not required - daemon
+    // NewtCommon_ReleaseJNIEnv(shallBeDetached);
+}
+
+- (BOOL)windowShouldClose: (id) sender
+{
+    return [self windowClosingImpl: NO];
+}
+
+- (void)windowWillClose: (NSNotification*) notification
+{
+    [self windowClosingImpl: YES];
+}
+
+- (BOOL) windowClosingImpl: (BOOL) force
+{
+    jboolean closed = JNI_FALSE;
+
+    NewtUIView* newtView = (NewtUIView *) [self contentView];
+    if( ! [newtView isKindOfClass:[NewtUIView class]] ) {
+        return NO;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    [newtView cursorHide: NO enter: -1];
+
+    if( false == [newtView getDestroyNotifySent] ) {
+        jobject javaWindowObject = [newtView getJavaWindowObject];
+        DBG_PRINT( "*************** windowWillClose.0: %p\n", (void *)(intptr_t)javaWindowObject);
+        if (javaWindowObject == NULL) {
+            DBG_PRINT("windowWillClose: null javaWindowObject\n");
+            [pool release];
+            return NO;
+        }
+        int shallBeDetached = 0;
+        JNIEnv* env = NewtCommon_GetJNIEnv(1 /* asDaemon */, &shallBeDetached);
+        if(NULL==env) {
+            DBG_PRINT("windowWillClose: null JNIEnv\n");
+            [pool release];
+            return NO;
+        }
+        [newtView setDestroyNotifySent: true]; // earmark assumption of being closed
+        closed = (*env)->CallBooleanMethod(env, javaWindowObject, windowDestroyNotifyID, force ? JNI_TRUE : JNI_FALSE);
+        if(!force && !closed) {
+            // not closed on java side, not force -> clear flag
+            [newtView setDestroyNotifySent: false];
+        }
+
+        // detaching thread not required - daemon
+        // NewtCommon_ReleaseJNIEnv(shallBeDetached);
+        DBG_PRINT( "*************** windowWillClose.X: %p, closed %d\n", (void *)(intptr_t)javaWindowObject, (int)closed);
+    } else {
+        DBG_PRINT( "*************** windowWillClose (skip)\n");
+    }
+    [pool release];
+    return JNI_TRUE == closed ? YES : NO ;
+}
+
+@end
+
diff --git a/src/newt/native/IOSUIWindow.m b/src/newt/native/IOSUIWindow.m
new file mode 100644
index 000000000..780c2344f
--- /dev/null
+++ b/src/newt/native/IOSUIWindow.m
@@ -0,0 +1,1161 @@
+/**
+ * Copyright 2019 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+#import <inttypes.h>
+
+#import "jogamp_newt_driver_ios_WindowDriver.h"
+#import "IOSNewtUIWindow.h"
+
+#import "MouseEvent.h"
+#import "KeyEvent.h"
+#import "ScreenMode.h"
+
+#import <stdio.h>
+
+#ifdef DBG_PERF
+    #include "timespec.h"
+#endif
+
+static const char * const ClazzNamePoint = "com/jogamp/nativewindow/util/Point";
+static const char * const ClazzAnyCstrName = "<init>";
+static const char * const ClazzNamePointCstrSignature = "(II)V";
+static jclass pointClz = NULL;
+static jmethodID pointCstr = NULL;
+
+static NSString* jstringToNSString(JNIEnv* env, jstring jstr)
+{
+    const jchar* jstrChars = (*env)->GetStringChars(env, jstr, NULL);
+    NSString* str = [[NSString alloc] initWithCharacters: jstrChars length: (*env)->GetStringLength(env, jstr)];
+    (*env)->ReleaseStringChars(env, jstr, jstrChars);
+    return str;
+}
+
+static void setWindowClientTopLeftPoint(NewtUIWindow* mWin, jint x, jint y, BOOL doDisplay) {
+    DBG_PRINT( "setWindowClientTopLeftPoint.0 - window: %p %d/%d, display %d\n", mWin, (int)x, (int)y, (int)doDisplay);
+    CGPoint pS = CGPointMake(x, y);
+    CGRect rect = [mWin frame];
+    rect.origin = pS;
+
+    [mWin setFrame: rect];
+    DBG_PRINT( "setWindowClientTopLeftPoint.X: %d/%d\n", (int)pS.x, (int)pS.y);
+
+    if( doDisplay ) {
+        // TODO UIView* mView = [mWin contentView];
+        // TODO [mWin invalidateCursorRectsForView: mView];
+    }
+}
+
+static void setWindowClientTopLeftPointAndSize(NewtUIWindow* mWin, jint x, jint y, jint width, jint height, BOOL doDisplay) {
+    DBG_PRINT( "setWindowClientTopLeftPointAndSize.0 - window: %p %d/%d %dx%d, display %d\n", mWin, (int)x, (int)y, (int)width, (int)height, (int)doDisplay);
+    CGRect rect = CGRectMake(x, y, width, height);
+    DBG_PRINT( "setWindowClientTopLeftPointAndSize.1: %d/%d %dx%d\n", (int)rect.origin.x, (int)rect.origin.y, (int)rect.size.width, (int)rect.size.height);
+
+    // TODO [mWin setFrame: rect display:doDisplay];
+    [mWin setFrame: rect];
+    DBG_PRINT( "setWindowClientTopLeftPointAndSize.X: %d/%d %dx%d\n", (int)rect.origin.x, (int)rect.origin.y, (int)rect.size.width, (int)rect.size.height);
+
+    // -> display:YES
+    // if( doDisplay ) {
+    //   UIView* mView = [mWin contentView];
+    //   [mWin invalidateCursorRectsForView: mView];
+    // }
+}
+
+#ifdef VERBOSE_ON
+static int getRetainCount(NSObject * obj) {
+    return ( NULL == obj ) ? -1 : (int)([obj retainCount]) ;
+}
+#endif
+
+static void setJavaWindowObject(JNIEnv *env, jobject newJavaWindowObject, NewtUIView *view, BOOL enable) {
+    DBG_PRINT( "setJavaWindowObject.0: View %p\n", view);
+    if( !enable) {
+        jobject globJavaWindowObject = [view getJavaWindowObject];
+        if( NULL != globJavaWindowObject ) {
+            DBG_PRINT( "setJavaWindowObject.1: View %p - Clear old javaWindowObject %p\n", view, globJavaWindowObject);
+            (*env)->DeleteGlobalRef(env, globJavaWindowObject);
+            [view setJavaWindowObject: NULL];
+        }
+    } else if( NULL != newJavaWindowObject ) {
+        DBG_PRINT( "setJavaWindowObject.2: View %p - Set new javaWindowObject %p\n", view, newJavaWindowObject);
+        jobject globJavaWindowObject = (*env)->NewGlobalRef(env, newJavaWindowObject);
+        [view setJavaWindowObject: globJavaWindowObject];
+    }
+    DBG_PRINT( "setJavaWindowObject.X: View %p\n", view);
+}
+
+static void changeContentView(JNIEnv *env, jobject javaWindowObject, UIView *pview, NewtUIWindow *win, NewtUIView *newView, BOOL setJavaWindow) {
+    UIView* oldUIView = NULL; // TODO [win contentView];
+    NewtUIView* oldNewtUIView = NULL;
+#ifdef VERBOSE_ON
+    int dbgIdx = 1;
+#endif
+
+    if( [oldUIView isKindOfClass:[NewtUIView class]] ) {
+        oldNewtUIView = (NewtUIView *) oldUIView;
+    }
+
+    DBG_PRINT( "changeContentView.%d win %p, view (%p,%d (%d) -> %p,%d), parent view %p\n", 
+        dbgIdx++, win, oldUIView, getRetainCount(oldUIView), NULL!=oldNewtUIView, newView, getRetainCount(newView), pview);
+
+    if( NULL!=oldUIView ) {
+NS_DURING
+        // Available >= 10.5 - Makes the menubar disapear
+        BOOL iifs = NO; // TODO [oldUIView isInFullScreenMode];
+        if( iifs ) {
+            // TODO [oldUIView exitFullScreenModeWithOptions: NULL];
+        }
+NS_HANDLER
+NS_ENDHANDLER
+        DBG_PRINT( "changeContentView.%d win %p, view (%p,%d (%d) -> %p,%d)\n", 
+            dbgIdx++, win, oldUIView, getRetainCount(oldUIView), NULL!=oldNewtUIView, newView, getRetainCount(newView));
+
+        if( NULL != oldNewtUIView ) {
+            [oldNewtUIView setDestroyNotifySent: false];
+            setJavaWindowObject(env, NULL, oldNewtUIView, NO);
+        }
+        // TODO [oldUIView removeFromSuperviewWithoutNeedingDisplay];
+    }
+    DBG_PRINT( "changeContentView.%d win %p, view (%p,%d -> %p,%d), isHidden %d, isHiddenOrHasHiddenAncestor: %d\n", 
+        dbgIdx++, win, oldUIView, getRetainCount(oldUIView), newView, getRetainCount(newView), [newView isHidden], [newView isHiddenOrHasHiddenAncestor]);
+
+    if( NULL!=newView ) {
+        [newView setDestroyNotifySent: false];
+        if( setJavaWindow ) {
+            setJavaWindowObject(env, javaWindowObject, newView, YES);
+        }
+
+        DBG_PRINT( "changeContentView.%d win %p, view (%p,%d -> %p,%d)\n", 
+            dbgIdx++, win, oldUIView, getRetainCount(oldUIView), newView, getRetainCount(newView));
+
+        if(NULL!=pview) {
+            // TODO [pview addSubview: newView positioned: UIWindowAbove relativeTo: nil];
+        }
+    }
+    DBG_PRINT( "changeContentView.%d win %p, view (%p,%d -> %p,%d), isHidden %d, isHiddenOrHasHiddenAncestor: %d\n", 
+        dbgIdx++, win, oldUIView, getRetainCount(oldUIView), newView, getRetainCount(newView), [newView isHidden], [newView isHiddenOrHasHiddenAncestor]);
+
+    // TODO [win setContentView: newView];
+
+    DBG_PRINT( "changeContentView.%d win %p, view (%p,%d -> %p,%d), isHidden %d, isHiddenOrHasHiddenAncestor: %d\n", 
+        dbgIdx++, win, oldUIView, getRetainCount(oldUIView), newView, getRetainCount(newView), [newView isHidden], [newView isHiddenOrHasHiddenAncestor]);
+
+    // make sure the insets are updated in the java object
+    [win updateInsets: env jwin:javaWindowObject];
+
+    DBG_PRINT( "changeContentView.X win %p, view (%p,%d -> %p,%d)\n", 
+        win, oldUIView, getRetainCount(oldUIView), newView, getRetainCount(newView));
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_DisplayDriver
+ * Method:    initIDs
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_ios_DisplayDriver_initUIApplication0
+  (JNIEnv *env, jclass clazz)
+{
+    static int initialized = 0;
+
+    if(initialized) return JNI_TRUE;
+    initialized = 1;
+
+    NewtCommon_init(env);
+
+    // Initialize the shared NSApplication instance
+    [UIApplication sharedApplication];
+
+    // Need this when debugging, as it is necessary to attach gdb to
+    // the running java process -- "gdb java" doesn't work
+    //    printf("Going to sleep for 10 seconds\n");
+    //    sleep(10);
+
+    return (jboolean) JNI_TRUE;
+}
+
+static void NewtScreen_dump() {
+#ifdef VERBOSE_ON
+    NSArray *screens = [UIScreen screens];
+    int i;
+    for(i=0; i<[screens count]; i++) {
+        UIScreen * screen = (UIScreen *) [screens objectAtIndex: i];
+        CGRect screenFrame = [screen frame];
+        CGRect screenVisibleFrame = [screen visibleFrame];
+        CGFloat pixelScale = 1.0; // default
+        pixelScale = [screen scale]; // HiDPI scaling
+        UIWindowDepth depth = [screen depth]; // an (int) value!
+        DBG_PRINT( "UIScreen #%d (%p): Frame %lf/%lf %lfx%lf (vis %lf/%lf %lfx%lf), scale %lf, depth %d\n",
+            i, screen,
+            screenFrame.origin.x, screenFrame.origin.y, screenFrame.size.width, screenFrame.size.height,
+            screenVisibleFrame.origin.x, screenVisibleFrame.origin.y, screenVisibleFrame.size.width, screenVisibleFrame.size.height,
+            pixelScale, depth);
+    }
+#endif
+}
+
+// Duplicate each Mode by all possible rotations (4):
+// For each real-mode: [mode, 0], [mode, 90], [mode, 180], [mode, 270]
+#define ROTMODES_PER_REALMODE 1
+
+/*
+ * Class:     jogamp_newt_driver_ios_ScreenDriver
+ * Method:    getMonitorDeviceIds0
+ * Signature: ()I
+ */
+JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_ios_ScreenDriver_getMonitorDeviceIds0
+  (JNIEnv *env, jobject obj)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    NSArray *screens = [UIScreen screens];
+    int count = [screens count];
+    int32_t displayIDs[count];
+    int i;
+    for(i=0; i<count; i++) {
+        // UIScreen * screen = (UIScreen *) [screens objectAtIndex: i];
+        displayIDs[i] = i; // TODO no unique screen name?
+    }
+    jintArray properties = (*env)->NewIntArray(env, count);
+    if (properties == NULL) {
+        NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", count);
+    }
+    (*env)->SetIntArrayRegion(env, properties, 0, count, displayIDs);
+    [pool release];
+    return properties;
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_ScreenDriver
+ * Method:    getMonitorProps0
+ * Signature: (I)[I
+ */
+JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_ios_ScreenDriver_getMonitorProps0
+  (JNIEnv *env, jobject obj, jint crt_id)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+#ifdef DBG_PERF
+    struct timespec t0, t1, td;
+    long td_ms;
+    timespec_now(&t0);
+#endif
+
+#ifdef DBG_PERF
+    timespec_now(&t1); timespec_subtract(&td, &t1, &t0); td_ms = timespec_milliseconds(&td);
+    fprintf(stderr, "MacScreen_getMonitorProps0.1: %ld ms\n", td_ms); fflush(NULL);
+#endif
+    NSArray *screens = [UIScreen screens];
+    int count = [screens count];
+    UIScreen * screen = (UIScreen *) [screens objectAtIndex: crt_id];
+    if( NULL == screen ) {
+        [pool release];
+        return NULL;
+    }
+    BOOL isPrimary = 0 == crt_id;
+#ifdef DBG_PERF
+    timespec_now(&t1); timespec_subtract(&td, &t1, &t0); td_ms = timespec_milliseconds(&td);
+    fprintf(stderr, "MacScreen_getMonitorProps0.2: %ld ms\n", td_ms); fflush(NULL);
+#endif
+
+    UIScreenMode * screenMode = [screen currentMode];
+    CGSize sizeMM = CGSizeMake(161.0, 228.0); // TODO ???
+#ifdef DBG_PERF
+    timespec_now(&t1); timespec_subtract(&td, &t1, &t0); td_ms = timespec_milliseconds(&td);
+    fprintf(stderr, "MacScreen_getMonitorProps0.3: %ld ms\n", td_ms); fflush(NULL);
+#endif
+
+    CGRect dBounds = [screen bounds];
+#ifdef VERBOSE_ON
+    DBG_PRINT( "getMonitorProps0: crt_id 0x%X (prim %d), top-left displayBounds[%d/%d %dx%d]\n", 
+                 (int)crt_id, isPrimary,
+                 (int)dBounds.origin.x, (int)dBounds.origin.y, (int)dBounds.size.width, (int)dBounds.size.height);
+#endif
+
+    jsize propCount = MIN_MONITOR_DEVICE_PROPERTIES - 1 - NUM_MONITOR_MODE_PROPERTIES;
+    jint prop[ propCount ];
+    int offset = 0;
+    prop[offset++] = propCount;
+    prop[offset++] = crt_id;
+    prop[offset++] = 0; // isClone
+    prop[offset++] = isPrimary ? 1 : 0; // isPrimary
+    prop[offset++] = (jint) sizeMM.width;
+    prop[offset++] = (jint) sizeMM.height;
+    prop[offset++] = (jint) dBounds.origin.x;    // rotated viewport x      (pixel units, will be fixed in java code)
+    prop[offset++] = (jint) dBounds.origin.y;    // rotated viewport y      (pixel units, will be fixed in java code)
+    prop[offset++] = (jint) dBounds.size.width;  // rotated viewport width  (pixel units, will be fixed in java code)
+    prop[offset++] = (jint) dBounds.size.height; // rotated viewport height (pixel units, will be fixed in java code)
+    prop[offset++] = (jint) dBounds.origin.x;    // rotated viewport x      (window units, will be fixed in java code)
+    prop[offset++] = (jint) dBounds.origin.y;    // rotated viewport y      (window units, will be fixed in java code)
+    prop[offset++] = (jint) dBounds.size.width;  // rotated viewport width  (window units, will be fixed in java code)
+    prop[offset++] = (jint) dBounds.size.height; // rotated viewport height (window units, will be fixed in java code)
+
+    jintArray properties = (*env)->NewIntArray(env, propCount);
+    if (properties == NULL) {
+        NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", propCount);
+    }
+    (*env)->SetIntArrayRegion(env, properties, 0, propCount, prop);
+    
+    [pool release];
+
+    return properties;
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_ScreenDriver
+ * Method:    getMonitorMode0
+ * Signature: (II)[I
+ */
+JNIEXPORT jintArray JNICALL Java_jogamp_newt_driver_ios_ScreenDriver_getMonitorMode0
+  (JNIEnv *env, jobject obj, jint crt_id, jint mode_idx)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+    NSArray<UIScreen*> *screens = [UIScreen screens];
+    int count = [screens count];
+    UIScreen * screen = (UIScreen *) [screens objectAtIndex: crt_id];
+    if( NULL == screen ) {
+        [pool release];
+        return NULL;
+    }
+    CGFloat pixelScale = 1.0; // default
+NS_DURING
+    // Available >= 10.7
+    pixelScale = [screen scale]; // HiDPI scaling
+NS_HANDLER
+NS_ENDHANDLER
+
+    NSArray<UIScreenMode*> *availableModes = [screen availableModes];
+    int numberOfAvailableModes = [availableModes count];
+    CFIndex numberOfAvailableModesRots = ROTMODES_PER_REALMODE * numberOfAvailableModes; 
+    int currentCCWRot = 0;
+    jint ccwRot = 0;
+    int nativeId = 0;
+    UIScreenMode * mode = NULL;
+
+#ifdef VERBOSE_ON
+    if(0 >= mode_idx) {
+        // only for current mode (-1) and first mode (scanning)
+        DBG_PRINT( "getScreenMode0: crtID 0x%X (s %p, pscale %lf), mode %d, avail: %d/%d, current rot %d ccw\n",  
+            (uint32_t)displayID, screen, pixelScale, (int)mode_idx, (int)numberOfAvailableModes, (int)numberOfAvailableModesRots, currentCCWRot);
+    }
+#endif
+
+    if(numberOfAvailableModesRots<=mode_idx) {
+        // n/a - end of modes
+        DBG_PRINT( "getScreenMode0: end of modes: mode %d, avail: %d/%d\n",
+            (int)mode_idx, (int)numberOfAvailableModes, (int)numberOfAvailableModesRots);
+        [pool release];
+        return NULL;
+    } else if(-1 < mode_idx) {
+        // only at initialization time, where index >= 0
+        nativeId = mode_idx / ROTMODES_PER_REALMODE;
+        ccwRot = mode_idx % ROTMODES_PER_REALMODE * 90;
+        mode = (UIScreenMode*) [availableModes objectAtIndex: nativeId];
+    } else {
+        // current mode
+        mode = [screen currentMode];
+        ccwRot = 0;
+        nativeId = 0;
+    }
+    // mode = CGDisplayModeRetain(mode); // 10.6 on CGDisplayModeRef
+
+    CGSize mSize = [mode size];
+    int mWidth = (int)mSize.width;
+    int mHeight = (int)mSize.height;
+    if( -1 == mode_idx ) {
+        mWidth *= (int)pixelScale;   // accomodate HiDPI
+        mHeight *= (int)pixelScale; // accomodate HiDPI
+    }
+
+    // swap width and height, since OSX reflects rotated dimension, we don't
+    if ( 90 == currentCCWRot || 270 == currentCCWRot ) {
+        int tempWidth = mWidth;
+        mWidth = mHeight;
+        mHeight = tempWidth;
+    }
+
+    jint prop[ NUM_MONITOR_MODE_PROPERTIES_ALL ];
+    int propIndex = 0;
+
+    int refreshRate = 60; // TODO
+    int fRefreshRate = ( 0 < refreshRate ) ? refreshRate : 60; // default .. (experienced on OSX 10.6.8)
+    prop[propIndex++] = NUM_MONITOR_MODE_PROPERTIES_ALL;
+    prop[propIndex++] = mWidth;
+    prop[propIndex++] = mHeight;
+    prop[propIndex++] = 32; // TODO CGDDGetModeBitsPerPixel(mode);
+    prop[propIndex++] = fRefreshRate * 100; // Hz*100
+    prop[propIndex++] = 0; // flags
+    prop[propIndex++] = nativeId;
+    prop[propIndex++] = ccwRot;
+ 
+    DBG_PRINT( "getScreenMode0: Mode %d/%d (%d): %dx%d, %d bpp, %d / %d Hz, nativeId %d, rot %d ccw\n",
+        (int)mode_idx, (int)numberOfAvailableModesRots, (int)numberOfAvailableModes, 
+        (int)prop[1], (int)prop[2], (int)prop[3],
+        (int)prop[4], refreshRate, (int)prop[6], (int)prop[7]);
+
+    jintArray properties = (*env)->NewIntArray(env, NUM_MONITOR_MODE_PROPERTIES_ALL);
+    if (properties == NULL) {
+        NewtCommon_throwNewRuntimeException(env, "Could not allocate int array of size %d", NUM_MONITOR_MODE_PROPERTIES_ALL);
+    }
+    (*env)->SetIntArrayRegion(env, properties, 0, NUM_MONITOR_MODE_PROPERTIES_ALL, prop);
+    
+    // CGDisplayModeRelease(mode); // 10.6 on CGDisplayModeRef
+    [pool release];
+
+    return properties;
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_ScreenDriver
+ * Method:    setMonitorMode0
+ * Signature: (III)Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_ios_ScreenDriver_setMonitorMode0
+  (JNIEnv *env, jobject object, jint crt_id, jint nativeId, jint ccwRot)
+{
+    return false;
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    initIDs
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_ios_WindowDriver_initIDs0
+  (JNIEnv *env, jclass clazz)
+{
+    static int initialized = 0;
+
+    if(initialized) return JNI_TRUE;
+    initialized = 1;
+
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+    NewtScreen_dump();
+
+    jclass c;
+    c = (*env)->FindClass(env, ClazzNamePoint);
+    if(NULL==c) {
+        NewtCommon_FatalError(env, "FatalError Java_jogamp_newt_driver_ios_WindowDriver_initIDs0: can't find %s", ClazzNamePoint);
+    }
+    pointClz = (jclass)(*env)->NewGlobalRef(env, c);
+    (*env)->DeleteLocalRef(env, c);
+    if(NULL==pointClz) {
+        NewtCommon_FatalError(env, "FatalError Java_jogamp_newt_driver_ios_WindowDriver_initIDs0: can't use %s", ClazzNamePoint);
+    }
+    pointCstr = (*env)->GetMethodID(env, pointClz, ClazzAnyCstrName, ClazzNamePointCstrSignature);
+    if(NULL==pointCstr) {
+        NewtCommon_FatalError(env, "FatalError Java_jogamp_newt_driver_ios_WindowDriver_initIDs0: can't fetch %s.%s %s",
+            ClazzNamePoint, ClazzAnyCstrName, ClazzNamePointCstrSignature);
+    }
+
+    // Need this when debugging, as it is necessary to attach gdb to
+    // the running java process -- "gdb java" doesn't work
+    //    printf("Going to sleep for 10 seconds\n");
+    //    sleep(10);
+
+    BOOL res =  [NewtUIWindow initNatives: env forClass: clazz];
+    [pool release];
+
+    return (jboolean) res;
+}
+
+/**
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    createView0
+ * Signature: (IIII)J
+ */
+JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_ios_WindowDriver_createView0
+  (JNIEnv *env, jobject jthis, jint x, jint y, jint w, jint h)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+    DBG_PRINT( "createView0 - %p (this), %d/%d %dx%d (START)\n",
+        (void*)(intptr_t)jthis, (int)x, (int)y, (int)w, (int)h);
+
+    CGRect rectView = CGRectMake(0, 0, w, h);
+    NewtUIView *myView = [[NewtUIView alloc] initWithFrame: rectView] ;
+    DBG_PRINT( "createView0.X - new view: %p\n", myView);
+
+    [pool release];
+
+    return (jlong) (intptr_t) myView;
+}
+
+/**
+ * Method creates a deferred un-initialized Window, hence no special invocation required inside method.
+ *
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    createWindow0
+ * Signature: (IIIIZIIJ)J
+ */
+JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_ios_WindowDriver_createWindow0
+  (JNIEnv *env, jobject jthis, jint x, jint y, jint w, jint h,
+   jboolean fullscreen, jint styleMask, jint bufferingType, jlong jview)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    NewtUIView* myView = (NewtUIView*) (intptr_t) jview ;
+
+    DBG_PRINT( "createWindow0 - %p (this), %d/%d %dx%d, fs %d, style %X, buffType %X, view %p (START)\n",
+        (void*)(intptr_t)jthis, (int)x, (int)y, (int)w, (int)h, (int)fullscreen, 
+        (int)styleMask, (int)bufferingType, myView);
+    (void)myView;
+
+    if (fullscreen) {
+        // TODO styleMask = NSBorderlessWindowMask;
+    }
+    CGRect rectWin = CGRectMake(x, y, w, h);
+
+    // Allocate the window
+    NewtUIWindow* myWindow = [[NewtUIWindow alloc] initWithContentRect: rectWin
+                                               styleMask: (NSUInteger) styleMask
+                                               backing: 0 // TODO (NSBackingStoreType) bufferingType
+                                               defer: YES
+                                               isFullscreenWindow: fullscreen];
+    // DBG_PRINT( "createWindow0.1 - %p, isVisible %d\n", myWindow, [myWindow isVisible]);
+
+    DBG_PRINT( "createWindow0.X - %p, isVisible %d\n", myWindow, [myWindow isVisible]);
+
+    [pool release];
+
+    return (jlong) ((intptr_t) myWindow);
+}
+
+JNIEXPORT jint JNICALL Java_jogamp_newt_driver_ios_WindowDriver_getDisplayID0(JNIEnv *env, jobject jthis, jlong window) {
+    NewtUIWindow* myWindow = (NewtUIWindow*) ((intptr_t) window);
+    if( NULL == myWindow ) {
+        DBG_PRINT( "getDisplayID0 - NULL NEWT win - abort\n");
+        return 0;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    UIScreen *screen =  [myWindow screen];
+    int32_t displayID = 0; // TODO (int32_t)NewtScreen_getCGDirectDisplayIDByUIScreen(screen);
+    [pool release];
+    return (jint) displayID;
+}
+
+/**
+ * Method is called on Main-Thread, hence no special invocation required inside method.
+ *
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    initWindow0
+ * Signature: (JJIIIIFZZZJ)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_initWindow0
+  (JNIEnv *env, jobject jthis, jlong parent, jlong window, jint x, jint y, jint w, jint h, jfloat reqPixelScale,
+   jboolean opaque, jboolean atop, jboolean abottom, jboolean visible, jlong jview)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    NewtUIWindow* myWindow = (NewtUIWindow*) ((intptr_t) window);
+    NewtUIView* myView = (NewtUIView*) (intptr_t) jview ;
+    BOOL fullscreen = myWindow->isFullscreenWindow;
+
+    DBG_PRINT( "initWindow0 - %p (this), %p (parent), %p (window), %d/%d %dx%d, reqPixScale %f, opaque %d, atop %d, abottom %d, fs %d, visible %d, view %p (START)\n",
+        (void*)(intptr_t)jthis, (void*)(intptr_t)parent, myWindow, (int)x, (int)y, (int)w, (int)h, (float)reqPixelScale,
+        (int) opaque, (int)atop, (int)abottom, (int)fullscreen, (int)visible, myView);
+
+    // TODO [myWindow setReleasedWhenClosed: NO]; // We control UIWindow destruction!
+    // TODO [myWindow setPreservesContentDuringLiveResize: NO];
+
+    NSObject* nsParentObj = (NSObject*) ((intptr_t) parent);
+    UIWindow* parentWindow = NULL;
+    UIView* parentView = NULL;
+    if( nsParentObj != NULL && [nsParentObj isKindOfClass:[UIWindow class]] ) {
+        parentWindow = (UIWindow*) nsParentObj;
+        parentView = (UIView*)nsParentObj;
+        DBG_PRINT( "initWindow0 - Parent is UIWindow : %p (win) -> %p (view) \n", parentWindow, parentView);
+    } else if( nsParentObj != NULL && [nsParentObj isKindOfClass:[UIView class]] ) {
+        parentView = (UIView*) nsParentObj;
+        parentWindow = [parentView window];
+        DBG_PRINT( "initWindow0 - Parent is UIView : %p -(view) > %p (win) \n", parentView, parentWindow);
+    } else {
+        DBG_PRINT( "initWindow0 - Parent is neither UIWindow nor UIView : %p\n", nsParentObj);
+    }
+    DBG_PRINT( "initWindow0 - is visible.1: %d\n", [myWindow isVisible]);
+
+    // Remove animations for child windows
+    if(NULL != parentWindow) {
+        [UIView setAnimationsEnabled: NO];
+    }
+
+#ifdef VERBOSE_ON
+    int dbgIdx = 1;
+#endif
+    if(opaque) {
+        [myWindow setOpaque: YES];
+        DBG_PRINT( "initWindow0.%d\n", dbgIdx++);
+        if (!fullscreen) {
+            // TODO [myWindow setShowsResizeIndicator: YES];
+        }
+        DBG_PRINT( "initWindow0.%d\n", dbgIdx++);
+    } else {
+        [myWindow setOpaque: NO];
+        [myWindow setBackgroundColor: [UIColor clearColor]];
+    }
+    [myWindow setAlwaysOn: atop bottom:abottom];
+
+    // specify we want mouse-moved events
+    // TODO [myWindow setAcceptsMouseMovedEvents:YES];
+
+    DBG_PRINT( "initWindow0.%d - %p view %p, isVisible %d\n", 
+        dbgIdx++, myWindow, myView, [myWindow isVisible]);
+
+    // Set the content view
+    changeContentView(env, jthis, parentView, myWindow, myView, NO);
+    // TODO [myWindow setInitialFirstResponder: myView];
+
+    DBG_PRINT( "initWindow0.%d - %p view %p, isVisible %d\n", 
+        dbgIdx++, myWindow, myView, [myWindow isVisible]);
+
+    if(NULL!=parentWindow) {
+        [myWindow attachToParent: parentWindow];
+    }
+
+    DBG_PRINT( "initWindow0.%d - %p view %p, isVisible %d, visible %d\n", 
+        dbgIdx++, myWindow, myView, [myWindow isVisible], visible);
+
+    // Immediately re-position this window based on an upper-left coordinate system
+    setWindowClientTopLeftPointAndSize(myWindow, x, y, w, h, NO);
+
+    DBG_PRINT( "initWindow0.%d - %p view %p, isVisible %d\n", 
+        dbgIdx++, myWindow, myView, [myWindow isVisible]);
+
+    // TODO [myWindow setAllowsConcurrentViewDrawing: YES];
+
+    DBG_PRINT( "initWindow0.%d - %p view %p, isVisible %d\n", 
+        dbgIdx++, myWindow, myView, [myWindow isVisible]);
+
+    // TODO [myView setCanDrawConcurrently: YES];
+
+    DBG_PRINT( "initWindow0.%d - %p view %p, isVisible %d\n", 
+        dbgIdx++, myWindow, myView, [myWindow isVisible]);
+
+    // visible on front
+    if( visible ) {
+        // TODO [myWindow orderFront: myWindow];
+    }
+
+    DBG_PRINT( "initWindow0.%d - %p view %p, isVisible %d\n", 
+        dbgIdx++, myWindow, myView, [myWindow isVisible]);
+
+    // force surface creation
+    // [myView lockFocus];
+    // [myView unlockFocus];
+
+    // Set the next responder to be the window so that we can forward
+    // right mouse button down events
+    // TODO [myView setNextResponder: myWindow];
+
+    DBG_PRINT( "initWindow0.%d - %p (this), %p (parent): new window: %p, view %p\n",
+        dbgIdx++, (void*)(intptr_t)jthis, (void*)(intptr_t)parent, myWindow, myView);
+
+    [myView setDestroyNotifySent: false];
+    setJavaWindowObject(env, jthis, myView, YES);
+
+    DBG_PRINT( "initWindow0.%d - %p (this), %p (parent): new window: %p, view %p\n",
+        dbgIdx++, (void*)(intptr_t)jthis, (void*)(intptr_t)parent, myWindow, myView);
+
+NS_DURING
+    if( fullscreen ) {
+        /** 
+         * See Bug 914: We don't use exclusive fullscreen anymore (capturing display)
+         * allowing ALT-TAB to allow process/app switching!
+         * Shall have no penalty on modern GPU and is also recommended, see bottom box @
+         * <https://developer.apple.com/library/mac/documentation/graphicsimaging/Conceptual/QuartzDisplayServicesConceptual/Articles/DisplayCapture.html>
+         *
+        UIScreen *myScreen =  NewtScreen_getUIScreenByCoord(x, y);
+        if( NULL != myScreen ) {
+            if ( [myView respondsToSelector:@selector(enterFullScreenMode:withOptions:)] ) {
+                // Available >= 10.5 - Makes the menubar disapear
+                [myView enterFullScreenMode: myScreen withOptions:NULL];
+            } 
+        }
+        */
+        if( myWindow->hasPresentationSwitch ) {
+            DBG_PRINT( "initWindow0.%d - %p view %p, setPresentationOptions 0x%X\n", 
+                dbgIdx++, myWindow, myView, (int)myWindow->fullscreenPresentationOptions);
+            // TODO [NSApp setPresentationOptions: myWindow->fullscreenPresentationOptions];
+        }
+    }
+NS_HANDLER
+NS_ENDHANDLER
+
+    DBG_PRINT( "initWindow0.%d - %p (this), %p (parent): new window: %p, view %p\n",
+        dbgIdx++, (void*)(intptr_t)jthis, (void*)(intptr_t)parent, myWindow, myView);
+
+    [pool release];
+    DBG_PRINT( "initWindow0.X - %p (this), %p (parent): new window: %p, view %p\n",
+        (void*)(intptr_t)jthis, (void*)(intptr_t)parent, myWindow, myView);
+}
+
+/**
+ * Method is called on Main-Thread, hence no special invocation required inside method.
+ *
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    setPixelScale0
+ * Signature: (JJF)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_setPixelScale0
+  (JNIEnv *env, jobject jthis, jlong window, jlong view, jfloat reqPixelScale)
+{
+    NewtUIWindow* myWindow = (NewtUIWindow*) ((intptr_t) window);
+    if( NULL == myWindow ) {
+        DBG_PRINT( "setPixelScale0 - NULL NEWT win - abort\n");
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    NewtUIView* myView = (NewtUIView*) (intptr_t) view ;
+#ifdef VERBOSE_ON
+    int dbgIdx = 1;
+#endif
+    DBG_PRINT( "setPixelScale0 - %p (this), %p (window), view %p, reqPixScale %f (START)\n",
+        (void*)(intptr_t)jthis, myWindow, myView, (float)reqPixelScale);
+    (void)myWindow;
+
+    DBG_PRINT( "setPixelScale0.%d - %p (this), window: %p, view %p\n",
+        dbgIdx++, (void*)(intptr_t)jthis, myWindow, myView);
+
+    [pool release];
+    DBG_PRINT( "setPixelScale0.X - %p (this), window: %p, view %p\n",
+        (void*)(intptr_t)jthis, myWindow, myView);
+}
+
+/**
+ * Method is called on Main-Thread, hence no special invocation required inside method.
+ *
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    close0
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_close0
+  (JNIEnv *env, jobject unused, jlong window)
+{
+    NewtUIWindow* mWin = (NewtUIWindow*) ((intptr_t) window);
+    if( NULL == mWin ) {
+        DBG_PRINT( "windowClose.0 - NULL NEWT win - abort\n");
+        return;
+    }
+    BOOL isNSWin = [mWin isKindOfClass:[UIWindow class]];
+    BOOL isNewtWin = [mWin isKindOfClass:[NewtUIWindow class]];
+    UIWindow *pWin = NULL; // TODO [mWin parentWindow];
+    DBG_PRINT( "windowClose.0 - %p [isUIWindow %d, isNewtWin %d], parent %p\n", mWin, isNSWin, isNewtWin, pWin);
+    (void)isNSWin; // silence
+    if( !isNewtWin ) {
+        NewtCommon_throwNewRuntimeException(env, "Not a NewtUIWindow %p", mWin);
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    NewtUIView* mView = (NewtUIView *)mWin; // TODO [mWin contentView];
+    BOOL fullscreen = mWin->isFullscreenWindow;
+    BOOL destroyNotifySent, isUIView, isNewtUIView;
+    if( NULL != mView ) {
+        isUIView = [mView isKindOfClass:[UIView class]];
+        isNewtUIView = [mView isKindOfClass:[NewtUIView class]];
+        destroyNotifySent = isNewtUIView ? [mView getDestroyNotifySent] : false;
+    } else {
+        isUIView = false;
+        isNewtUIView = false;
+        destroyNotifySent = false;
+    }
+
+    DBG_PRINT( "windowClose.0 - %p, destroyNotifySent %d, view %p [isUIView %d, isNewtUIView %d], fullscreen %d, parent %p\n", 
+        mWin, destroyNotifySent, mView, isUIView, isNewtUIView, (int)fullscreen, pWin);
+
+    [mWin setRealized: NO];
+
+    if( isNewtUIView ) {
+        // cleanup view
+        [mView setDestroyNotifySent: true];
+        setJavaWindowObject(env, NULL, mView, NO);
+    }
+
+NS_DURING
+    /** 
+     * See Bug 914: We don't use exclusive fullscreen anymore (capturing display)
+     * See initWindow0(..) above ..
+    if(NULL!=mView) {
+        BOOL iifs;
+        if ( [mView respondsToSelector:@selector(isInFullScreenMode)] ) {
+            iifs = [mView isInFullScreenMode];
+        } else {
+            iifs = NO;
+        }
+        if(iifs && [mView respondsToSelector:@selector(exitFullScreenModeWithOptions:)] ) {
+            [mView exitFullScreenModeWithOptions: NULL];
+        }
+    } */
+    // Note: mWin's release will also release it's mView!
+    DBG_PRINT( "windowClose.1a - %p view %p, fullscreen %d, hasPresSwitch %d, defaultPresentationOptions 0x%X\n", 
+        mWin, mView, (int)fullscreen, (int)mWin->hasPresentationSwitch, (int)mWin->defaultPresentationOptions);
+
+    if( fullscreen && mWin->hasPresentationSwitch ) {
+        DBG_PRINT( "windowClose.1b - %p view %p, setPresentationOptions 0x%X\n", 
+            mWin, mView, (int)mWin->defaultPresentationOptions);
+        // TODO [NSApp setPresentationOptions: mWin->defaultPresentationOptions];
+    }
+NS_HANDLER
+NS_ENDHANDLER
+
+    if(NULL!=pWin) {
+        [mWin detachFromParent: pWin];
+    }
+    // TODO [mWin orderOut: mWin];
+    [mWin setHidden: YES]; // no release, close n/a, .. well: ref count counts :-(
+
+    DBG_PRINT( "windowClose.2 - %p view %p, parent %p\n", mWin, mView, pWin);
+
+    [mWin release];
+
+    DBG_PRINT( "windowClose.Xp\n");
+
+    [pool release];
+}
+
+/*
+ * Class:     Java_jogamp_newt_driver_ios_WindowDriver
+ * Method:    lockSurface0
+ * Signature: (JJ)Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_ios_WindowDriver_lockSurface0
+  (JNIEnv *env, jclass clazz, jlong window, jlong view)
+{
+    NewtUIWindow *mWin = (NewtUIWindow*) ((intptr_t) window);
+    if(NO == [mWin isRealized]) {
+        return JNI_FALSE;
+    }
+    NewtUIView * mView = (NewtUIView *) ((intptr_t) view);
+    return [mView softLock] == YES ? JNI_TRUE : JNI_FALSE;
+    /** deadlocks, since we render independent of focus
+    return [mView lockFocusIfCanDraw] == YES ? JNI_TRUE : JNI_FALSE; */
+}
+
+/*
+ * Class:     Java_jogamp_newt_driver_ios_WindowDriver
+ * Method:    unlockSurface0
+ * Signature: (JJ)Z
+ */
+JNIEXPORT jboolean JNICALL Java_jogamp_newt_driver_ios_WindowDriver_unlockSurface0
+  (JNIEnv *env, jclass clazz, jlong window, jlong view)
+{
+    // NewtUIWindow *mWin = (NewtUIWindow*) ((intptr_t) window);
+    (void) window;
+    NewtUIView * mView = (NewtUIView *) ((intptr_t) view);
+    return [mView softUnlock] == YES ? JNI_TRUE : JNI_FALSE;
+    /** deadlocks, since we render independent of focus
+    [mView unlockFocus]; */
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    requestFocus0
+ * Signature: (JZ)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_requestFocus0
+  (JNIEnv *env, jobject window, jlong w, jboolean force)
+{
+    UIWindow* mWin = (UIWindow*) ((intptr_t) w);
+    if( NULL == mWin ) {
+        DBG_PRINT( "requestFocus - NULL NEWT win - abort\n");
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+#ifdef VERBOSE_ON
+    BOOL hasFocus = [mWin isKeyWindow];
+#endif
+    DBG_PRINT( "requestFocus - window: %p, force %d, hasFocus %d (START)\n", mWin, force, hasFocus);
+
+    // TODO [mWin setAcceptsMouseMovedEvents: YES];
+    // TODO [mWin makeFirstResponder: nil];
+    // TODO [mWin orderFrontRegardless];
+    [mWin makeKeyWindow];
+
+    DBG_PRINT( "requestFocus - window: %p, force %d (END)\n", mWin, force);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    resignFocus0
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_resignFocus0
+  (JNIEnv *env, jobject window, jlong w)
+{
+    UIWindow* mWin = (UIWindow*) ((intptr_t) w);
+    if( NULL == mWin ) {
+        DBG_PRINT( "resignFocus0 - NULL NEWT win - abort\n");
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    UIWindow* pWin = NULL; // TODO [mWin parentWindow];
+    BOOL hasFocus = [mWin isKeyWindow];
+
+    DBG_PRINT( "resignFocus0 - window: %p, parent %p, hasFocus %d (START)\n", mWin, pWin, hasFocus );
+    if( hasFocus ) {
+        if(NULL != pWin) {
+            // [mWin makeFirstResponder: pWin];
+            [pWin makeKeyWindow];
+        } else {
+            [pWin resignKeyWindow];
+        }
+    }
+    DBG_PRINT( "resignFocus0 - window: %p (END)\n", mWin);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    orderFront0
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_orderFront0
+  (JNIEnv *env, jobject unused, jlong window)
+{
+    UIWindow* mWin = (UIWindow*) ((intptr_t) window);
+    if( NULL == mWin ) {
+        DBG_PRINT( "orderFront0 - NULL NEWT win - abort\n");
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    UIWindow* pWin = NULL; // TODO [mWin parentWindow];
+
+    DBG_PRINT( "orderFront0 - window: (parent %p) %p visible %d (START)\n", pWin, mWin, [mWin isVisible]);
+
+    if( NULL == pWin ) {
+        // TODO [mWin orderFrontRegardless];
+    } else {
+        // TODO [mWin orderWindow: UIWindowAbove relativeTo: [pWin windowNumber]];
+    }
+
+    DBG_PRINT( "orderFront0 - window: (parent %p) %p (END)\n", pWin, mWin);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    orderOut
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_orderOut0
+  (JNIEnv *env, jobject unused, jlong window)
+{
+    UIWindow* mWin = (UIWindow*) ((intptr_t) window);
+    if( NULL == mWin ) {
+        DBG_PRINT( "orderOut0 - NULL NEWT win - abort\n");
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    UIWindow* pWin = NULL; // TODO [mWin parentWindow];
+
+    DBG_PRINT( "orderOut0 - window: (parent %p) %p visible %d (START)\n", pWin, mWin, [mWin isVisible]);
+
+    if( NULL == pWin ) {
+        // TODO [mWin orderOut: mWin];
+    } else {
+        // TODO [mWin orderWindow: UIWindowOut relativeTo: [pWin windowNumber]];
+    }
+
+    DBG_PRINT( "orderOut0 - window: (parent %p) %p (END)\n", pWin, mWin);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    setTitle0
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_setTitle0
+  (JNIEnv *env, jobject unused, jlong window, jstring title)
+{
+    UIWindow* win = (UIWindow*) ((intptr_t) window);
+    if( NULL == win ) {
+        DBG_PRINT( "setTitle0 - NULL NEWT win - abort\n");
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+    DBG_PRINT( "setTitle0 - window: %p (START)\n", win);
+
+    NSString* str = jstringToNSString(env, title);
+    [str autorelease];
+    // TODO [win setTitle: str];
+
+    DBG_PRINT( "setTitle0 - window: %p (END)\n", win);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    contentView0
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_ios_WindowDriver_contentView0
+  (JNIEnv *env, jobject unused, jlong window)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    UIWindow* win = (UIWindow*) ((intptr_t) window);
+    UIView* nsView = (UIView*)win; // TODO [win contentView];
+    NewtUIView* newtView = NULL;
+
+    if( [nsView isKindOfClass:[NewtUIView class]] ) {
+        newtView = (NewtUIView *) nsView;
+    }
+
+    DBG_PRINT( "contentView0 - window: %p, view: %p, newtView %p\n", win, nsView, newtView);
+
+    jlong res = (jlong) ((intptr_t) nsView);
+
+    [pool release];
+    return res;
+}
+
+/**
+ * Method is called on Main-Thread, hence no special invocation required inside method.
+ *
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    changeContentView
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_changeContentView0
+  (JNIEnv *env, jobject jthis, jlong parentWindowOrView, jlong window, jlong jview)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+    NewtUIView* newView = (NewtUIView *) ((intptr_t) jview);
+    NewtUIWindow* win = (NewtUIWindow*) ((intptr_t) window);
+
+    DBG_PRINT( "changeContentView0.0 -  win %p, view (%p,%d)\n", 
+        win, newView, getRetainCount(newView));
+
+    NSObject *nsParentObj = (NSObject*) ((intptr_t) parentWindowOrView);
+    UIView* pView = NULL;
+    if( NULL != nsParentObj ) {
+        if( [nsParentObj isKindOfClass:[UIWindow class]] ) {
+            UIWindow * pWin = (UIWindow*) nsParentObj;
+            pView = (UIView*)pWin; // TODO [pWin contentView];
+        } else if( [nsParentObj isKindOfClass:[UIView class]] ) {
+            pView = (UIView*) nsParentObj;
+        }
+    }
+
+    changeContentView(env, jthis, pView, win, newView, YES);
+
+    DBG_PRINT( "changeContentView0.X\n");
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    updateSizePosInsets0
+ * Signature: (JZ)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_updateSizePosInsets0
+  (JNIEnv *env, jobject jthis, jlong window, jboolean defer)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    NewtUIWindow* mWin = (NewtUIWindow*) ((intptr_t) window);
+
+    DBG_PRINT( "updateSizePosInsets - window: %p, defer %d (START)\n", mWin, (int)defer);
+
+    [mWin updateSizePosInsets: env jwin:jthis defer:defer];
+
+    DBG_PRINT( "updateSizePosInsets - window: %p, defer %d (END)\n", mWin, (int)defer);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    setWindowClientTopLeftPointAndSize0
+ * Signature: (JIIIIZ)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_setWindowClientTopLeftPointAndSize0
+  (JNIEnv *env, jobject unused, jlong window, jint x, jint y, jint w, jint h, jboolean display)
+{
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+    NewtUIWindow* mWin = (NewtUIWindow*) ((intptr_t) window);
+
+    DBG_PRINT( "setWindowClientTopLeftPointAndSize - window: %p (START)\n", mWin);
+
+    setWindowClientTopLeftPointAndSize(mWin, x, y, w, h, display);
+
+    DBG_PRINT( "setWindowClientTopLeftPointAndSize - window: %p (END)\n", mWin);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    setWindowClientTopLeftPoint0
+ * Signature: (JIIZ)V
+ */
+JNIEXPORT void JNICALL Java_jogamp_newt_driver_ios_WindowDriver_setWindowClientTopLeftPoint0
+  (JNIEnv *env, jobject unused, jlong window, jint x, jint y, jboolean display)
+{
+    NewtUIWindow* mWin = (NewtUIWindow*) ((intptr_t) window);
+    if( NULL == mWin ) {
+        DBG_PRINT( "setWindowClientTopLeftPoint - NULL NEWT win - abort\n");
+        return;
+    }
+    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+
+    DBG_PRINT( "setWindowClientTopLeftPoint - window: %p (START)\n", mWin);
+
+    setWindowClientTopLeftPoint(mWin, x, y, display);
+
+    DBG_PRINT( "setWindowClientTopLeftPoint - window: %p (END)\n", mWin);
+
+    [pool release];
+}
+
+/*
+ * Class:     jogamp_newt_driver_ios_WindowDriver
+ * Method:    getLocationOnScreen0
+ * Signature: (JII)Lcom/jogamp/nativewindow/util/Point;
+ */
+JNIEXPORT jobject JNICALL Java_jogamp_newt_driver_ios_WindowDriver_getLocationOnScreen0
+  (JNIEnv *env, jclass unused, jlong win, jint src_x, jint src_y)
+{
+    NewtUIWindow *mWin = (NewtUIWindow*) (intptr_t) win;
+    if( NULL == mWin ) {
+        DBG_PRINT( "getLocationOnScreen0 - NULL NEWT win - abort\n");
+        return NULL;
+    }
+    if( ![mWin isKindOfClass:[NewtUIWindow class]] ) {
+        NewtCommon_throwNewRuntimeException(env, "Not a NewtUIWindow %p", mWin);
+        return NULL;
+    }
+    CGPoint p0 = [mWin getLocationOnScreen: CGPointMake(src_x, src_y)];
+    return (*env)->NewObject(env, pointClz, pointCstr, (jint)p0.x, (jint)p0.y);
+}
+
diff --git a/src/newt/native/JVM_JNI8.c b/src/newt/native/JVM_JNI8.c
new file mode 100644
index 000000000..c023cb0f0
--- /dev/null
+++ b/src/newt/native/JVM_JNI8.c
@@ -0,0 +1,42 @@
+/**
+ * Copyright 2019 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+
+#include <stdio.h> //required by android to identify NULL
+#include <jni.h>
+
+#if defined (JNI_VERSION_1_8)
+
+JNIEXPORT jint JNICALL JNI_OnLoad_newt(JavaVM *vm, void *reserved) {
+    return JNI_VERSION_1_8;
+}
+
+JNIEXPORT void JNICALL JNI_OnUnload_newt(JavaVM *vm, void *reserved) {
+}
+
+#endif /* defined (JNI_VERSION_1_8) */
+