1 /*
   2  * Copyright (c) 2011, 2016, 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 "ApplicationDelegate.h"
  27 
  28 #import "com_apple_eawt_Application.h"
  29 #import "com_apple_eawt__AppDockIconHandler.h"
  30 #import "com_apple_eawt__AppEventHandler.h"
  31 #import "com_apple_eawt__AppMenuBarHandler.h"
  32 #import "com_apple_eawt__AppMenuBarHandler.h"
  33 #import "com_apple_eawt__AppMiscHandlers.h"
  34 
  35 #import <JavaNativeFoundation/JavaNativeFoundation.h>
  36 
  37 #import "CPopupMenu.h"
  38 #import "ThreadUtilities.h"
  39 #import "NSApplicationAWT.h"
  40 
  41 
  42 #pragma mark App Menu helpers
  43 
  44 // The following is a AWT convention?
  45 #define PREFERENCES_TAG  42
  46 
  47 static void addMenuItem(NSMenuItem* menuItem, NSInteger index) {
  48 AWT_ASSERT_APPKIT_THREAD;
  49 
  50     NSMenu *menuBar = [[NSApplication sharedApplication] mainMenu];
  51     NSMenu *appMenu = [[menuBar itemAtIndex:0] submenu];
  52 
  53     [appMenu insertItem:menuItem atIndex:index];
  54     [appMenu insertItem:[NSMenuItem separatorItem] atIndex:index + 1]; // Add the following separator
  55 }
  56 
  57 static void removeMenuItem(NSMenuItem* menuItem) {
  58 AWT_ASSERT_APPKIT_THREAD;
  59 
  60     NSMenu *menuBar = [[NSApplication sharedApplication] mainMenu];
  61     NSMenu *appMenu = [[menuBar itemAtIndex:0] submenu];
  62 
  63     NSInteger index = [appMenu indexOfItem:menuItem];
  64     if (index < 0) return; // something went wrong
  65 
  66     [appMenu removeItemAtIndex:index + 1]; // Get the following separator
  67     [appMenu removeItem:menuItem];
  68 }
  69 
  70 @interface NSBundle (EAWTOverrides)
  71 - (BOOL)_hasEAWTOverride:(NSString *)key;
  72 @end
  73 
  74 
  75 @implementation NSBundle (EAWTOverrides)
  76 
  77 - (BOOL)_hasEAWTOverride:(NSString *)key {
  78     return [[[[self objectForInfoDictionaryKey:@"Java"] objectForKey:@"EAWTOverride"] objectForKey:key] boolValue];
  79 }
  80 
  81 @end
  82 
  83 
  84 // used by JavaRuntimeSupport.framework's [JRSAppKitAWT awtAppDelegate]
  85 // to expose our app delegate to the SWT or other apps that have knoledge
  86 // of Java's AWT and want to install their own app delegate that will delegate
  87 // to the AWT for some operations
  88 
  89 @interface JavaAWTAppDelegateLoader : NSObject { }
  90 @end
  91 
  92 @implementation JavaAWTAppDelegateLoader
  93 + (ApplicationDelegate *) awtAppDelegate {
  94     return [ApplicationDelegate sharedDelegate];
  95 }
  96 @end
  97 
  98 
  99 @implementation ApplicationDelegate
 100 
 101 @synthesize fPreferencesMenu;
 102 @synthesize fAboutMenu;
 103 @synthesize fProgressIndicator;
 104 
 105 @synthesize fDockMenu;
 106 @synthesize fDefaultMenuBar;
 107 
 108 
 109 + (ApplicationDelegate *)sharedDelegate {
 110     static ApplicationDelegate *sApplicationDelegate = nil;
 111     static BOOL checked = NO;
 112 
 113     if (sApplicationDelegate != nil) return sApplicationDelegate;
 114     if (checked) return nil;
 115 
 116 AWT_ASSERT_APPKIT_THREAD;
 117 
 118     // don't install the EAWT delegate if another kind of NSApplication is installed, like say, Safari
 119     BOOL shouldInstall = NO;
 120     if (NSApp != nil) {
 121         if ([NSApp isMemberOfClass:[NSApplication class]]) shouldInstall = YES;
 122         if ([NSApp isKindOfClass:[NSApplicationAWT class]]) shouldInstall = YES;
 123     }
 124     checked = YES;
 125     if (!shouldInstall) return nil;
 126 
 127     sApplicationDelegate = [[ApplicationDelegate alloc] init];
 128     return sApplicationDelegate;
 129 }
 130 
 131 - (void)_updatePreferencesMenu:(BOOL)prefsAvailable enabled:(BOOL)prefsEnabled {
 132 AWT_ASSERT_APPKIT_THREAD;
 133 
 134     if (prefsAvailable) {
 135         // Make sure Prefs is around
 136         if ([self.fPreferencesMenu menu] == nil) {
 137             // Position of Prefs depends upon About availability.
 138             NSInteger index = ([self.fAboutMenu menu] != nil) ? 2 : 0;
 139 
 140             addMenuItem(self.fPreferencesMenu, index);
 141         }
 142 
 143         if (prefsEnabled) {
 144             [self.fPreferencesMenu setEnabled:YES];
 145             [self.fPreferencesMenu setTarget:self];
 146             [self.fPreferencesMenu setAction:@selector(_preferencesMenuHandler)];
 147         } else {
 148             [self.fPreferencesMenu setEnabled:NO];
 149             [self.fPreferencesMenu setTarget:nil];
 150             [self.fPreferencesMenu setAction:nil];
 151         }
 152     } else {
 153         if ([self.fPreferencesMenu menu] == nil) return;
 154 
 155         // Remove the preferences item
 156         removeMenuItem(self.fPreferencesMenu);
 157     }
 158 }
 159 
 160 - (void)_updateAboutMenu:(BOOL)aboutAvailable enabled:(BOOL)aboutEnabled {
 161 AWT_ASSERT_APPKIT_THREAD;
 162 
 163     if (aboutAvailable) {
 164         // Make sure About is around
 165         if ([self.fAboutMenu menu] == nil) {
 166             addMenuItem(self.fAboutMenu, 0);
 167         }
 168 
 169         if (aboutEnabled) {
 170             [self.fAboutMenu setEnabled:YES];
 171             [self.fAboutMenu setTarget:self];
 172             [self.fAboutMenu setAction:@selector(_aboutMenuHandler)];
 173         } else {
 174             [self.fAboutMenu setEnabled:NO];
 175             [self.fAboutMenu setTarget:nil];
 176             [self.fAboutMenu setAction:nil];
 177         }
 178     } else {
 179         if ([self.fAboutMenu menu] == nil) return;
 180 
 181         // Remove About item.
 182         removeMenuItem(self.fAboutMenu);
 183     }
 184 }
 185 
 186 - (id) init {
 187 AWT_ASSERT_APPKIT_THREAD;
 188 
 189     self = [super init];
 190     if (!self) return self;
 191 
 192     // Prep for about and preferences menu
 193     BOOL usingDefaultNib = YES;
 194     if ([NSApp isKindOfClass:[NSApplicationAWT class]]) {
 195         usingDefaultNib = [NSApp usingDefaultNib];
 196     }
 197     if (!usingDefaultNib) return self;
 198 
 199     NSMenu *menuBar = [[NSApplication sharedApplication] mainMenu];
 200     NSMenu *appMenu = [[menuBar itemAtIndex:0] submenu];
 201 
 202     self.fPreferencesMenu = (NSMenuItem*)[appMenu itemWithTag:PREFERENCES_TAG];
 203     self.fAboutMenu = (NSMenuItem*)[appMenu itemAtIndex:0];
 204     
 205     NSDockTile *dockTile = [NSApp dockTile];
 206     self.fProgressIndicator = [[NSProgressIndicator alloc]
 207                                 initWithFrame:NSMakeRect(3.f, 0.f, dockTile.size.width - 6.f, 20.f)];
 208     
 209     [fProgressIndicator setStyle:NSProgressIndicatorBarStyle];
 210     [fProgressIndicator setIndeterminate:NO];
 211     [[dockTile contentView] addSubview:fProgressIndicator];
 212     [fProgressIndicator setMinValue:0];
 213     [fProgressIndicator setMaxValue:100];
 214     [fProgressIndicator setHidden:YES];
 215     [fProgressIndicator release];
 216 
 217     // If the java application has a bundle with an Info.plist file with
 218     //  a CFBundleDocumentTypes entry, then it is set up to handle Open Doc
 219     //  and Print Doc commands for these files. Therefore java AWT will
 220     //  cache Open Doc and Print Doc events that are sent prior to a
 221     //  listener being installed by the client java application.
 222     NSBundle *bundle = [NSBundle mainBundle];
 223     fHandlesDocumentTypes = [bundle objectForInfoDictionaryKey:@"CFBundleDocumentTypes"] != nil || [bundle _hasEAWTOverride:@"DocumentHandler"];
 224     fHandlesURLTypes = [bundle objectForInfoDictionaryKey:@"CFBundleURLTypes"] != nil || [bundle _hasEAWTOverride:@"URLHandler"];
 225     if (fHandlesURLTypes) {
 226         [[NSAppleEventManager sharedAppleEventManager] setEventHandler:self
 227                                                            andSelector:@selector(_handleOpenURLEvent:withReplyEvent:)
 228                                                          forEventClass:kInternetEventClass
 229                                                             andEventID:kAEGetURL];
 230     }
 231 
 232     // By HIG, Preferences are not available unless there is a handler. By default in Mac OS X,
 233     //  there is not a handler, but it is in the nib file for convenience.
 234     removeMenuItem(self.fPreferencesMenu);
 235 
 236     [self _updateAboutMenu:YES enabled:YES];
 237 
 238     // Now that the AppKit objects are known and set up, initialize the model data
 239     BOOL aboutAvailable = ([self.fAboutMenu menu] != nil);
 240     BOOL aboutEnabled = (aboutAvailable && [self.fAboutMenu isEnabled] && ([self.fAboutMenu target] != nil));
 241 
 242     BOOL prefsAvailable = ([self.fPreferencesMenu menu] != nil);
 243     BOOL prefsEnabled = (prefsAvailable && [self.fPreferencesMenu isEnabled] && ([self.fPreferencesMenu target] != nil));
 244 
 245     JNIEnv *env = [ThreadUtilities getJNIEnv];
 246     static JNF_CLASS_CACHE(sjc_AppMenuBarHandler, "com/apple/eawt/_AppMenuBarHandler");
 247     static JNF_STATIC_MEMBER_CACHE(sjm_initMenuStates, sjc_AppMenuBarHandler, "initMenuStates", "(ZZZZ)V");
 248     JNFCallStaticVoidMethod(env, sjm_initMenuStates, aboutAvailable, aboutEnabled, prefsAvailable, prefsEnabled);
 249 
 250     // register for the finish launching and system power off notifications by default
 251     NSNotificationCenter *ctr = [NSNotificationCenter defaultCenter];
 252     Class clz = [ApplicationDelegate class];
 253     [ctr addObserver:clz selector:@selector(_willFinishLaunching) name:NSApplicationWillFinishLaunchingNotification object:nil];
 254     [ctr addObserver:clz selector:@selector(_systemWillPowerOff) name:NSWorkspaceWillPowerOffNotification object:nil];
 255     [ctr addObserver:clz selector:@selector(_appDidActivate) name:NSApplicationDidBecomeActiveNotification object:nil];
 256     [ctr addObserver:clz selector:@selector(_appDidDeactivate) name:NSApplicationDidResignActiveNotification object:nil];
 257     [ctr addObserver:clz selector:@selector(_appDidHide) name:NSApplicationDidHideNotification object:nil];
 258     [ctr addObserver:clz selector:@selector(_appDidUnhide) name:NSApplicationDidUnhideNotification object:nil];
 259 
 260     return self;
 261 }
 262 
 263 - (void)dealloc {
 264     self.fPreferencesMenu = nil;
 265     self.fAboutMenu = nil;
 266     self.fDockMenu = nil;
 267     self.fDefaultMenuBar = nil;
 268     self.fProgressIndicator = nil;
 269 
 270     [super dealloc];
 271 }
 272 
 273 #pragma mark Callbacks from AppKit
 274 
 275 static JNF_CLASS_CACHE(sjc_AppEventHandler, "com/apple/eawt/_AppEventHandler");
 276 
 277 - (void)_handleOpenURLEvent:(NSAppleEventDescriptor *)openURLEvent withReplyEvent:(NSAppleEventDescriptor *)replyEvent {
 278 AWT_ASSERT_APPKIT_THREAD;
 279     if (!fHandlesURLTypes) return;
 280 
 281     NSString *url = [[openURLEvent paramDescriptorForKeyword:keyDirectObject] stringValue];
 282 
 283     //fprintf(stderr,"jm_handleOpenURL\n");
 284     JNIEnv *env = [ThreadUtilities getJNIEnv];
 285     jstring jURL = JNFNSToJavaString(env, url);
 286     static JNF_STATIC_MEMBER_CACHE(jm_handleOpenURI, sjc_AppEventHandler, "handleOpenURI", "(Ljava/lang/String;)V");
 287     JNFCallStaticVoidMethod(env, jm_handleOpenURI, jURL); // AWT_THREADING Safe (event)
 288     (*env)->DeleteLocalRef(env, jURL);
 289 
 290     [replyEvent insertDescriptor:[NSAppleEventDescriptor nullDescriptor] atIndex:0];
 291 }
 292 
 293 // Helper for both open file and print file methods
 294 // Creates a Java list of files from a native list of files
 295 - (jobject)_createFilePathArrayFrom:(NSArray *)filenames withEnv:(JNIEnv *)env {
 296     static JNF_CLASS_CACHE(sjc_ArrayList, "java/util/ArrayList");
 297     static JNF_CTOR_CACHE(jm_ArrayList_ctor, sjc_ArrayList, "(I)V");
 298     static JNF_MEMBER_CACHE(jm_ArrayList_add, sjc_ArrayList, "add", "(Ljava/lang/Object;)Z");
 299 
 300     jobject jFileNamesArray = JNFNewObject(env, jm_ArrayList_ctor, (jint)[filenames count]); // AWT_THREADING Safe (known object)
 301     for (NSString *filename in filenames) {
 302         jstring jFileName = JNFNormalizedJavaStringForPath(env, filename);
 303         JNFCallVoidMethod(env, jFileNamesArray, jm_ArrayList_add, jFileName);
 304     }
 305 
 306     return jFileNamesArray;
 307 }
 308 
 309 // Open file handler
 310 - (void)application:(NSApplication *)theApplication openFiles:(NSArray *)fileNames {
 311 AWT_ASSERT_APPKIT_THREAD;
 312     if (!fHandlesDocumentTypes) {
 313         [theApplication replyToOpenOrPrint:NSApplicationDelegateReplyCancel];
 314         return;
 315     }
 316 
 317     //fprintf(stderr,"jm_handleOpenFile\n");
 318     JNIEnv *env = [ThreadUtilities getJNIEnv];
 319 
 320     // if these files were opened from a Spotlight query, try to get the search text from the current AppleEvent
 321     NSAppleEventDescriptor *currentEvent = [[NSAppleEventManager sharedAppleEventManager] currentAppleEvent];
 322     NSString *searchString = [[currentEvent paramDescriptorForKeyword:keyAESearchText] stringValue];
 323     jstring jSearchString = JNFNSToJavaString(env, searchString);
 324 
 325     // convert the file names array
 326     jobject jFileNamesArray = [self _createFilePathArrayFrom:fileNames withEnv:env];
 327 
 328     static JNF_STATIC_MEMBER_CACHE(jm_handleOpenFiles, sjc_AppEventHandler, "handleOpenFiles", "(Ljava/util/List;Ljava/lang/String;)V");
 329     JNFCallStaticVoidMethod(env, jm_handleOpenFiles, jFileNamesArray, jSearchString);
 330     (*env)->DeleteLocalRef(env, jFileNamesArray);
 331     (*env)->DeleteLocalRef(env, jSearchString);
 332 
 333     [theApplication replyToOpenOrPrint:NSApplicationDelegateReplySuccess];
 334 }
 335 
 336 // Print handler
 337 - (NSApplicationPrintReply)application:(NSApplication *)application printFiles:(NSArray *)fileNames withSettings:(NSDictionary *)printSettings showPrintPanels:(BOOL)showPrintPanels {
 338 AWT_ASSERT_APPKIT_THREAD;
 339     if (!fHandlesDocumentTypes) return NSPrintingCancelled;
 340 
 341     //fprintf(stderr,"jm_handlePrintFile\n");
 342     JNIEnv *env = [ThreadUtilities getJNIEnv];
 343     jobject jFileNamesArray = [self _createFilePathArrayFrom:fileNames withEnv:env];
 344     static JNF_STATIC_MEMBER_CACHE(jm_handlePrintFile, sjc_AppEventHandler, "handlePrintFiles", "(Ljava/util/List;)V");
 345     JNFCallStaticVoidMethod(env, jm_handlePrintFile, jFileNamesArray); // AWT_THREADING Safe (event)
 346     (*env)->DeleteLocalRef(env, jFileNamesArray);
 347 
 348     return NSPrintingSuccess;
 349 }
 350 
 351 // Open app handler, registered in -init
 352 + (void)_notifyJava:(jint)notificationType {
 353 AWT_ASSERT_APPKIT_THREAD;
 354 
 355     //fprintf(stderr,"jm_handleOpenApplication\n");
 356     JNIEnv *env = [ThreadUtilities getJNIEnv];
 357     static JNF_STATIC_MEMBER_CACHE(jm_handleNativeNotification, sjc_AppEventHandler, "handleNativeNotification", "(I)V");
 358     JNFCallStaticVoidMethod(env, jm_handleNativeNotification, notificationType); // AWT_THREADING Safe (event)
 359 }
 360 
 361 // About menu handler
 362 - (void)_aboutMenuHandler {
 363     [ApplicationDelegate _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_ABOUT];
 364 }
 365 
 366 // Preferences handler
 367 - (void)_preferencesMenuHandler {
 368     [ApplicationDelegate _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_PREFS];
 369 }
 370 
 371 // Open app handler, registered in -init
 372 + (void)_willFinishLaunching {
 373     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_OPEN_APP];
 374 }
 375 
 376 // ReOpen app handler
 377 - (BOOL)applicationShouldHandleReopen:(NSApplication *)theApplication hasVisibleWindows:(BOOL)flag {
 378     [ApplicationDelegate _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_REOPEN_APP];
 379     return YES;
 380 }
 381 
 382 // Quit handler
 383 - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)app {
 384     [ApplicationDelegate _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_QUIT];
 385     return NSTerminateLater;
 386 }
 387 
 388 + (void)_systemWillPowerOff {
 389     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_SHUTDOWN];
 390 }
 391 
 392 + (void)_appDidActivate {
 393     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_ACTIVE_APP_GAINED];
 394 }
 395 
 396 + (void)_appDidDeactivate {
 397     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_ACTIVE_APP_LOST];
 398 }
 399 
 400 + (void)_appDidHide {
 401     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_APP_HIDDEN];
 402 }
 403 
 404 + (void)_appDidUnhide {
 405     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_APP_SHOWN];
 406 }
 407 
 408 + (void)_sessionDidActivate {
 409     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_USER_SESSION_ACTIVE];
 410 }
 411 
 412 + (void)_sessionDidDeactivate {
 413     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_USER_SESSION_INACTIVE];
 414 }
 415 
 416 + (void)_screenDidSleep {
 417     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_SCREEN_SLEEP];
 418 }
 419 
 420 + (void)_screenDidWake {
 421     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_SCREEN_WAKE];
 422 }
 423 
 424 + (void)_systemDidSleep {
 425     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_SYSTEM_SLEEP];
 426 }
 427 
 428 + (void)_systemDidWake {
 429     [self _notifyJava:com_apple_eawt__AppEventHandler_NOTIFY_SYSTEM_WAKE];
 430 }
 431 
 432 + (void)_registerForNotification:(NSNumber *)notificationTypeNum {
 433     NSNotificationCenter *ctr = [[NSWorkspace sharedWorkspace] notificationCenter];
 434     Class clz = [ApplicationDelegate class];
 435 
 436     jint notificationType = [notificationTypeNum intValue];
 437     switch (notificationType) {
 438         case com_apple_eawt__AppEventHandler_REGISTER_USER_SESSION:
 439             [ctr addObserver:clz selector:@selector(_sessionDidActivate) name:NSWorkspaceSessionDidBecomeActiveNotification object:nil];
 440             [ctr addObserver:clz selector:@selector(_sessionDidDeactivate) name:NSWorkspaceSessionDidResignActiveNotification object:nil];
 441             break;
 442         case com_apple_eawt__AppEventHandler_REGISTER_SCREEN_SLEEP:
 443             [ctr addObserver:clz selector:@selector(_screenDidSleep) name:NSWorkspaceScreensDidSleepNotification object:nil];
 444             [ctr addObserver:clz selector:@selector(_screenDidWake) name:NSWorkspaceScreensDidWakeNotification object:nil];
 445             break;
 446         case com_apple_eawt__AppEventHandler_REGISTER_SYSTEM_SLEEP:
 447             [ctr addObserver:clz selector:@selector(_systemDidSleep) name:NSWorkspaceWillSleepNotification object:nil];
 448             [ctr addObserver:clz selector:@selector(_systemDidWake) name:NSWorkspaceDidWakeNotification object:nil];
 449             break;
 450         default:
 451             NSLog(@"EAWT attempting to register for unknown notification: %d", (int)notificationType);
 452             break;
 453     }
 454 }
 455 
 456 // Retrieves the menu to be attached to the Dock icon (AppKit callback)
 457 - (NSMenu *)applicationDockMenu:(NSApplication *)sender {
 458 AWT_ASSERT_APPKIT_THREAD;
 459     return self.fDockMenu;
 460 }
 461 
 462 - (CMenuBar *)defaultMenuBar {
 463     return [[self.fDefaultMenuBar retain] autorelease];
 464 }
 465 
 466 
 467 #pragma mark Helpers called on the main thread from Java
 468 
 469 // Sets a new NSImageView on the Dock tile
 470 + (void)_setDockIconImage:(NSImage *)image {
 471 AWT_ASSERT_APPKIT_THREAD;
 472 
 473     NSDockTile *dockTile = [NSApp dockTile];
 474     if (image == nil) {
 475         [dockTile setContentView:nil];
 476         return;
 477     }
 478 
 479     // setup an image view for the dock tile
 480     NSRect frame = NSMakeRect(0, 0, dockTile.size.width, dockTile.size.height);
 481     NSImageView *dockImageView = [[NSImageView alloc] initWithFrame: frame];
 482     [dockImageView setImageScaling:NSImageScaleProportionallyUpOrDown];
 483     [dockImageView setImage:image];
 484 
 485     [[ApplicationDelegate sharedDelegate].fProgressIndicator removeFromSuperview];
 486     [dockImageView addSubview:[ApplicationDelegate sharedDelegate].fProgressIndicator];
 487 
 488     // add it to the NSDockTile
 489     [dockTile setContentView: dockImageView];
 490     [dockTile display];
 491 
 492     [dockImageView release];
 493 }
 494 
 495 + (void)_setDockIconProgress:(NSNumber *)value {
 496 AWT_ASSERT_APPKIT_THREAD;
 497 
 498     ApplicationDelegate *delegate = [ApplicationDelegate sharedDelegate];
 499     if ([value doubleValue] >= 0 && [value doubleValue] <=100) {
 500         [delegate.fProgressIndicator setDoubleValue:[value doubleValue]];
 501         [delegate.fProgressIndicator setHidden:NO];
 502     } else {
 503         [delegate.fProgressIndicator setHidden:YES];
 504     }
 505 
 506     [[NSApp dockTile] display];
 507 }
 508 
 509 // Obtains the image of the Dock icon, either manually set, a drawn copy, or the default NSApplicationIcon
 510 + (NSImage *)_dockIconImage {
 511 AWT_ASSERT_APPKIT_THREAD;
 512 
 513     NSDockTile *dockTile = [NSApp dockTile];
 514     NSView *view = [dockTile contentView];
 515 
 516     if ([view isKindOfClass:[NSImageView class]]) {
 517         NSImage *img = [((NSImageView *)view) image];
 518         if (img) return img;
 519     }
 520 
 521     if (view == nil) {
 522         return [NSImage imageNamed:@"NSApplicationIcon"];
 523     }
 524 
 525     NSRect frame = [view frame];
 526     NSImage *image = [[NSImage alloc] initWithSize:frame.size];
 527     [image lockFocus];
 528     [view drawRect:frame];
 529     [image unlockFocus];
 530     [image autorelease];
 531     return image;
 532 }
 533 
 534 @end
 535 
 536 
 537 #pragma mark Native JNI calls
 538 
 539 /*
 540  * Class:     com_apple_eawt_Application
 541  * Method:    nativeInitializeApplicationDelegate
 542  * Signature: ()V
 543  */
 544 JNIEXPORT void JNICALL Java_com_apple_eawt_Application_nativeInitializeApplicationDelegate
 545 (JNIEnv *env, jclass clz)
 546 {
 547 JNF_COCOA_ENTER(env);
 548     // Force initialization to happen on AppKit thread!
 549     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 550         [ApplicationDelegate sharedDelegate];
 551     }];
 552 JNF_COCOA_EXIT(env);
 553 }
 554 
 555 /*
 556  * Class:     com_apple_eawt__AppEventHandler
 557  * Method:    nativeOpenCocoaAboutWindow
 558  * Signature: ()V
 559  */
 560 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppEventHandler_nativeOpenCocoaAboutWindow
 561 (JNIEnv *env, jclass clz)
 562 {
 563 JNF_COCOA_ENTER(env);
 564 
 565     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 566         [NSApp orderFrontStandardAboutPanel:nil];
 567     }];
 568 
 569 JNF_COCOA_EXIT(env);
 570 }
 571 
 572 /*
 573  * Class:     com_apple_eawt__AppEventHandler
 574  * Method:    nativeReplyToAppShouldTerminate
 575  * Signature: (Z)V
 576  */
 577 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppEventHandler_nativeReplyToAppShouldTerminate
 578 (JNIEnv *env, jclass clz, jboolean doTerminate)
 579 {
 580 JNF_COCOA_ENTER(env);
 581 
 582     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 583         [NSApp replyToApplicationShouldTerminate:doTerminate];
 584     }];
 585 
 586 JNF_COCOA_EXIT(env);
 587 }
 588 
 589 /*
 590  * Class:     com_apple_eawt__AppEventHandler
 591  * Method:    nativeRegisterForNotification
 592  * Signature: (I)V
 593  */
 594 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppEventHandler_nativeRegisterForNotification
 595 (JNIEnv *env, jclass clz, jint notificationType)
 596 {
 597 JNF_COCOA_ENTER(env);
 598     [ThreadUtilities performOnMainThread:@selector(_registerForNotification:)
 599                                       on:[ApplicationDelegate class]
 600                               withObject:[NSNumber numberWithInt:notificationType]
 601                            waitUntilDone:NO]; // AWT_THREADING Safe (non-blocking)
 602 JNF_COCOA_EXIT(env);
 603 }
 604 
 605 /*
 606  * Class:     com_apple_eawt__AppDockIconHandler
 607  * Method:    nativeSetDockMenu
 608  * Signature: (J)V
 609  */
 610 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppDockIconHandler_nativeSetDockMenu
 611 (JNIEnv *env, jclass clz, jlong nsMenuPtr)
 612 {
 613 JNF_COCOA_ENTER(env);
 614 
 615     NSMenu *menu = (NSMenu *)jlong_to_ptr(nsMenuPtr);
 616     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
 617         [ApplicationDelegate sharedDelegate].fDockMenu = menu;
 618     }];
 619 
 620 JNF_COCOA_EXIT(env);
 621 }
 622 
 623 /*
 624  * Class:     com_apple_eawt__AppDockIconHandler
 625  * Method:    nativeSetDockIconImage
 626  * Signature: (J)V
 627  */
 628 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppDockIconHandler_nativeSetDockIconImage
 629 (JNIEnv *env, jclass clz, jlong nsImagePtr)
 630 {
 631 JNF_COCOA_ENTER(env);
 632 
 633     NSImage *_image = (NSImage *)jlong_to_ptr(nsImagePtr);
 634     [ThreadUtilities performOnMainThread:@selector(_setDockIconImage:)
 635                                       on:[ApplicationDelegate class]
 636                               withObject:_image
 637                            waitUntilDone:NO];
 638 
 639 JNF_COCOA_EXIT(env);
 640 }
 641 
 642 /*
 643  * Class:     com_apple_eawt__AppDockIconHandler
 644  * Method:    nativeSetDockIconProgress
 645  * Signature: (I)V
 646  */
 647 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppDockIconHandler_nativeSetDockIconProgress
 648   (JNIEnv *env, jclass clz, jint value)
 649 {
 650     JNF_COCOA_ENTER(env);
 651 
 652      [ThreadUtilities performOnMainThread:@selector(_setDockIconProgress:)
 653                                        on:[ApplicationDelegate class]
 654                                withObject:[NSNumber numberWithInt:value]
 655                             waitUntilDone:NO];
 656 
 657     JNF_COCOA_EXIT(env);
 658 }
 659 
 660 /*
 661  * Class:     com_apple_eawt__AppDockIconHandler
 662  * Method:    nativeGetDockIconImage
 663  * Signature: ()J
 664  */
 665 JNIEXPORT jlong JNICALL Java_com_apple_eawt__1AppDockIconHandler_nativeGetDockIconImage
 666 (JNIEnv *env, jclass clz)
 667 {
 668     __block NSImage *image = nil;
 669 
 670 JNF_COCOA_ENTER(env);
 671 
 672     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
 673         image = [[ApplicationDelegate _dockIconImage] retain];
 674     }];
 675 
 676 JNF_COCOA_EXIT(env);
 677 
 678     return ptr_to_jlong(image);
 679 }
 680 
 681 /*
 682  * Class:     com_apple_eawt__AppDockIconHandler
 683  * Method:    nativeSetDockIconBadge
 684  * Signature: (Ljava/lang/String;)V
 685  */
 686 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppDockIconHandler_nativeSetDockIconBadge
 687 (JNIEnv *env, jclass clz, jstring badge)
 688 {
 689 JNF_COCOA_ENTER(env);
 690 
 691     NSString *badgeString = JNFJavaToNSString(env, badge);
 692     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 693         NSDockTile *dockTile = [NSApp dockTile];
 694         [dockTile setBadgeLabel:badgeString];
 695         [dockTile display];
 696     }];
 697 
 698 JNF_COCOA_EXIT(env);
 699 }
 700 
 701 /*
 702  * Class:     com_apple_eawt__AppMiscHandlers
 703  * Method:    nativeRequestActivation
 704  * Signature: (Z)V
 705  */
 706 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppMiscHandlers_nativeRequestActivation
 707 (JNIEnv *env, jclass clz, jboolean allWindows)
 708 {
 709 JNF_COCOA_ENTER(env);
 710 
 711     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 712         NSApplicationActivationOptions options = allWindows ? NSApplicationActivateAllWindows : 0;
 713         options |= NSApplicationActivateIgnoringOtherApps; // without this, nothing happens!
 714         [[NSRunningApplication currentApplication] activateWithOptions:options];
 715     }];
 716 
 717 JNF_COCOA_EXIT(env);
 718 }
 719 
 720 /*
 721  * Class:     com_apple_eawt__AppMiscHandlers
 722  * Method:    nativeRequestUserAttention
 723  * Signature: (Z)V
 724  */
 725 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppMiscHandlers_nativeRequestUserAttention
 726 (JNIEnv *env, jclass clz, jboolean critical)
 727 {
 728 JNF_COCOA_ENTER(env);
 729 
 730     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 731         [NSApp requestUserAttention:critical ? NSCriticalRequest : NSInformationalRequest];
 732     }];
 733 
 734 JNF_COCOA_EXIT(env);
 735 }
 736 
 737 /*
 738  * Class:     com_apple_eawt__AppMiscHandlers
 739  * Method:    nativeOpenHelpViewer
 740  * Signature: ()V
 741  */
 742 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppMiscHandlers_nativeOpenHelpViewer
 743 (JNIEnv *env, jclass clz)
 744 {
 745 JNF_COCOA_ENTER(env);
 746 
 747     [ThreadUtilities performOnMainThread:@selector(showHelp:)
 748                                       on:NSApp
 749                               withObject:nil
 750                            waitUntilDone:NO];
 751 
 752 JNF_COCOA_EXIT(env);
 753 }
 754 
 755 /*
 756  * Class:     com_apple_eawt__AppMiscHandlers
 757  * Method:    nativeEnableSuddenTermination
 758  * Signature: ()V
 759  */
 760 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppMiscHandlers_nativeEnableSuddenTermination
 761 (JNIEnv *env, jclass clz)
 762 {
 763 JNF_COCOA_ENTER(env);
 764 
 765     [[NSProcessInfo processInfo] enableSuddenTermination]; // Foundation thread-safe
 766 
 767 JNF_COCOA_EXIT(env);
 768 }
 769 
 770 /*
 771  * Class:     com_apple_eawt__AppMiscHandlers
 772  * Method:    nativeDisableSuddenTermination
 773  * Signature: ()V
 774  */
 775 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppMiscHandlers_nativeDisableSuddenTermination
 776 (JNIEnv *env, jclass clz)
 777 {
 778 JNF_COCOA_ENTER(env);
 779 
 780     [[NSProcessInfo processInfo] disableSuddenTermination]; // Foundation thread-safe
 781 
 782 JNF_COCOA_EXIT(env);
 783 }
 784 
 785 /*
 786  * Class:     com_apple_eawt__AppMenuBarHandler
 787  * Method:    nativeSetMenuState
 788  * Signature: (IZZ)V
 789  */
 790 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppMenuBarHandler_nativeSetMenuState
 791 (JNIEnv *env, jclass clz, jint menuID, jboolean visible, jboolean enabled)
 792 {
 793 JNF_COCOA_ENTER(env);
 794 
 795     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 796         ApplicationDelegate *delegate = [ApplicationDelegate sharedDelegate];
 797         switch (menuID) {
 798             case com_apple_eawt__AppMenuBarHandler_MENU_ABOUT:
 799                 [delegate _updateAboutMenu:visible enabled:enabled];
 800                 break;
 801             case com_apple_eawt__AppMenuBarHandler_MENU_PREFS:
 802                 [delegate _updatePreferencesMenu:visible enabled:enabled];
 803                 break;
 804         }
 805     }];
 806 
 807 JNF_COCOA_EXIT(env);
 808 }
 809 
 810 /*
 811  * Class:     com_apple_eawt__AppMenuBarHandler
 812  * Method:    nativeSetDefaultMenuBar
 813  * Signature: (J)V
 814  */
 815 JNIEXPORT void JNICALL Java_com_apple_eawt__1AppMenuBarHandler_nativeSetDefaultMenuBar
 816 (JNIEnv *env, jclass clz, jlong cMenuBarPtr)
 817 {
 818 JNF_COCOA_ENTER(env);
 819 
 820     CMenuBar *menu = (CMenuBar *)jlong_to_ptr(cMenuBarPtr);
 821     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
 822         [ApplicationDelegate sharedDelegate].fDefaultMenuBar = menu;
 823     }];
 824 
 825 JNF_COCOA_EXIT(env);
 826 }