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 <dlfcn.h>
  27 #import <pthread.h>
  28 #import <objc/runtime.h>
  29 #import <Cocoa/Cocoa.h>
  30 #import <Security/AuthSession.h>
  31 #import <JavaNativeFoundation/JavaNativeFoundation.h>
  32 #import <JavaRuntimeSupport/JavaRuntimeSupport.h>
  33 
  34 #include "jni_util.h"
  35 #import "CMenuBar.h"
  36 #import "InitIDs.h"
  37 #import "LWCToolkit.h"
  38 #import "ThreadUtilities.h"
  39 #import "AWT_debug.h"
  40 #import "CSystemColors.h"
  41 #import  "NSApplicationAWT.h"
  42 #import "PropertiesUtilities.h"
  43 #import "ApplicationDelegate.h"
  44 
  45 #import "sun_lwawt_macosx_LWCToolkit.h"
  46 
  47 #import "sizecalc.h"
  48 


  49 int gNumberOfButtons;
  50 jint* gButtonDownMasks;
  51 
  52 // Indicates that the app has been started with -XstartOnFirstThread
  53 // (directly or via WebStart settings), and AWT should not run its
  54 // own event loop in this mode. Even if a loop isn't running yet,
  55 // we expect an embedder (e.g. SWT) to start it some time later.
  56 static BOOL forceEmbeddedMode = NO;
  57 
  58 // Indicates if awt toolkit is embedded into another UI toolkit
  59 static BOOL isEmbedded = NO;
  60 
  61 // This is the data necessary to have JNI_OnLoad wait for AppKit to start.
  62 static BOOL sAppKitStarted = NO;
  63 static pthread_mutex_t sAppKitStarted_mutex = PTHREAD_MUTEX_INITIALIZER;
  64 static pthread_cond_t sAppKitStarted_cv = PTHREAD_COND_INITIALIZER;
  65 
  66 @implementation AWTToolkit
  67 
  68 static long eventCount;
  69 
  70 + (long) getEventCount{
  71     return eventCount;
  72 }
  73 
  74 + (void) eventCountPlusPlus{
  75     eventCount++;
  76 }
  77 
  78 @end
  79 
  80 
  81 @interface AWTRunLoopObject : NSObject {
  82     BOOL _shouldEndRunLoop;
  83 }
  84 @end
  85 
  86 @implementation AWTRunLoopObject
  87 
  88 - (id) init {
  89     self = [super init];
  90     if (self != nil) {
  91         _shouldEndRunLoop = NO;
  92     }
  93     return self;
  94 }
  95 
  96 - (BOOL) shouldEndRunLoop {
  97     return _shouldEndRunLoop;
  98 }
  99 
 100 - (void) endRunLoop {
 101     _shouldEndRunLoop = YES;
 102 }
 103 
 104 @end
 105 
 106 @interface JavaRunnable : NSObject { }
 107 @property jobject runnable;
 108 - (id)initWithRunnable:(jobject)gRunnable;
 109 - (void)perform;
 110 @end
 111 
 112 @implementation JavaRunnable
 113 @synthesize runnable = _runnable;
 114 
 115 - (id)initWithRunnable:(jobject)gRunnable {
 116     if (self = [super init]) {
 117         self.runnable = gRunnable;
 118     }
 119     return self;
 120 }
 121 
 122 - (void)dealloc {
 123     JNIEnv *env = [ThreadUtilities getJNIEnv];
 124     if (self.runnable) {
 125         (*env)->DeleteGlobalRef(env, self.runnable);
 126     }
 127     [super dealloc];
 128 }
 129 
 130 - (void)perform {
 131     JNIEnv* env = [ThreadUtilities getJNIEnv];
 132     static JNF_CLASS_CACHE(sjc_Runnable, "java/lang/Runnable");
 133     static JNF_MEMBER_CACHE(jm_Runnable_run, sjc_Runnable, "run", "()V");
 134     JNFCallVoidMethod(env, self.runnable, jm_Runnable_run);
 135     [self release];
 136 }
 137 @end
 138 
 139 void setBusy(BOOL busy) {
 140     AWT_ASSERT_APPKIT_THREAD;
 141 
 142     JNIEnv *env = [ThreadUtilities getJNIEnv];
 143     static JNF_CLASS_CACHE(jc_AWTAutoShutdown, "sun/awt/AWTAutoShutdown");
 144 
 145     if (busy) {
 146         static JNF_STATIC_MEMBER_CACHE(jm_notifyBusyMethod, jc_AWTAutoShutdown, "notifyToolkitThreadBusy", "()V");
 147         JNFCallStaticVoidMethod(env, jm_notifyBusyMethod);
 148     } else {
 149         static JNF_STATIC_MEMBER_CACHE(jm_notifyFreeMethod, jc_AWTAutoShutdown, "notifyToolkitThreadFree", "()V");
 150         JNFCallStaticVoidMethod(env, jm_notifyFreeMethod);
 151     }
 152 }
 153 
 154 static void setUpAWTAppKit(BOOL installObservers)
 155 {
 156     if (installObservers) {
 157         AWT_STARTUP_LOG(@"Setting up busy observers");
 158 
 159         // Add CFRunLoopObservers to call into AWT so that AWT knows that the
 160         //  AWT thread (which is the AppKit main thread) is alive. This way AWT
 161         //  will not automatically shutdown.
 162         CFRunLoopObserverRef busyObserver = CFRunLoopObserverCreateWithHandler(
 163                                                NULL,                        // CFAllocator
 164                                                kCFRunLoopAfterWaiting,      // CFOptionFlags
 165                                                true,                        // repeats
 166                                                NSIntegerMax,                // order
 167                                                ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
 168                                                    setBusy(YES);
 169                                                });
 170 
 171         CFRunLoopObserverRef notBusyObserver = CFRunLoopObserverCreateWithHandler(
 172                                                 NULL,                        // CFAllocator
 173                                                 kCFRunLoopBeforeWaiting,     // CFOptionFlags
 174                                                 true,                        // repeats
 175                                                 NSIntegerMin,                // order
 176                                                 ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) {
 177                                                     setBusy(NO);
 178                                                 });
 179 
 180         CFRunLoopRef runLoop = [[NSRunLoop currentRunLoop] getCFRunLoop];
 181         CFRunLoopAddObserver(runLoop, busyObserver, kCFRunLoopDefaultMode);
 182         CFRunLoopAddObserver(runLoop, notBusyObserver, kCFRunLoopDefaultMode);
 183 
 184         CFRelease(busyObserver);
 185         CFRelease(notBusyObserver);
 186 
 187         setBusy(YES);
 188     }
 189 
 190     JNIEnv* env = [ThreadUtilities getJNIEnv];
 191     static JNF_CLASS_CACHE(jc_LWCToolkit, "sun/lwawt/macosx/LWCToolkit");
 192     static JNF_STATIC_MEMBER_CACHE(jsm_installToolkitThreadInJava, jc_LWCToolkit, "installToolkitThreadInJava", "()V");
 193     JNFCallStaticVoidMethod(env, jsm_installToolkitThreadInJava);
 194 }
 195 
 196 BOOL isSWTInWebStart(JNIEnv* env) {
 197     NSString *swtWebStart = [PropertiesUtilities javaSystemPropertyForKey:@"com.apple.javaws.usingSWT" withEnv:env];
 198     return [@"true" isCaseInsensitiveLike:swtWebStart];
 199 }
 200 
 201 static void AWT_NSUncaughtExceptionHandler(NSException *exception) {
 202     NSLog(@"Apple AWT Internal Exception: %@", [exception description]);
 203 }
 204 
 205 @interface AWTStarter : NSObject
 206 + (void)start:(BOOL)headless;
 207 + (void)starter:(BOOL)onMainThread headless:(BOOL)headless;
 208 + (void)appKitIsRunning:(id)arg;
 209 @end
 210 
 211 @implementation AWTStarter
 212 
 213 + (BOOL) isConnectedToWindowServer {
 214     SecuritySessionId session_id;
 215     SessionAttributeBits session_info;
 216     OSStatus status = SessionGetInfo(callerSecuritySession, &session_id, &session_info);
 217     if (status != noErr) return NO;
 218     if (!(session_info & sessionHasGraphicAccess)) return NO;
 219     return YES;
 220 }
 221 
 222 + (BOOL) markAppAsDaemon {
 223     id jrsAppKitAWTClass = objc_getClass("JRSAppKitAWT");
 224     SEL markAppSel = @selector(markAppIsDaemon);
 225     if (![jrsAppKitAWTClass respondsToSelector:markAppSel]) return NO;
 226     return [jrsAppKitAWTClass performSelector:markAppSel] ? YES : NO;
 227 }
 228 
 229 + (void)appKitIsRunning:(id)arg {
 230     AWT_ASSERT_APPKIT_THREAD;
 231     AWT_STARTUP_LOG(@"About to message AppKit started");
 232 
 233     // Signal that AppKit has started (or is already running).
 234     pthread_mutex_lock(&sAppKitStarted_mutex);
 235     sAppKitStarted = YES;
 236     pthread_cond_signal(&sAppKitStarted_cv);
 237     pthread_mutex_unlock(&sAppKitStarted_mutex);
 238 
 239     AWT_STARTUP_LOG(@"Finished messaging AppKit started");
 240 }
 241 
 242 + (void)start:(BOOL)headless
 243 {
 244     // onMainThread is NOT the same at SWT mode!
 245     // If the JVM was started on the first thread for SWT, but the SWT loads the AWT on a secondary thread,
 246     // onMainThread here will be false but SWT mode will be true.  If we are currently on the main thread, we don't
 247     // need to throw AWT startup over to another thread.
 248     BOOL onMainThread = [NSThread isMainThread];
 249 
 250     NSString* msg = [NSString stringWithFormat:@"+[AWTStarter start headless:%d] { onMainThread:%d }", headless, onMainThread];
 251     AWT_STARTUP_LOG(msg);
 252 
 253     if (!headless)
 254     {
 255         // Listen for the NSApp to start. This indicates that JNI_OnLoad can proceed.
 256         //  It must wait because there is a chance that another java thread will grab
 257         //  the AppKit lock before the +[NSApplication sharedApplication] returns.
 258         //  See <rdar://problem/3492666> for an example.
 259         [[NSNotificationCenter defaultCenter] addObserver:[AWTStarter class]
 260                                                  selector:@selector(appKitIsRunning:)
 261                                                      name:NSApplicationDidFinishLaunchingNotification
 262                                                    object:nil];
 263 
 264         AWT_STARTUP_LOG(@"+[AWTStarter start:::]: registered NSApplicationDidFinishLaunchingNotification");
 265     }
 266 
 267     [ThreadUtilities performOnMainThreadWaiting:NO block:^() {
 268         [AWTStarter starter:onMainThread headless:headless];
 269     }];
 270 
 271 
 272     if (!headless && !onMainThread) {
 273 
 274         AWT_STARTUP_LOG(@"about to wait on AppKit startup mutex");
 275 
 276         // Wait here for AppKit to have started (or for AWT to have been loaded into
 277         //  an already running NSApplication).
 278         pthread_mutex_lock(&sAppKitStarted_mutex);
 279         while (sAppKitStarted == NO) {
 280             pthread_cond_wait(&sAppKitStarted_cv, &sAppKitStarted_mutex);
 281         }
 282         pthread_mutex_unlock(&sAppKitStarted_mutex);
 283 
 284         // AWT gets here AFTER +[AWTStarter appKitIsRunning:] is called.
 285         AWT_STARTUP_LOG(@"got out of the AppKit startup mutex");
 286     }
 287 
 288     if (!headless) {
 289         // Don't set the delegate until the NSApplication has been created and
 290         // its finishLaunching has initialized it.
 291         //  ApplicationDelegate is the support code for com.apple.eawt.
 292         [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
 293             id<NSApplicationDelegate> delegate = [ApplicationDelegate sharedDelegate];
 294             if (delegate != nil) {
 295                 OSXAPP_SetApplicationDelegate(delegate);
 296             }
 297         }];
 298     }
 299 }
 300 
 301 + (void)starter:(BOOL)wasOnMainThread headless:(BOOL)headless {
 302     NSAutoreleasePool *pool = [NSAutoreleasePool new];
 303     // Add the exception handler of last resort
 304     NSSetUncaughtExceptionHandler(AWT_NSUncaughtExceptionHandler);
 305 
 306     // Headless mode trumps either ordinary AWT or SWT-in-AWT mode.  Declare us a daemon and return.
 307     if (headless) {
 308         // Note that we don't install run loop observers in headless mode
 309         // because we don't need them (see 7174704)
 310         if (!forceEmbeddedMode) {
 311             setUpAWTAppKit(false);
 312         }
 313         [AWTStarter markAppAsDaemon];
 314         return;
 315     }
 316 
 317     if (forceEmbeddedMode) {
 318         AWT_STARTUP_LOG(@"in SWT or SWT/WebStart mode");
 319 
 320         // Init a default NSApplication instance instead of the NSApplicationAWT.
 321         // Note that [NSApp isRunning] will return YES after that, though
 322         // this behavior isn't specified anywhere. We rely on that.
 323         NSApplicationLoad();
 324     }
 325 
 326     // This will create a NSApplicationAWT for standalone AWT programs, unless there is
 327     //  already a NSApplication instance. If there is already a NSApplication instance,
 328     //  and -[NSApplication isRunning] returns YES, AWT is embedded inside another
 329     //  AppKit Application.
 330     NSApplication *app = [NSApplicationAWT sharedApplication];
 331     isEmbedded = ![NSApp isKindOfClass:[NSApplicationAWT class]];
 332 
 333     if (!isEmbedded) {
 334         // Install run loop observers and set the AppKit Java thread name
 335         setUpAWTAppKit(true);
 336     }
 337 
 338     // AWT gets to this point BEFORE NSApplicationDidFinishLaunchingNotification is sent.
 339     if (![app isRunning]) {
 340         AWT_STARTUP_LOG(@"+[AWTStarter startAWT]: ![app isRunning]");
 341         // This is where the AWT AppKit thread parks itself to process events.
 342         [NSApplicationAWT runAWTLoopWithApp: app];
 343     } else {
 344         // We're either embedded, or showing a splash screen
 345         if (isEmbedded) {
 346             AWT_STARTUP_LOG(@"running embedded");
 347 
 348             // We don't track if the runloop is busy, so set it free to let AWT finish when it needs
 349             setBusy(NO);
 350         } else {
 351             AWT_STARTUP_LOG(@"running after showing a splash screen");
 352         }
 353 
 354         // Signal so that JNI_OnLoad can proceed.
 355         if (!wasOnMainThread) [AWTStarter appKitIsRunning:nil];
 356 
 357         // Proceed to exit this call as there is no reason to run the NSApplication event loop.
 358     }
 359 
 360     [pool drain];
 361 }
 362 
 363 @end
 364 
 365 /*
 366  * Class:     sun_lwawt_macosx_LWCToolkit
 367  * Method:    nativeSyncQueue
 368  * Signature: (J)Z
 369  */
 370 JNIEXPORT jboolean JNICALL Java_sun_lwawt_macosx_LWCToolkit_nativeSyncQueue
 371 (JNIEnv *env, jobject self, jlong timeout)
 372 {
 373     long currentEventNum = [AWTToolkit getEventCount];
 374 
 375     NSApplication* sharedApp = [NSApplication sharedApplication];
 376     if ([sharedApp isKindOfClass:[NSApplicationAWT class]]) {
 377         NSApplicationAWT* theApp = (NSApplicationAWT*)sharedApp;
 378         // We use two different API to post events to the application,
 379         //  - [NSApplication postEvent]
 380         //  - CGEventPost(), see CRobot.m
 381         // It was found that if we post an event via CGEventPost in robot and
 382         // immediately after this we will post the second event via
 383         // [NSApp postEvent] then sometimes the second event will be handled
 384         // first. The opposite isn't proved, but we use both here to be safer.
 385         [theApp postDummyEvent:false];
 386         [theApp waitForDummyEvent:timeout / 2.0];
 387         [theApp postDummyEvent:true];
 388         [theApp waitForDummyEvent:timeout / 2.0];
 389 
 390     } else {
 391         // could happen if we are embedded inside SWT application,
 392         // in this case just spin a single empty block through
 393         // the event loop to give it a chance to process pending events
 394         [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){}];
 395     }
 396 
 397     if (([AWTToolkit getEventCount] - currentEventNum) != 0) {
 398         return JNI_TRUE;
 399     }
 400 
 401     return JNI_FALSE;
 402 }
 403 
 404 /*
 405  * Class:     sun_lwawt_macosx_LWCToolkit
 406  * Method:    flushNativeSelectors
 407  * Signature: ()J
 408  */
 409 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_LWCToolkit_flushNativeSelectors
 410 (JNIEnv *env, jclass clz)
 411 {
 412 JNF_COCOA_ENTER(env);
 413         [ThreadUtilities performOnMainThreadWaiting:YES block:^(){}];
 414 JNF_COCOA_EXIT(env);
 415 }
 416 
 417 /*
 418  * Class:     sun_lwawt_macosx_LWCToolkit
 419  * Method:    beep
 420  * Signature: ()V
 421  */
 422 JNIEXPORT void JNICALL
 423 Java_sun_lwawt_macosx_LWCToolkit_beep
 424 (JNIEnv *env, jobject self)
 425 {
 426     NSBeep(); // produces both sound and visual flash, if configured in System Preferences
 427 }
 428 
 429 static UInt32 RGB(NSColor *c) {
 430     c = [c colorUsingColorSpaceName:NSCalibratedRGBColorSpace];
 431     if (c == nil)
 432     {
 433         return -1; // opaque white
 434     }
 435 
 436     CGFloat r, g, b, a;
 437     [c getRed:&r green:&g blue:&b alpha:&a];
 438 
 439     UInt32 ir = (UInt32) (r*255+0.5),
 440     ig = (UInt32) (g*255+0.5),
 441     ib = (UInt32) (b*255+0.5),
 442     ia = (UInt32) (a*255+0.5);
 443 
 444     //    NSLog(@"%@ %d, %d, %d", c, ir, ig, ib);
 445 
 446     return ((ia & 0xFF) << 24) | ((ir & 0xFF) << 16) | ((ig & 0xFF) << 8) | ((ib & 0xFF) << 0);
 447 }
 448 
 449 BOOL doLoadNativeColors(JNIEnv *env, jintArray jColors, BOOL useAppleColors) {
 450     jint len = (*env)->GetArrayLength(env, jColors);
 451 
 452     UInt32 colorsArray[len];
 453     UInt32 *colors = colorsArray;
 454 
 455     [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
 456         NSUInteger i;
 457         for (i = 0; i < len; i++) {
 458             colors[i] = RGB([CSystemColors getColor:i useAppleColor:useAppleColors]);
 459         }
 460     }];
 461 
 462     jint *_colors = (*env)->GetPrimitiveArrayCritical(env, jColors, 0);
 463     if (_colors == NULL) {
 464         return NO;
 465     }
 466     memcpy(_colors, colors, len * sizeof(UInt32));
 467     (*env)->ReleasePrimitiveArrayCritical(env, jColors, _colors, 0);
 468     return YES;
 469 }
 470 
 471 /**
 472  * Class:     sun_lwawt_macosx_LWCToolkit
 473  * Method:    loadNativeColors
 474  * Signature: ([I[I)V
 475  */
 476 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_LWCToolkit_loadNativeColors
 477 (JNIEnv *env, jobject peer, jintArray jSystemColors, jintArray jAppleColors)
 478 {
 479 JNF_COCOA_ENTER(env);
 480     if (doLoadNativeColors(env, jSystemColors, NO)) {
 481         doLoadNativeColors(env, jAppleColors, YES);
 482     }
 483 JNF_COCOA_EXIT(env);
 484 }
 485 
 486 /*
 487  * Class:     sun_lwawt_macosx_LWCToolkit
 488  * Method:    createAWTRunLoopMediator
 489  * Signature: ()J
 490  */
 491 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_LWCToolkit_createAWTRunLoopMediator
 492 (JNIEnv *env, jclass clz)
 493 {
 494 AWT_ASSERT_APPKIT_THREAD;
 495 
 496     jlong result;
 497 
 498 JNF_COCOA_ENTER(env);
 499     // We double retain because this object is owned by both main thread and "other" thread
 500     // We release in both doAWTRunLoop and stopAWTRunLoop
 501     result = ptr_to_jlong([[[AWTRunLoopObject alloc] init] retain]);
 502 JNF_COCOA_EXIT(env);
 503 
 504     return result;
 505 }
 506 
 507 /*
 508  * Class:     sun_lwawt_macosx_LWCToolkit
 509  * Method:    doAWTRunLoopImpl
 510  * Signature: (JZZ)V
 511  */
 512 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_LWCToolkit_doAWTRunLoopImpl
 513 (JNIEnv *env, jclass clz, jlong mediator, jboolean processEvents, jboolean inAWT)
 514 {
 515 AWT_ASSERT_APPKIT_THREAD;
 516 JNF_COCOA_ENTER(env);
 517 
 518     AWTRunLoopObject* mediatorObject = (AWTRunLoopObject*)jlong_to_ptr(mediator);
 519 
 520     if (mediatorObject == nil) return;
 521 
 522     // Don't use acceptInputForMode because that doesn't setup autorelease pools properly
 523     BOOL isRunning = true;
 524     while (![mediatorObject shouldEndRunLoop] && isRunning) {
 525         isRunning = [[NSRunLoop currentRunLoop] runMode:(inAWT ? [JNFRunLoop javaRunLoopMode] : NSDefaultRunLoopMode)
 526                                              beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.010]];
 527         if (processEvents) {
 528             //We do not spin a runloop here as date is nil, so does not matter which mode to use
 529             // Processing all events excluding NSApplicationDefined which need to be processed
 530             // on the main loop only (those events are intended for disposing resources)
 531             NSEvent *event;
 532             if ((event = [NSApp nextEventMatchingMask:(NSAnyEventMask & ~NSApplicationDefined)
 533                                            untilDate:nil
 534                                               inMode:NSDefaultRunLoopMode
 535                                              dequeue:YES]) != nil) {
 536                 [NSApp sendEvent:event];
 537             }
 538 
 539         }
 540     }
 541     [mediatorObject release];
 542 JNF_COCOA_EXIT(env);
 543 }
 544 
 545 /*
 546  * Class:     sun_lwawt_macosx_LWCToolkit
 547  * Method:    stopAWTRunLoop
 548  * Signature: (J)V
 549  */
 550 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_LWCToolkit_stopAWTRunLoop
 551 (JNIEnv *env, jclass clz, jlong mediator)
 552 {
 553 JNF_COCOA_ENTER(env);
 554 
 555     AWTRunLoopObject* mediatorObject = (AWTRunLoopObject*)jlong_to_ptr(mediator);
 556 
 557     [ThreadUtilities performOnMainThread:@selector(endRunLoop) on:mediatorObject withObject:nil waitUntilDone:NO];
 558 
 559     [mediatorObject release];
 560 
 561 JNF_COCOA_EXIT(env);
 562 }
 563 
 564 /*
 565  * Class:     sun_lwawt_macosx_LWCToolkit
 566  * Method:    performOnMainThreadAfterDelay
 567  * Signature: (Ljava/lang/Runnable;J)V
 568  */
 569 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_LWCToolkit_performOnMainThreadAfterDelay
 570 (JNIEnv *env, jclass clz, jobject runnable, jlong delay)
 571 {
 572 JNF_COCOA_ENTER(env);
 573     jobject gRunnable = (*env)->NewGlobalRef(env, runnable);
 574     CHECK_NULL(gRunnable);
 575     [ThreadUtilities performOnMainThreadWaiting:NO block:^() {
 576         JavaRunnable* performer = [[JavaRunnable alloc] initWithRunnable:gRunnable];
 577         [performer performSelector:@selector(perform) withObject:nil afterDelay:(delay/1000.0)];
 578     }];
 579 JNF_COCOA_EXIT(env);
 580 }
 581 
 582 
 583 /*
 584  * Class:     sun_lwawt_macosx_LWCToolkit
 585  * Method:    isCapsLockOn
 586  * Signature: ()Z
 587  */
 588 JNIEXPORT jboolean JNICALL Java_sun_lwawt_macosx_LWCToolkit_isCapsLockOn
 589 (JNIEnv *env, jobject self)
 590 {
 591     __block jboolean isOn = JNI_FALSE;
 592     [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
 593         NSUInteger modifiers = [NSEvent modifierFlags];
 594         isOn = (modifiers & NSAlphaShiftKeyMask) != 0;
 595     }];
 596 
 597     return isOn;
 598 }
 599 
 600 /*
 601  * Class:     sun_lwawt_macosx_LWCToolkit
 602  * Method:    isApplicationActive
 603  * Signature: ()Z
 604  */
 605 JNIEXPORT jboolean JNICALL Java_sun_lwawt_macosx_LWCToolkit_isApplicationActive
 606 (JNIEnv *env, jclass clazz)
 607 {
 608     __block jboolean active = JNI_FALSE;
 609 
 610 JNF_COCOA_ENTER(env);
 611 
 612     [ThreadUtilities performOnMainThreadWaiting:YES block:^() {
 613         active = (jboolean)[NSRunningApplication currentApplication].active;
 614     }];
 615 
 616 JNF_COCOA_EXIT(env);
 617 
 618     return active;
 619 }
 620 
 621 /*
 622  * Class:     sun_lwawt_macosx_LWCToolkit
 623  * Method:    activateApplicationIgnoringOtherApps
 624  * Signature: ()V
 625  */
 626 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_LWCToolkit_activateApplicationIgnoringOtherApps
 627 (JNIEnv *env, jclass clazz)
 628 {
 629     JNF_COCOA_ENTER(env);
 630     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 631         if(![NSApp isActive]){
 632             [NSApp activateIgnoringOtherApps:YES];
 633         }
 634     }];
 635     JNF_COCOA_EXIT(env);
 636 }
 637 
 638 
 639 /*
 640  * Class:     sun_awt_SunToolkit
 641  * Method:    closeSplashScreen
 642  * Signature: ()V
 643  */
 644 JNIEXPORT void JNICALL
 645 Java_sun_awt_SunToolkit_closeSplashScreen(JNIEnv *env, jclass cls)
 646 {
 647     void *hSplashLib = dlopen(0, RTLD_LAZY);
 648     if (!hSplashLib) return;
 649 
 650     void (*splashClose)() = dlsym(hSplashLib, "SplashClose");
 651     if (splashClose) {
 652         splashClose();
 653     }
 654     dlclose(hSplashLib);
 655 }
 656 
 657 
 658 // TODO: definitely doesn't belong here (copied from fontpath.c in the
 659 // solaris tree)...
 660 
 661 JNIEXPORT jstring JNICALL
 662 Java_sun_font_FontManager_getFontPath
 663 (JNIEnv *env, jclass obj, jboolean noType1)
 664 {
 665     return JNFNSToJavaString(env, @"/Library/Fonts");
 666 }
 667 
 668 // This isn't yet used on unix, the implementation is added since shared
 669 // code calls this method in preparation for future use.
 670 JNIEXPORT void JNICALL
 671 Java_sun_font_FontManager_populateFontFileNameMap
 672 (JNIEnv *env, jclass obj, jobject fontToFileMap, jobject fontToFamilyMap, jobject familyToFontListMap, jobject locale)
 673 {
 674 
 675 }
 676 
 677 /*
 678  * Class:     sun_lwawt_macosx_LWCToolkit
 679  * Method:    initIDs
 680  * Signature: ()V
 681  */
 682 JNIEXPORT void JNICALL
 683 Java_sun_lwawt_macosx_LWCToolkit_initIDs
 684 (JNIEnv *env, jclass klass) {
 685 
 686     JNF_COCOA_ENTER(env)
 687 
 688     gNumberOfButtons = sun_lwawt_macosx_LWCToolkit_BUTTONS;
 689 
 690     jclass inputEventClazz = (*env)->FindClass(env, "java/awt/event/InputEvent");
 691     CHECK_NULL(inputEventClazz);
 692     jmethodID getButtonDownMasksID = (*env)->GetStaticMethodID(env, inputEventClazz, "getButtonDownMasks", "()[I");
 693     CHECK_NULL(getButtonDownMasksID);
 694     jintArray obj = (jintArray)(*env)->CallStaticObjectMethod(env, inputEventClazz, getButtonDownMasksID);
 695     jint * tmp = (*env)->GetIntArrayElements(env, obj, JNI_FALSE);
 696     CHECK_NULL(tmp);
 697 
 698     gButtonDownMasks = (jint*)SAFE_SIZE_ARRAY_ALLOC(malloc, sizeof(jint), gNumberOfButtons);
 699     if (gButtonDownMasks == NULL) {
 700         gNumberOfButtons = 0;
 701         (*env)->ReleaseIntArrayElements(env, obj, tmp, JNI_ABORT);
 702         JNU_ThrowOutOfMemoryError(env, NULL);
 703         return;
 704     }
 705 
 706     int i;
 707     for (i = 0; i < gNumberOfButtons; i++) {
 708         gButtonDownMasks[i] = tmp[i];
 709     }
 710 
 711     (*env)->ReleaseIntArrayElements(env, obj, tmp, 0);
 712     (*env)->DeleteLocalRef(env, obj);
 713 
 714     JNF_COCOA_EXIT(env)
 715 }
 716 
 717 /*
 718  * Class:     sun_lwawt_macosx_LWCToolkit
 719  * Method:    initAppkit
 720  * Signature: (Ljava/lang/ThreadGroup;)V
 721  */
 722 JNIEXPORT void JNICALL
 723 Java_sun_lwawt_macosx_LWCToolkit_initAppkit
 724 (JNIEnv *env, jclass klass, jobject appkitThreadGroup, jboolean headless) {
 725     JNF_COCOA_ENTER(env)
 726 
 727     [ThreadUtilities setAppkitThreadGroup:(*env)->NewGlobalRef(env, appkitThreadGroup)];
 728 
 729     // Launcher sets this env variable if -XstartOnFirstThread is specified
 730     char envVar[80];
 731     snprintf(envVar, sizeof(envVar), "JAVA_STARTED_ON_FIRST_THREAD_%d", getpid());
 732     if (getenv(envVar) != NULL) {
 733         forceEmbeddedMode = YES;
 734         unsetenv(envVar);
 735     }
 736 
 737     if (isSWTInWebStart(env)) {
 738         forceEmbeddedMode = YES;
 739     }
 740 
 741     [AWTStarter start:headless ? YES : NO];
 742 
 743     JNF_COCOA_EXIT(env)
 744 }
 745 
 746 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
 747     OSXAPP_SetJavaVM(vm);
 748 
 749     // We need to let Foundation know that this is a multithreaded application, if it isn't already.
 750     if (![NSThread isMultiThreaded]) {
 751         [NSThread detachNewThreadSelector:nil toTarget:nil withObject:nil];
 752     }
 753 
 754     return JNI_VERSION_1_4;
 755 }
 756 
 757 /*
 758  * Class:     sun_lwawt_macosx_LWCToolkit
 759  * Method:    isEmbedded
 760  * Signature: ()Z
 761  */
 762 JNIEXPORT jboolean JNICALL
 763 Java_sun_lwawt_macosx_LWCToolkit_isEmbedded
 764 (JNIEnv *env, jclass klass) {
 765     return isEmbedded ? JNI_TRUE : JNI_FALSE;
 766 }
 767 
--- EOF ---