1 /*
2 * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #import "common.h"
27 #import "com_sun_glass_ui_Application.h"
28 #import "com_sun_glass_ui_mac_MacApplication.h"
29 #import "com_sun_glass_events_KeyEvent.h"
30
31
32 #import "GlassMacros.h"
33 #import "GlassApplication.h"
34 #import "GlassHelper.h"
35 #import "GlassKey.h"
36 #import "GlassScreen.h"
37 #import "GlassWindow.h"
38 #import "GlassTouches.h"
39 #import "RemoteLayerSupport.h"
40
41 #import "ProcessInfo.h"
42 #import <Security/SecRequirement.h>
43
44 //#define VERBOSE
45 #ifndef VERBOSE
46 #define LOG(MSG, ...)
47 #else
48 #define LOG(MSG, ...) GLASS_LOG(MSG, ## __VA_ARGS__);
49 #endif
50
51 //#define VERBOSE_LOAD
52
53 static BOOL shouldKeepRunningNestedLoop = YES;
54 static jobject nestedLoopReturnValue = NULL;
55 static BOOL isFullScreenExitingLoop = NO;
56 static NSMutableDictionary * keyCodeForCharMap = nil;
57 static BOOL isEmbedded = NO;
58 static BOOL disableSyncRendering = NO;
59
60 jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
61 {
62 pthread_key_create(&GlassThreadDataKey, NULL);
63
64 memset(&javaIDs, 0, sizeof(javaIDs));
65 MAIN_JVM = vm;
66 return JNI_VERSION_1_4;
67 }
68
69 #pragma mark --- GlassRunnable
70
71 @interface GlassRunnable : NSObject
72 {
73 jobject jRunnable;
74 }
75
76 - (id)initWithRunnable:(jobject)runnable;
77 - (void)run;
78
79 @end
80
81 @implementation GlassRunnable
82
83 - (id)initWithRunnable:(jobject)runnable
84 {
85 self->jRunnable = runnable;
86 return self;
87 }
88
89 - (void)run
90 {
91 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
92 {
93 assert(pthread_main_np() == 1);
94 JNIEnv *env = jEnv;
95 if (env != NULL)
96 {
97 (*env)->CallVoidMethod(env, self->jRunnable, jRunnableRun);
98 GLASS_CHECK_EXCEPTION(env);
99 }
100
101 [self release];
102 }
103 [pool drain];
104 }
105
106 - (void)dealloc
107 {
108 assert(pthread_main_np() == 1);
109 JNIEnv *env = jEnv;
110 if (env != NULL)
111 {
112 (*env)->DeleteGlobalRef(env, self->jRunnable);
113 }
114 self->jRunnable = NULL;
115
116 [super dealloc];
117 }
118
119 @end
120
121 #pragma mark --- GlassApplication
122
123 @implementation GlassApplication
124
125 - (id)initWithEnv:(JNIEnv*)env application:(jobject)application launchable:(jobject)launchable taskbarApplication:(jboolean)isTaskbarApplication classLoader:(jobject)classLoader
126 {
127 self = [super init];
128 if (self != nil)
129 {
130 self->started = NO;
131 self->jTaskBarApp = isTaskbarApplication;
132
133 self->jApplication = (*env)->NewGlobalRef(env, application);
134 if (launchable != NULL)
135 {
136 self->jLaunchable = (*env)->NewGlobalRef(env, launchable);
137 }
138
139 if (classLoader != NULL)
140 {
141 [GlassHelper SetGlassClassLoader:classLoader withEnv:env];
142 }
143 }
144 return self;
145 }
146
147 #pragma mark --- delegate methods
148
149 - (void)GlassApplicationDidChangeScreenParameters
150 {
151 LOG("GlassApplicationDidChangeScreenParameters");
152
153 GET_MAIN_JENV;
154 GlassScreenDidChangeScreenParameters(env);
155 }
156
157 - (void)applicationWillFinishLaunching:(NSNotification *)aNotification
158 {
159 LOG("GlassApplication:applicationWillFinishLaunching");
160
161 GET_MAIN_JENV;
162 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
163 {
164 if (self->jLaunchable != NULL)
165 {
166 jclass runnableClass = [GlassHelper ClassForName:"java.lang.Runnable" withEnv:jEnv];
167 if ((*env)->ExceptionCheck(env) == JNI_TRUE)
168 {
169 (*env)->ExceptionDescribe(env);
170 (*env)->ExceptionClear(env);
171 }
172
173 jmethodID runMethod = (*env)->GetMethodID(env, runnableClass, "run", "()V");
174 if ((*env)->ExceptionCheck(env) == JNI_TRUE)
175 {
176 (*env)->ExceptionDescribe(env);
177 (*env)->ExceptionClear(env);
178 }
179
180 if ((runnableClass != 0) && (runMethod != 0))
181 {
182 (*env)->CallVoidMethod(env, self->jLaunchable, runMethod);
183 if ((*env)->ExceptionCheck(env) == JNI_TRUE)
184 {
185 (*env)->ExceptionDescribe(env);
186 (*env)->ExceptionClear(env);
187 }
188 else
189 {
190 [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(GlassApplicationDidChangeScreenParameters) name:NSApplicationDidChangeScreenParametersNotification object:nil];
191 }
192 }
193 else if (runnableClass == 0)
194 {
195 NSLog(@"ERROR: Glass could not find Runnable class\n");
196 }
197 else //if (runMethod == 0)
198 {
199 NSLog(@"ERROR: Glass could not find run() method\n");
200 }
201 }
202
203 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyWillFinishLaunchingMethod]);
204
205 self->started = YES;
206 }
207 [pool drain];
208 GLASS_CHECK_EXCEPTION(env);
209 }
210
211 - (void)applicationDidFinishLaunching:(NSNotification *)aNotification
212 {
213 LOG("GlassApplication:applicationDidFinishLaunching");
214
215 GET_MAIN_JENV;
216 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
217 {
218 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyDidFinishLaunchingMethod]);
219 }
220 [pool drain];
221 GLASS_CHECK_EXCEPTION(env);
222 }
223
224 - (void)applicationWillBecomeActive:(NSNotification *)aNotification
225 {
226 LOG("GlassApplication:applicationWillBecomeActive");
227
228 GET_MAIN_JENV;
229 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
230 {
231 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyWillBecomeActiveMethod]);
232 }
233 [pool drain];
234 GLASS_CHECK_EXCEPTION(env);
235 }
236
237 - (void)applicationDidBecomeActive:(NSNotification *)aNotification
238 {
239 LOG("GlassApplication:applicationDidBecomeActive");
240
241 GET_MAIN_JENV;
242 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
243 {
244 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyDidBecomeActiveMethod]);
245 }
246 [pool drain];
247 GLASS_CHECK_EXCEPTION(env);
248 }
249
250 - (void)applicationWillResignActive:(NSNotification *)aNotification
251 {
252 LOG("GlassApplication:applicationWillResignActive");
253
254 GET_MAIN_JENV;
255 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
256 {
257 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyWillResignActiveMethod]);
258 }
259 [pool drain];
260 GLASS_CHECK_EXCEPTION(env);
261 }
262
263 - (void)applicationDidResignActive:(NSNotification *)aNotification
264 {
265 LOG("GlassApplication:applicationDidResignActive");
266
267 GET_MAIN_JENV;
268 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
269 {
270 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyDidResignActiveMethod]);
271 }
272 [pool drain];
273 GLASS_CHECK_EXCEPTION(env);
274 }
275
276 - (void)applicationWillHide:(NSNotification *)aNotification
277 {
278 LOG("GlassApplication:applicationWillHide");
279
280 GET_MAIN_JENV;
281 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
282 {
283 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyWillHideMethod]);
284 }
285 [pool drain];
286 GLASS_CHECK_EXCEPTION(env);
287 }
288
289 - (void)applicationDidHide:(NSNotification *)aNotification
290 {
291 LOG("GlassApplication:applicationDidHide");
292
293 GET_MAIN_JENV;
294 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
295 {
296 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyDidHideMethod]);
297 }
298 [pool drain];
299 GLASS_CHECK_EXCEPTION(env);
300 }
301
302 - (void)applicationWillUnhide:(NSNotification *)aNotification
303 {
304 LOG("GlassApplication:applicationWillUnhide");
305
306 GET_MAIN_JENV;
307 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
308 {
309 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyWillUnhideMethod]);
310 }
311 [pool drain];
312 GLASS_CHECK_EXCEPTION(env);
313 }
314
315 - (void)applicationDidUnhide:(NSNotification *)aNotification
316 {
317 LOG("GlassApplication:applicationDidUnhide");
318
319 GET_MAIN_JENV;
320 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
321 {
322 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyDidUnhideMethod]);
323 }
324 [pool drain];
325 GLASS_CHECK_EXCEPTION(env);
326 }
327
328 - (void)application:(NSApplication *)theApplication openFiles:(NSArray *)filenames
329 {
330 LOG("GlassApplication:application:openFiles");
331
332 GET_MAIN_JENV;
333 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
334 {
335 NSUInteger count = [filenames count];
336 jobjectArray files = (*env)->NewObjectArray(env, (jsize)count, [GlassHelper ClassForName:"java.lang.String" withEnv:env], NULL);
337 GLASS_CHECK_EXCEPTION(env);
338 for (NSUInteger i=0; i<count; i++)
339 {
340 NSString *file = [filenames objectAtIndex:i];
341 if (file != nil)
342 {
343 (*env)->SetObjectArrayElement(env, files, (jsize)i, (*env)->NewStringUTF(env, [file UTF8String]));
344 GLASS_CHECK_EXCEPTION(env);
345 }
346 }
347 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyOpenFilesMethod], files);
348 }
349 [pool drain];
350 GLASS_CHECK_EXCEPTION(env);
351
352 [theApplication replyToOpenOrPrint:NSApplicationDelegateReplySuccess];
353 }
354
355 - (BOOL)application:(NSApplication *)theApplication openFile:(NSString *)filename
356 {
357 LOG("GlassApplication:application:openFile");
358
359 // controlled by Info.plist -NSOpenfileName
360 // http://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html
361 [self application:theApplication openFiles:[NSArray arrayWithObject:filename]];
362
363 return YES;
364 }
365
366 - (BOOL)application:(id)theApplication openFileWithoutUI:(NSString *)filename
367 {
368 LOG("GlassApplication:application:openFileWithoutUI");
369
370 // programmaticaly called by the client (even though GlassApplication does not currently call it, let's wire it in just in case)
371 [self application:theApplication openFiles:[NSArray arrayWithObject:filename]];
372
373 return YES;
374 }
375
376 - (BOOL)application:(NSApplication *)theApplication openTempFile:(NSString *)filename
377 {
378 LOG("GlassApplication:application:openTempFile");
379
380 // controlled by Info.plist -NSOpenTempfileName
381 // http://developer.apple.com/library/mac/#documentation/MacOSX/Conceptual/BPRuntimeConfig/Articles/ConfigApplications.html
382 // NOP
383
384 return YES;
385 }
386
387 - (BOOL)applicationShouldOpenUntitledFile:(NSApplication *)sender
388 {
389 LOG("GlassApplication:applicationShouldOpenUntitledFile");
390
391 // don't want
392
393 return NO;
394 }
395
396 - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
397 {
398 LOG("GlassApplication:applicationShouldTerminate");
399
400 GET_MAIN_JENV;
401 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
402 {
403 (*env)->CallVoidMethod(env, self->jApplication, [GlassHelper ApplicationNotifyWillQuitMethod]);
404 }
405 [pool drain];
406 GLASS_CHECK_EXCEPTION(env);
407
408 return NSTerminateCancel;
409 }
410
411
412 - (BOOL)applicationOpenUntitledFile:(NSApplication *)theApplication
413 {
414 LOG("GlassApplication:applicationOpenUntitledFile");
415
416 // NOP (should never be called because applicationShouldOpenUntitledFile returns NO)
417
418 return YES;
419 }
420
421 #pragma mark --- Glass support
422
423 - (void)runLoop:(id)selector
424 {
425 LOG("GlassApplication:runLoop ENTER");
426
427 NSAutoreleasePool *pool1 = [[NSAutoreleasePool alloc] init];
428
429 jint error = (*jVM)->AttachCurrentThread(jVM, (void **)&jEnv, NULL);
430 //jint error = (*jVM)->AttachCurrentThreadAsDaemon(jVM, (void **)&jEnv, NULL);
431 if (error == 0)
432 {
433 NSAutoreleasePool *pool2 = [[NSAutoreleasePool alloc] init];
434
435 if ([[NSThread currentThread] name] == nil)
436 {
437 [[NSThread currentThread] setName:@"Main Cocoa (UI) Thread"];
438 }
439
440 GlassApplication *glassApp = (GlassApplication *)selector;
441
442 // Load MacApplication class using the glass classloader
443 jclass cls = [GlassHelper ClassForName:"com.sun.glass.ui.mac.MacApplication" withEnv:jEnv];
444 if (!cls)
445 {
446 NSLog(@"ERROR: can't find the MacApplication class");
447 }
448 else
449 {
450 jmethodID setEventThreadMID = (*jEnv)->GetMethodID(jEnv, cls, "setEventThread", "()V");
451 if (!setEventThreadMID)
452 {
453 NSLog(@"ERROR: can't get MacApplication.setEventThread() method ID");
454 }
455 else
456 {
457 (*jEnv)->CallVoidMethod(jEnv, glassApp->jApplication, setEventThreadMID);
458 }
459 }
460 GLASS_CHECK_EXCEPTION(jEnv);
461
462 NSBundle *mainBundle = [NSBundle mainBundle];
463 {
464 NSString *appName = [mainBundle objectForInfoDictionaryKey:@"CFBundleDisplayName"];
465
466 if (appName == nil) {
467 appName = [mainBundle objectForInfoDictionaryKey:@"CFBundleName"];
468 }
469
470 if (appName) {
471 // make the name available to Java side, before Launchable.fnishLaunching callback
472 jstring jname = (*jEnv)->NewStringUTF(jEnv, [appName UTF8String]);
473 jmethodID setNameMethod = (*jEnv)->GetMethodID(jEnv, cls, "setName", "(Ljava/lang/String;)V");
474 GLASS_CHECK_EXCEPTION(jEnv);
475 if (setNameMethod != NULL) {
476 (*jEnv)->CallVoidMethod(jEnv, glassApp->jApplication, setNameMethod, jname);
477 }
478 GLASS_CHECK_EXCEPTION(jEnv);
479 }
480 }
481
482 // Determine if we're running embedded (in AWT, SWT, elsewhere)
483 NSApplication *app = [NSApplication sharedApplication];
484 isEmbedded = [app isRunning];
485
486 if (!isEmbedded)
487 {
488 if (self->jTaskBarApp == JNI_TRUE)
489 {
490 // move process from background only to full on app with visible Dock icon
491 ProcessSerialNumber psn;
492 if (GetCurrentProcess(&psn) == noErr)
493 {
494 TransformProcessType(&psn, kProcessTransformToForegroundApplication);
495 }
496
497 NSString *CFBundleIconFile = [mainBundle objectForInfoDictionaryKey:@"CFBundleIconFile"];
498 NSString *iconPath = nil;
499 if (CFBundleIconFile != nil)
500 {
501 iconPath = [mainBundle pathForResource:[CFBundleIconFile stringByDeletingPathExtension] ofType:[CFBundleIconFile pathExtension]];
502 }
503
504 // -Xdock:icon can override CFBundleIconFile (but only if it actually points to a valid icon)
505 NSString *property = [NSString stringWithFormat:@"APP_ICON_%d", [[NSProcessInfo processInfo] processIdentifier]];
506 char *path = getenv([property UTF8String]);
507 if (path != NULL)
508 {
509 NSString *overridenPath = [NSString stringWithFormat:@"%s", path];
510 if ([[NSFileManager defaultManager] fileExistsAtPath:overridenPath isDirectory:NO] == YES)
511 {
512 iconPath = overridenPath;
513 }
514 }
515 if ([[NSFileManager defaultManager] fileExistsAtPath:iconPath isDirectory:NO] == NO)
516 {
517 // try again using Java generic icon (this icon might go away eventually ?)
518 iconPath = [NSString stringWithFormat:@"%s", "/System/Library/Frameworks/JavaVM.framework/Resources/GenericApp.icns"];
519 }
520
521 NSImage *image = nil;
522 {
523 if ([[NSFileManager defaultManager] fileExistsAtPath:iconPath isDirectory:NO] == YES)
524 {
525 image = [[NSImage alloc] initWithContentsOfFile:iconPath];
526 }
527 if (image == nil)
528 {
529 // last resort - if still no icon, then ask for an empty standard app icon, which is guranteed to exist
530 image = [[NSImage imageNamed:@"NSApplicationIcon"] retain];
531 }
532 }
533 [app setApplicationIconImage:image];
534 [image release];
535
536 // Install a hidden Window menu. This allows the dock icon
537 // menu to show the list of open windows (NSWindow instances)
538 NSMenu *myMenu = [[NSMenu alloc] initWithTitle:@"Window"];
539 [app setWindowsMenu:myMenu];
540 [myMenu release];
541
542 [app setDelegate:self];
543
544 // [app activateIgnoringOtherApps:YES] won't activate the menu bar on OS X 10.9, so instead we do this:
545 [[NSRunningApplication currentApplication] activateWithOptions:(NSApplicationActivateIgnoringOtherApps | NSApplicationActivateAllWindows)];
546 }
547 else
548 {
549 // allow background processes to change the cursor (10.8 only API so we'll have to dynamically call it if available)
550 {
551 BOOL yes = YES;
552 [GlassHelper InvokeSelectorIfAvailable:@selector(javaSetAllowsCursorSetInBackground:) forClass:[NSCursor class] withArgument:&yes withReturnValue:NULL];
553 }
554
555 // http://developer.apple.com/library/ios/#documentation/DeveloperTools/Conceptual/cross_development/Using/using.html
556 if (floor(NSAppKitVersionNumber) >= 1138) // NSAppKitVersionNumber10_7
557 {
558 // 10.7 or later: move process from background only process to a limited app with active windows,
559 // but no Dock icon
560 ProcessSerialNumber psn;
561 if (GetCurrentProcess(&psn) == noErr)
562 {
563 TransformProcessType(&psn, 4); // kProcessTransformToUIElementApplication
564 }
565 }
566 else
567 {
568 // 10.6 or earlier: applets are not officially supported on 10.6 and earlier
569 // so they will have limited applet functionality (no active windows)
570 }
571 [app setDelegate:self];
572 }
573
574 #if defined(VERBOSE_LOAD)
575 jclass BooleanClass = [GlassHelper ClassForName:"java.lang.Boolean" withEnv:jEnv];
576 if (BooleanClass != 0)
577 {
578 jmethodID getBooleanMethod = (*jEnv)->GetStaticMethodID(jEnv, BooleanClass, "getBoolean", "(Ljava/lang/String;)Z");
579 if (getBooleanMethod != 0)
580 {
581 jstring flag = (*jEnv)->NewStringUTF(jEnv, "glassload.verbose");
582 jboolean verbose = (*jEnv)->CallStaticBooleanMethod(jEnv, BooleanClass, getBooleanMethod, flag);
583 if (verbose == JNI_TRUE)
584 {
585 printLoadedLibraries(stderr);
586 printLoadedFiles(stderr);
587 }
588 }
589 }
590 #endif
591
592 // drain the pool before entering runloop
593 [pool2 drain];
594
595 // enter runloop, this will not return until terminated
596 [NSApp run];
597
598 // Abort listerning to global touch input events
599 [GlassTouches terminate];
600
601 GLASS_CHECK_EXCEPTION(jEnv);
602
603 (*jEnv)->CallVoidMethod(jEnv, self->jApplication, javaIDs.MacApplication.notifyApplicationDidTerminate);
604 GLASS_CHECK_EXCEPTION(jEnv);
605
606 jint err = (*jVM)->DetachCurrentThread(jVM);
607 if (err < 0)
608 {
609 NSLog(@"Unable to detach from JVM. Error code: %d\n", (int)err);
610 }
611
612 jEnv = NULL;
613 }
614 else // event loop is not started
615 {
616 if ([NSThread isMainThread] == YES) {
617 [glassApp applicationWillFinishLaunching: NULL];
618 } else {
619 [glassApp performSelectorOnMainThread:@selector(applicationWillFinishLaunching:) withObject:NULL waitUntilDone:NO];
620 }
621 GLASS_CHECK_EXCEPTION(jEnv);
622
623 [pool2 drain];
624 }
625 }
626 else // attaching to JVM failed
627 {
628 NSLog(@"ERROR: Glass could not attach to VM, result:%d\n", (int)error);
629 }
630
631 [pool1 drain];
632
633 LOG("GlassApplication:runLoop EXIT");
634 }
635
636 - (BOOL)started
637 {
638 return self->started;
639 }
640
641 + (jobject)enterNestedEventLoopWithEnv:(JNIEnv*)env
642 {
643 jobject ret = NULL;
644
645 NSRunLoop *theRL = [NSRunLoop currentRunLoop];
646 NSApplication * app = [NSApplication sharedApplication];
647 shouldKeepRunningNestedLoop = YES;
648 // Cannot use [NSDate distantFuture] because the period is big the app could hang in a runloop
649 // if the event came before entering the RL
650 while (shouldKeepRunningNestedLoop && [theRL runMode:NSDefaultRunLoopMode
651 beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.010]])
652 {
653 NSEvent * event = [app nextEventMatchingMask: 0xFFFFFFFF untilDate:nil inMode:NSDefaultRunLoopMode dequeue:YES];
654
655 if (event != nil) {
656 [app sendEvent: event];
657 }
658 }
659
660 if (nestedLoopReturnValue != NULL) {
661 ret = (*env)->NewLocalRef(env, nestedLoopReturnValue);
662 (*env)->DeleteGlobalRef(env, nestedLoopReturnValue);
663 nestedLoopReturnValue = NULL;
664 }
665
666 shouldKeepRunningNestedLoop = YES;
667
668 return ret;
669 }
670
671 + (void)leaveNestedEventLoopWithEnv:(JNIEnv*)env retValue:(jobject)retValue
672 {
673 if (retValue != NULL) {
674 nestedLoopReturnValue = (*env)->NewGlobalRef(env, retValue);
675 }
676 shouldKeepRunningNestedLoop = NO;
677 }
678
679 + (void)enterFullScreenExitingLoop
680 {
681 isFullScreenExitingLoop = YES;
682 GET_MAIN_JENV;
683 (*env)->CallStaticObjectMethod(env, jApplicationClass,
684 javaIDs.Application.enterNestedEventLoop);
685 isFullScreenExitingLoop = NO;
686 }
687
688 + (void)leaveFullScreenExitingLoopIfNeeded
689 {
690 if (!isFullScreenExitingLoop) {
691 return;
692 }
693 GET_MAIN_JENV;
694 (*env)->CallStaticVoidMethod(env, jApplicationClass,
695 javaIDs.Application.leaveNestedEventLoop, (jobject)NULL);
696 }
697
698 + (void)registerKeyEvent:(NSEvent*)event
699 {
700 if (!keyCodeForCharMap) {
701 keyCodeForCharMap = [[NSMutableDictionary alloc] initWithCapacity:100];
702 // Note: it's never released, just like, say, the jApplication reference...
703 }
704 [keyCodeForCharMap setObject:[NSNumber numberWithUnsignedShort:[event keyCode]] forKey:[event characters]];
705 }
706
707 + (jint)getKeyCodeForChar:(jchar)c;
708 {
709 id v = [keyCodeForCharMap objectForKey:[NSString stringWithCharacters: (UniChar *)&c length:1]];
710 if (!v) {
711 return com_sun_glass_events_KeyEvent_VK_UNDEFINED;
712 } else {
713 return GetJavaKeyCodeFor([v unsignedShortValue]);
714 }
715 }
716
717 + (BOOL)syncRenderingDisabled {
718 return disableSyncRendering;
719 }
720
721 + (BOOL)isSandboxed
722 {
723 static int isSandboxed = -1;
724
725 if (isSandboxed == -1) {
726 isSandboxed = 0;
727
728 NSBundle *mainBundle = [NSBundle mainBundle];
729 NSURL *url = [mainBundle bundleURL];
730 SecStaticCodeRef staticCodeRef = NULL;
731 SecStaticCodeCreateWithPath((CFURLRef)url, kSecCSDefaultFlags, &staticCodeRef);
732
733 if (staticCodeRef) {
734 // Check if the app is signed
735 OSStatus res_signed = SecStaticCodeCheckValidityWithErrors(staticCodeRef, kSecCSBasicValidateOnly, NULL, NULL);
736 if (res_signed == errSecSuccess) {
737 // It is signed, now check if it's sandboxed
738 SecRequirementRef sandboxRequirementRef = NULL;
739 SecRequirementCreateWithString(CFSTR("entitlement[\"com.apple.security.app-sandbox\"] exists"), kSecCSDefaultFlags, &sandboxRequirementRef);
740
741 if (sandboxRequirementRef) {
742 OSStatus res_sandboxed = SecStaticCodeCheckValidityWithErrors(staticCodeRef, kSecCSBasicValidateOnly, sandboxRequirementRef, NULL);
743 if (res_sandboxed == errSecSuccess) {
744 // Yep, sandboxed
745 isSandboxed = 1;
746 }
747
748 CFRelease(sandboxRequirementRef);
749 }
750 }
751
752 CFRelease(staticCodeRef);
753 }
754 }
755
756 return isSandboxed == 1 ? YES : NO;
757 }
758
759 @end
760
761 #pragma mark --- JNI
762
763 /*
764 * Class: com_sun_glass_ui_mac_MacApplication
765 * Method: _initIDs
766 * Signature: ()V
767 */
768 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1initIDs
769 (JNIEnv *env, jclass jClass, jboolean jDisableSyncRendering)
770 {
771 LOG("Java_com_sun_glass_ui_mac_MacApplication__1initIDs");
772
773 disableSyncRendering = jDisableSyncRendering ? YES : NO;
774
775 jApplicationClass = (*env)->NewGlobalRef(env, jClass);
776
777 javaIDs.Application.createPixels = (*env)->GetStaticMethodID(
778 env, jClass, "createPixels", "(II[IF)Lcom/sun/glass/ui/Pixels;");
779 if ((*env)->ExceptionCheck(env)) return;
780
781 javaIDs.Application.getScaleFactor = (*env)->GetStaticMethodID(
782 env, jClass, "getScaleFactor", "(IIII)F");
783 if ((*env)->ExceptionCheck(env)) return;
784
785 javaIDs.Application.reportException = (*env)->GetStaticMethodID(
786 env, jClass, "reportException", "(Ljava/lang/Throwable;)V");
787 if ((*env)->ExceptionCheck(env)) return;
788
789 javaIDs.Application.enterNestedEventLoop = (*env)->GetStaticMethodID(
790 env, jClass, "enterNestedEventLoop", "()Ljava/lang/Object;");
791 if ((*env)->ExceptionCheck(env)) return;
792
793 javaIDs.Application.leaveNestedEventLoop = (*env)->GetStaticMethodID(
794 env, jClass, "leaveNestedEventLoop", "(Ljava/lang/Object;)V");
795 if ((*env)->ExceptionCheck(env)) return;
796
797 javaIDs.MacApplication.notifyApplicationDidTerminate = (*env)->GetMethodID(
798 env, jClass, "notifyApplicationDidTerminate", "()V");
799 if ((*env)->ExceptionCheck(env)) return;
800
801 if (jRunnableRun == NULL)
802 {
803 jclass jcls = (*env)->FindClass(env, "java/lang/Runnable");
804 if ((*env)->ExceptionCheck(env)) return;
805 jRunnableRun = (*env)->GetMethodID(env, jcls, "run", "()V");
806 if ((*env)->ExceptionCheck(env)) return;
807 }
808 }
809
810 /*
811 * Class: com_sun_glass_ui_mac_MacApplication
812 * Method: _runLoop
813 * Signature: (Ljava/lang/ClassLoader;Ljava/lang/Runnable;Z)V
814 */
815 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1runLoop
816 (JNIEnv *env, jobject japplication, jobject classLoader,
817 jobject jlaunchable, jboolean isTaskbarApplication)
818 {
819 LOG("Java_com_sun_glass_ui_mac_MacApplication__1runLoop");
820
821 NSAutoreleasePool *glasspool = [[NSAutoreleasePool alloc] init];
822 {
823 if ([NSThread isMainThread] == YES)
824 {
825 // fprintf(stderr, "\nWARNING: Glass was started on 1st thread and will block this thread.\nYou most likely do not want to do this - please remove \"-XstartOnFirstThread\" from VM arguments.\n\n");
826 }
827 else
828 {
829 if ([[NSThread currentThread] name] == nil)
830 {
831 [[NSThread currentThread] setName:@"Main Java Thread"];
832 }
833 }
834
835 GlassApplication *glass = [[GlassApplication alloc] initWithEnv:env application:japplication launchable:jlaunchable taskbarApplication:isTaskbarApplication classLoader:classLoader];
836 if ([NSThread isMainThread] == YES) {
837 [glass runLoop: glass];
838 } else {
839 [glass performSelectorOnMainThread:@selector(runLoop:) withObject:glass waitUntilDone:[NSThread isMainThread]];
840
841 // wait for Cocoa to enter its UI runloop
842 while ([glass started] == NO)
843 {
844 LOG(" waiting for [glass started]");
845 usleep(10000);
846 }
847 }
848
849 // at this point Java main thread is allowed to proceed, but Cocoa's UI thread entered its runloop, so the VM will not quit
850 }
851 [glasspool drain]; glasspool=nil;
852 GLASS_CHECK_EXCEPTION(env);
853 }
854
855 /*
856 * Class: com_sun_glass_ui_mac_MacApplication
857 * Method: _finishTerminating
858 * Signature: ()V
859 */
860 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1finishTerminating
861 (JNIEnv *env, jobject japplication)
862 {
863 LOG("Java_com_sun_glass_ui_mac_MacApplication__1finishTerminating");
864
865 if (isEmbedded) {
866 return;
867 }
868
869 NSAutoreleasePool *glasspool = [[NSAutoreleasePool alloc] init];
870 {
871 [NSApp stop:nil];
872 [NSApp hide:nil];
873
874 // wake up the runloop one last time so that it can process the stop:
875 // request, even if the app is inactive currently
876 NSTimeInterval dummyEventTimestamp = [NSProcessInfo processInfo].systemUptime;
877 NSEvent* event = [NSEvent otherEventWithType: NSApplicationDefined
878 location: NSMakePoint(0,0)
879 modifierFlags: 0
880 timestamp: dummyEventTimestamp
881 windowNumber: 0
882 context: nil
883 subtype: 0
884 data1: 0
885 data2: 0];
886 [NSApp postEvent: event atStart: NO];
887 }
888 [glasspool drain]; glasspool=nil;
889 GLASS_CHECK_EXCEPTION(env);
890 }
891
892 /*
893 * Class: com_sun_glass_ui_mac_MacApplication
894 * Method: _enterNestedEventLoopImpl
895 * Signature: ()Ljava/lang/Object;
896 */
897 JNIEXPORT jobject JNICALL Java_com_sun_glass_ui_mac_MacApplication__1enterNestedEventLoopImpl
898 (JNIEnv *env, jobject japplication)
899 {
900 LOG("Java_com_sun_glass_ui_mac_MacApplication__1enterNestedEventLoopImpl");
901
902 jobject ret;
903
904 NSAutoreleasePool *glasspool = [[NSAutoreleasePool alloc] init];
905 {
906 ret = [GlassApplication enterNestedEventLoopWithEnv:env];
907 }
908 [glasspool drain]; glasspool=nil;
909 GLASS_CHECK_EXCEPTION(env);
910
911 return ret;
912 }
913
914 /*
915 * Class: com_sun_glass_ui_mac_MacApplication
916 * Method: _leaveNestedEventLoopImpl
917 * Signature: (Ljava/lang/Object;)V
918 */
919 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1leaveNestedEventLoopImpl
920 (JNIEnv *env, jobject japplication, jobject retValue)
921 {
922 LOG("Java_com_sun_glass_ui_mac_MacApplication__1leaveNestedEventLoopImpl");
923
924 NSAutoreleasePool *glasspool = [[NSAutoreleasePool alloc] init];
925 {
926 [GlassApplication leaveNestedEventLoopWithEnv:env retValue:retValue];
927 }
928 [glasspool drain]; glasspool=nil;
929 GLASS_CHECK_EXCEPTION(env);
930 }
931
932 /*
933 * Class: com_sun_glass_ui_Application
934 * Method: _submitForLaterInvocation
935 * Signature: (Ljava/lang/Runnable;)V
936 */
937 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1submitForLaterInvocation
938 (JNIEnv *env, jobject japplication, jobject jRunnable)
939 {
940 //LOG("Java_com_sun_glass_ui_mac_MacApplication_submitForLaterInvocation");
941
942 GLASS_ASSERT_MAIN_JAVA_THREAD(env);
943 if (jEnv != NULL)
944 {
945 GlassRunnable *runnable = [[GlassRunnable alloc] initWithRunnable:(*env)->NewGlobalRef(env, jRunnable)];
946 [runnable performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];
947 }
948 }
949
950 /*
951 * Class: com_sun_glass_ui_Application
952 * Method: _invokeAndWait
953 * Signature: (Ljava/lang/Runnable;)V
954 */
955 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1invokeAndWait
956 (JNIEnv *env, jobject japplication, jobject jRunnable)
957 {
958 LOG("Java_com_sun_glass_ui_mac_MacApplication__1invokeAndWait");
959
960 GLASS_ASSERT_MAIN_JAVA_THREAD(env);
961 if (jEnv != NULL)
962 {
963 GlassRunnable *runnable = [[GlassRunnable alloc] initWithRunnable:(*env)->NewGlobalRef(env, jRunnable)];
964 [runnable performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];
965 }
966 }
967
968 /*
969 * Class: com_sun_glass_ui_mac_MacApplication
970 * Method: _getRemoteLayerServerName
971 * Signature: ()Ljava/lang/String;
972 */
973 JNIEXPORT jstring JNICALL Java_com_sun_glass_ui_mac_MacApplication__1getRemoteLayerServerName
974 (JNIEnv *env, jobject japplication)
975 {
976 LOG("Java_com_sun_glass_ui_mac_MacPasteboard__1getName");
977
978 jstring name = NULL;
979
980 GLASS_ASSERT_MAIN_JAVA_THREAD(env);
981 GLASS_POOL_ENTER;
982 {
983 static mach_port_t remoteLayerServerPort = MACH_PORT_NULL;
984 if (remoteLayerServerPort == MACH_PORT_NULL)
985 {
986 remoteLayerServerPort = RemoteLayerStartServer();
987 }
988 NSString *remoteLayerServerName = RemoteLayerGetServerName(remoteLayerServerPort);
989 name = (*env)->NewStringUTF(env, [remoteLayerServerName UTF8String]);
990 }
991 GLASS_POOL_EXIT;
992 GLASS_CHECK_EXCEPTION(env);
993
994 return name;
995 }
996
997 /*
998 * Class: com_sun_glass_ui_mac_MacApplication
999 * Method: staticScreen_getVideoRefreshPeriod
1000 * Signature: ()D
1001 */
1002 JNIEXPORT jdouble JNICALL
1003 Java_com_sun_glass_ui_mac_MacApplication_staticScreen_1getVideoRefreshPeriod
1004 (JNIEnv *env, jobject jApplication)
1005 {
1006 LOG("Java_com_sun_glass_ui_mac_MacApplication__1getVideoRefreshPeriod");
1007
1008 if (GlassDisplayLink != NULL)
1009 {
1010 double outRefresh = CVDisplayLinkGetActualOutputVideoRefreshPeriod(GlassDisplayLink);
1011 LOG("CVDisplayLinkGetActualOutputVideoRefreshPeriod: %f", outRefresh);
1012 return (outRefresh * 1000.0); // to millis
1013 }
1014 else
1015 {
1016 return 0.0;
1017 }
1018 }
1019
1020 /*
1021 * Class: com_sun_glass_ui_mac_MacApplication
1022 * Method: staticScreen_getScreens
1023 * Signature: ()[Lcom/sun/glass/ui/Screen;
1024 */
1025 JNIEXPORT jobjectArray JNICALL Java_com_sun_glass_ui_mac_MacApplication_staticScreen_1getScreens
1026 (JNIEnv *env, jobject jApplication)
1027 {
1028 LOG("Java_com_sun_glass_ui_mac_MacApplication__1getScreens");
1029
1030 jobjectArray screenArray = nil;
1031
1032 GLASS_POOL_ENTER;
1033 {
1034 screenArray = createJavaScreens(env);
1035 }
1036 GLASS_POOL_EXIT;
1037 GLASS_CHECK_EXCEPTION(env);
1038
1039 return screenArray;
1040 }
1041
1042
1043 /*
1044 * Class: com_sun_glass_ui_mac_MacApplication
1045 * Method: _supportsSystemMenu
1046 * Signature: ()Z;
1047 */
1048 JNIEXPORT jboolean JNICALL Java_com_sun_glass_ui_mac_MacApplication__1supportsSystemMenu
1049 (JNIEnv *env, jobject japplication)
1050 {
1051 return !isEmbedded;
1052 }
1053
1054 /*
1055 * Class: com_sun_glass_ui_mac_MacApplication
1056 * Method: _hide
1057 * Signature: ()V;
1058 */
1059 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1hide
1060 (JNIEnv *env, jobject japplication)
1061 {
1062 [NSApp hide:NSApp];
1063 }
1064
1065 /*
1066 * Class: com_sun_glass_ui_mac_MacApplication
1067 * Method: _hideOtherApplications
1068 * Signature: ()V;
1069 */
1070 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1hideOtherApplications
1071 (JNIEnv *env, jobject japplication)
1072 {
1073 [NSApp hideOtherApplications:NSApp];
1074 }
1075
1076 /*
1077 * Class: com_sun_glass_ui_mac_MacApplication
1078 * Method: _unhideAllApplications
1079 * Signature: ()V;
1080 */
1081 JNIEXPORT void JNICALL Java_com_sun_glass_ui_mac_MacApplication__1unhideAllApplications
1082 (JNIEnv *env, jobject japplication)
1083 {
1084 [NSApp unhideAllApplications:NSApp];
1085 }
1086
1087 /*
1088 * Class: com_sun_glass_ui_mac_MacApplication
1089 * Method: _getDataDirectory
1090 * Signature: ()Ljava/lang/String;
1091 */
1092 JNIEXPORT jstring JNICALL Java_com_sun_glass_ui_mac_MacApplication__1getDataDirectory
1093 (JNIEnv * env, jobject japplication)
1094 {
1095 jstring string = nil;
1096
1097 GLASS_ASSERT_MAIN_JAVA_THREAD(env);
1098 GLASS_POOL_ENTER;
1099 {
1100 NSArray *paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES);
1101 if (paths && [paths count] > 0) {
1102 string = (*env)->NewStringUTF(jEnv, [[paths lastObject] UTF8String]);
1103 }
1104 }
1105 GLASS_POOL_EXIT;
1106 GLASS_CHECK_EXCEPTION(env);
1107
1108 return string;
1109 }
1110
1111 /*
1112 * Class: com_sun_glass_ui_mac_MacApplication
1113 * Method: _getMacKey
1114 * Signature: (I)I
1115 */
1116 JNIEXPORT jint JNICALL Java_com_sun_glass_ui_mac_MacApplication__1getMacKey
1117 (JNIEnv *env, jclass jClass, jint code)
1118 {
1119 unsigned short macCode = 0;
1120 GetMacKey(code, &macCode);
1121 return (macCode & 0xFFFF);
1122 }