/** * 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 #include #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