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