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 <Cocoa/Cocoa.h>
  27 #import <JavaNativeFoundation/JavaNativeFoundation.h>
  28 
  29 #import "sun_lwawt_macosx_CPlatformWindow.h"
  30 #import "com_apple_eawt_event_GestureHandler.h"
  31 #import "com_apple_eawt_FullScreenHandler.h"
  32 #import "ApplicationDelegate.h"
  33 
  34 #import "AWTWindow.h"
  35 #import "AWTView.h"
  36 #import "GeomUtilities.h"
  37 #import "ThreadUtilities.h"
  38 
  39 #define MASK(KEY) \
  40     (sun_lwawt_macosx_CPlatformWindow_ ## KEY)
  41 
  42 #define IS(BITS, KEY) \
  43     ((BITS & MASK(KEY)) != 0)
  44 
  45 #define SET(BITS, KEY, VALUE) \
  46     BITS = VALUE ? BITS | MASK(KEY) : BITS & ~MASK(KEY)
  47 
  48 static JNF_CLASS_CACHE(jc_CPlatformWindow, "sun/lwawt/macosx/CPlatformWindow");
  49 
  50 // Cocoa windowDidBecomeKey/windowDidResignKey notifications
  51 // doesn't provide information about "opposite" window, so we
  52 // have to do a bit of tracking. This variable points to a window
  53 // which had been the key window just before a new key window
  54 // was set. It would be nil if the new key window isn't an AWT
  55 // window or the app currently has no key window.
  56 static AWTWindow* lastKeyWindow = nil;
  57 
  58 // This variable contains coordinates of a window's top left
  59 // which was positioned via java.awt.Window.setLocationByPlatform.
  60 // It would be NSZeroPoint if 'Location by Platform' is not used.
  61 static NSPoint lastTopLeftPoint;
  62 
  63 // --------------------------------------------------------------
  64 // NSWindow/NSPanel descendants implementation
  65 #define AWT_NS_WINDOW_IMPLEMENTATION                            \
  66 - (id) initWithDelegate:(AWTWindow *)delegate                   \
  67               frameRect:(NSRect)contectRect                     \
  68               styleMask:(NSUInteger)styleMask                   \
  69             contentView:(NSView *)view                          \
  70 {                                                               \
  71     self = [super initWithContentRect:contectRect               \
  72                             styleMask:styleMask                 \
  73                               backing:NSBackingStoreBuffered    \
  74                                 defer:NO];                      \
  75                                                                 \
  76     if (self == nil) return nil;                                \
  77                                                                 \
  78     [self setDelegate:delegate];                                \
  79     [self setContentView:view];                                 \
  80     [self setInitialFirstResponder:view];                       \
  81     [self setReleasedWhenClosed:NO];                            \
  82     [self setPreservesContentDuringLiveResize:YES];             \
  83                                                                 \
  84     return self;                                                \
  85 }                                                               \
  86                                                                 \
  87 /* NSWindow overrides */                                        \
  88 - (BOOL) canBecomeKeyWindow {                                   \
  89     return [(AWTWindow*)[self delegate] canBecomeKeyWindow];    \
  90 }                                                               \
  91                                                                 \
  92 - (BOOL) canBecomeMainWindow {                                  \
  93     return [(AWTWindow*)[self delegate] canBecomeMainWindow];   \
  94 }                                                               \
  95                                                                 \
  96 - (BOOL) worksWhenModal {                                       \
  97     return [(AWTWindow*)[self delegate] worksWhenModal];        \
  98 }                                                               \
  99                                                                 \
 100 - (void)sendEvent:(NSEvent *)event {                            \
 101     [(AWTWindow*)[self delegate] sendEvent:event];              \
 102     [super sendEvent:event];                                    \
 103 }
 104 
 105 @implementation AWTWindow_Normal
 106 AWT_NS_WINDOW_IMPLEMENTATION
 107 
 108 // Gesture support
 109 - (void)postGesture:(NSEvent *)event as:(jint)type a:(jdouble)a b:(jdouble)b {
 110     AWT_ASSERT_APPKIT_THREAD;
 111 
 112     JNIEnv *env = [ThreadUtilities getJNIEnv];
 113     jobject platformWindow = [((AWTWindow *)self.delegate).javaPlatformWindow jObjectWithEnv:env];
 114     if (platformWindow != NULL) {
 115         // extract the target AWT Window object out of the CPlatformWindow
 116         static JNF_MEMBER_CACHE(jf_target, jc_CPlatformWindow, "target", "Ljava/awt/Window;");
 117         jobject awtWindow = JNFGetObjectField(env, platformWindow, jf_target);
 118         if (awtWindow != NULL) {
 119             // translate the point into Java coordinates
 120             NSPoint loc = [event locationInWindow];
 121             loc.y = [self frame].size.height - loc.y;
 122 
 123             // send up to the GestureHandler to recursively dispatch on the AWT event thread
 124             static JNF_CLASS_CACHE(jc_GestureHandler, "com/apple/eawt/event/GestureHandler");
 125             static JNF_STATIC_MEMBER_CACHE(sjm_handleGestureFromNative, jc_GestureHandler, "handleGestureFromNative", "(Ljava/awt/Window;IDDDD)V");
 126             JNFCallStaticVoidMethod(env, sjm_handleGestureFromNative, awtWindow, type, (jdouble)loc.x, (jdouble)loc.y, (jdouble)a, (jdouble)b);
 127             (*env)->DeleteLocalRef(env, awtWindow);
 128         }
 129         (*env)->DeleteLocalRef(env, platformWindow);
 130     }
 131 }
 132 
 133 - (void)beginGestureWithEvent:(NSEvent *)event {
 134     [self postGesture:event
 135                    as:com_apple_eawt_event_GestureHandler_PHASE
 136                     a:-1.0
 137                     b:0.0];
 138 }
 139 
 140 - (void)endGestureWithEvent:(NSEvent *)event {
 141     [self postGesture:event
 142                    as:com_apple_eawt_event_GestureHandler_PHASE
 143                     a:1.0
 144                     b:0.0];
 145 }
 146 
 147 - (void)magnifyWithEvent:(NSEvent *)event {
 148     [self postGesture:event
 149                    as:com_apple_eawt_event_GestureHandler_MAGNIFY
 150                     a:[event magnification]
 151                     b:0.0];
 152 }
 153 
 154 - (void)rotateWithEvent:(NSEvent *)event {
 155     [self postGesture:event
 156                    as:com_apple_eawt_event_GestureHandler_ROTATE
 157                     a:[event rotation]
 158                     b:0.0];
 159 }
 160 
 161 - (void)swipeWithEvent:(NSEvent *)event {
 162     [self postGesture:event
 163                    as:com_apple_eawt_event_GestureHandler_SWIPE
 164                     a:[event deltaX]
 165                     b:[event deltaY]];
 166 }
 167 
 168 @end
 169 @implementation AWTWindow_Panel
 170 AWT_NS_WINDOW_IMPLEMENTATION
 171 @end
 172 // END of NSWindow/NSPanel descendants implementation
 173 // --------------------------------------------------------------
 174 
 175 
 176 @implementation AWTWindow
 177 
 178 @synthesize nsWindow;
 179 @synthesize javaPlatformWindow;
 180 @synthesize javaMenuBar;
 181 @synthesize javaMinSize;
 182 @synthesize javaMaxSize;
 183 @synthesize styleBits;
 184 @synthesize isEnabled;
 185 @synthesize ownerWindow;
 186 @synthesize preFullScreenLevel;
 187 @synthesize standardFrame;
 188 @synthesize isMinimizing;
 189 
 190 - (void) updateMinMaxSize:(BOOL)resizable {
 191     if (resizable) {
 192         [self.nsWindow setMinSize:self.javaMinSize];
 193         [self.nsWindow setMaxSize:self.javaMaxSize];
 194     } else {
 195         NSRect currentFrame = [self.nsWindow frame];
 196         [self.nsWindow setMinSize:currentFrame.size];
 197         [self.nsWindow setMaxSize:currentFrame.size];
 198     }
 199 }
 200 
 201 // creates a new NSWindow style mask based on the _STYLE_PROP_BITMASK bits
 202 + (NSUInteger) styleMaskForStyleBits:(jint)styleBits {
 203     NSUInteger type = 0;
 204     if (IS(styleBits, DECORATED)) {
 205         type |= NSTitledWindowMask;
 206         if (IS(styleBits, CLOSEABLE))   type |= NSClosableWindowMask;
 207         if (IS(styleBits, MINIMIZABLE)) type |= NSMiniaturizableWindowMask;
 208         if (IS(styleBits, RESIZABLE))   type |= NSResizableWindowMask;
 209     } else {
 210         type |= NSBorderlessWindowMask;
 211     }
 212 
 213     if (IS(styleBits, TEXTURED))      type |= NSTexturedBackgroundWindowMask;
 214     if (IS(styleBits, UNIFIED))       type |= NSUnifiedTitleAndToolbarWindowMask;
 215     if (IS(styleBits, UTILITY))       type |= NSUtilityWindowMask;
 216     if (IS(styleBits, HUD))           type |= NSHUDWindowMask;
 217     if (IS(styleBits, SHEET))         type |= NSDocModalWindowMask;
 218     if (IS(styleBits, NONACTIVATING)) type |= NSNonactivatingPanelMask;
 219 
 220     return type;
 221 }
 222 
 223 // updates _METHOD_PROP_BITMASK based properties on the window
 224 - (void) setPropertiesForStyleBits:(jint)bits mask:(jint)mask {
 225     if (IS(mask, RESIZABLE)) {
 226         BOOL resizable = IS(bits, RESIZABLE);
 227         [self updateMinMaxSize:resizable];
 228         [self.nsWindow setShowsResizeIndicator:resizable];
 229         // Zoom button should be disabled, if the window is not resizable,
 230         // otherwise button should be restored to initial state.
 231         BOOL zoom = resizable && IS(bits, ZOOMABLE);
 232         [[self.nsWindow standardWindowButton:NSWindowZoomButton] setEnabled:zoom];
 233     }
 234 
 235     if (IS(mask, HAS_SHADOW)) {
 236         [self.nsWindow setHasShadow:IS(bits, HAS_SHADOW)];
 237     }
 238 
 239     if (IS(mask, ZOOMABLE)) {
 240         [[self.nsWindow standardWindowButton:NSWindowZoomButton] setEnabled:IS(bits, ZOOMABLE)];
 241     }
 242 
 243     if (IS(mask, ALWAYS_ON_TOP)) {
 244         [self.nsWindow setLevel:IS(bits, ALWAYS_ON_TOP) ? NSFloatingWindowLevel : NSNormalWindowLevel];
 245     }
 246 
 247     if (IS(mask, HIDES_ON_DEACTIVATE)) {
 248         [self.nsWindow setHidesOnDeactivate:IS(bits, HIDES_ON_DEACTIVATE)];
 249     }
 250 
 251     if (IS(mask, DRAGGABLE_BACKGROUND)) {
 252         [self.nsWindow setMovableByWindowBackground:IS(bits, DRAGGABLE_BACKGROUND)];
 253     }
 254 
 255     if (IS(mask, DOCUMENT_MODIFIED)) {
 256         [self.nsWindow setDocumentEdited:IS(bits, DOCUMENT_MODIFIED)];
 257     }
 258 
 259     if (IS(mask, FULLSCREENABLE) && [self.nsWindow respondsToSelector:@selector(toggleFullScreen:)]) {
 260         if (IS(bits, FULLSCREENABLE)) {
 261             [self.nsWindow setCollectionBehavior:(1 << 7) /*NSWindowCollectionBehaviorFullScreenPrimary*/];
 262         } else {
 263             [self.nsWindow setCollectionBehavior:NSWindowCollectionBehaviorDefault];
 264         }
 265     }
 266 
 267 }
 268 
 269 - (id) initWithPlatformWindow:(JNFWeakJObjectWrapper *)platformWindow
 270                   ownerWindow:owner
 271                     styleBits:(jint)bits
 272                     frameRect:(NSRect)rect
 273                   contentView:(NSView *)view
 274 {
 275 AWT_ASSERT_APPKIT_THREAD;
 276 
 277     NSUInteger styleMask = [AWTWindow styleMaskForStyleBits:bits];
 278     NSRect contentRect = rect; //[NSWindow contentRectForFrameRect:rect styleMask:styleMask];
 279     if (contentRect.size.width <= 0.0) {
 280         contentRect.size.width = 1.0;
 281     }
 282     if (contentRect.size.height <= 0.0) {
 283         contentRect.size.height = 1.0;
 284     }
 285 
 286     self = [super init];
 287 
 288     if (self == nil) return nil; // no hope
 289 
 290     if (IS(bits, UTILITY) ||
 291         IS(bits, NONACTIVATING) ||
 292         IS(bits, HUD) ||
 293         IS(bits, HIDES_ON_DEACTIVATE))
 294     {
 295         self.nsWindow = [[AWTWindow_Panel alloc] initWithDelegate:self
 296                             frameRect:contentRect
 297                             styleMask:styleMask
 298                           contentView:view];
 299     }
 300     else
 301     {
 302         // These windows will appear in the window list in the dock icon menu
 303         self.nsWindow = [[AWTWindow_Normal alloc] initWithDelegate:self
 304                             frameRect:contentRect
 305                             styleMask:styleMask
 306                           contentView:view];
 307     }
 308 
 309     if (self.nsWindow == nil) return nil; // no hope either
 310     [self.nsWindow release]; // the property retains the object already
 311 
 312     self.isEnabled = YES;
 313     self.isMinimizing = NO;
 314     self.javaPlatformWindow = platformWindow;
 315     self.styleBits = bits;
 316     self.ownerWindow = owner;
 317     [self setPropertiesForStyleBits:styleBits mask:MASK(_METHOD_PROP_BITMASK)];
 318 
 319     if (IS(self.styleBits, IS_POPUP)) {
 320         [self.nsWindow setCollectionBehavior:(1 << 8) /*NSWindowCollectionBehaviorFullScreenAuxiliary*/];
 321     }
 322 
 323     return self;
 324 }
 325 
 326 + (BOOL) isAWTWindow:(NSWindow *)window {
 327     return [window isKindOfClass: [AWTWindow_Panel class]] || [window isKindOfClass: [AWTWindow_Normal class]];
 328 }
 329 
 330 // Retrieves the list of possible window layers (levels)
 331 + (NSArray*) getWindowLayers {
 332     static NSArray *windowLayers;
 333     static dispatch_once_t token;
 334 
 335     // Initialize the list of possible window layers
 336     dispatch_once(&token, ^{
 337         // The layers are ordered from front to back, (i.e. the toppest one is the first)
 338         windowLayers = [NSArray arrayWithObjects:
 339                             [NSNumber numberWithInt:CGWindowLevelForKey(kCGPopUpMenuWindowLevelKey)],
 340                             [NSNumber numberWithInt:CGWindowLevelForKey(kCGFloatingWindowLevelKey)],
 341                             [NSNumber numberWithInt:CGWindowLevelForKey(kCGNormalWindowLevelKey)],
 342                             nil
 343                         ];
 344         [windowLayers retain];
 345     });
 346     return windowLayers;
 347 }
 348 
 349 // returns id for the topmost window under mouse
 350 + (NSInteger) getTopmostWindowUnderMouseID {
 351     NSInteger result = -1;
 352 
 353     NSArray *windowLayers = [AWTWindow getWindowLayers];
 354     // Looking for the window under mouse starting from the toppest layer
 355     for (NSNumber *layer in windowLayers) {
 356         result = [AWTWindow getTopmostWindowUnderMouseIDImpl:[layer integerValue]];
 357         if (result != -1) {
 358             break;
 359         }
 360     }
 361     return result;
 362 }
 363 
 364 + (NSInteger) getTopmostWindowUnderMouseIDImpl:(NSInteger)windowLayer {
 365     NSInteger result = -1;
 366 
 367     NSRect screenRect = [[NSScreen mainScreen] frame];
 368     NSPoint nsMouseLocation = [NSEvent mouseLocation];
 369     CGPoint cgMouseLocation = CGPointMake(nsMouseLocation.x, screenRect.size.height - nsMouseLocation.y);
 370 
 371     NSMutableArray *windows = (NSMutableArray *)CGWindowListCopyWindowInfo(kCGWindowListOptionOnScreenOnly | kCGWindowListExcludeDesktopElements, kCGNullWindowID);
 372 
 373     for (NSDictionary *window in windows) {
 374         NSInteger layer = [[window objectForKey:(id)kCGWindowLayer] integerValue];
 375         if (layer == windowLayer) {
 376             CGRect rect;
 377             CGRectMakeWithDictionaryRepresentation((CFDictionaryRef)[window objectForKey:(id)kCGWindowBounds], &rect);
 378             if (CGRectContainsPoint(rect, cgMouseLocation)) {
 379                 result = [[window objectForKey:(id)kCGWindowNumber] integerValue];
 380                 break;
 381             }
 382         }
 383     }
 384     [windows release];
 385     return result;
 386 }
 387 
 388 // checks that this window is under the mouse cursor and this point is not overlapped by others windows
 389 - (BOOL) isTopmostWindowUnderMouse {
 390     return [self.nsWindow windowNumber] == [AWTWindow getTopmostWindowUnderMouseID];
 391 }
 392 
 393 + (AWTWindow *) getTopmostWindowUnderMouse {
 394     NSEnumerator *windowEnumerator = [[NSApp windows] objectEnumerator];
 395     NSWindow *window;
 396 
 397     NSInteger topmostWindowUnderMouseID = [AWTWindow getTopmostWindowUnderMouseID];
 398 
 399     while ((window = [windowEnumerator nextObject]) != nil) {
 400         if ([window windowNumber] == topmostWindowUnderMouseID) {
 401             BOOL isAWTWindow = [AWTWindow isAWTWindow: window];
 402             return isAWTWindow ? (AWTWindow *) [window delegate] : nil;
 403         }
 404     }
 405     return nil;
 406 }
 407 
 408 + (void) synthesizeMouseEnteredExitedEvents:(NSWindow*)window withType:(NSEventType)eventType {
 409 
 410     NSPoint screenLocation = [NSEvent mouseLocation];
 411     NSPoint windowLocation = [window convertScreenToBase: screenLocation];
 412     int modifierFlags = (eventType == NSMouseEntered) ? NSMouseEnteredMask : NSMouseExitedMask;
 413 
 414     NSEvent *mouseEvent = [NSEvent enterExitEventWithType: eventType
 415                                                  location: windowLocation
 416                                             modifierFlags: modifierFlags
 417                                                 timestamp: 0
 418                                              windowNumber: [window windowNumber]
 419                                                   context: nil
 420                                               eventNumber: 0
 421                                            trackingNumber: 0
 422                                                  userData: nil
 423                            ];
 424 
 425     [[window contentView] deliverJavaMouseEvent: mouseEvent];
 426 }
 427 
 428 + (void) synthesizeMouseEnteredExitedEventsForAllWindows {
 429 
 430     NSInteger topmostWindowUnderMouseID = [AWTWindow getTopmostWindowUnderMouseID];
 431     NSArray *windows = [NSApp windows];
 432     NSWindow *window;
 433 
 434     NSEnumerator *windowEnumerator = [windows objectEnumerator];
 435     while ((window = [windowEnumerator nextObject]) != nil) {
 436         if ([AWTWindow isAWTWindow: window]) {
 437             BOOL isUnderMouse = ([window windowNumber] == topmostWindowUnderMouseID);
 438             BOOL mouseIsOver = [[window contentView] mouseIsOver];
 439             if (isUnderMouse && !mouseIsOver) {
 440                 [AWTWindow synthesizeMouseEnteredExitedEvents:window withType:NSMouseEntered];
 441             } else if (!isUnderMouse && mouseIsOver) {
 442                 [AWTWindow synthesizeMouseEnteredExitedEvents:window withType:NSMouseExited];
 443             }
 444         }
 445     }
 446 }
 447 
 448 + (NSNumber *) getNSWindowDisplayID_AppKitThread:(NSWindow *)window {
 449     AWT_ASSERT_APPKIT_THREAD;
 450     NSScreen *screen = [window screen];
 451     NSDictionary *deviceDescription = [screen deviceDescription];
 452     return [deviceDescription objectForKey:@"NSScreenNumber"];
 453 }
 454 
 455 - (void) dealloc {
 456 AWT_ASSERT_APPKIT_THREAD;
 457 
 458     JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 459     [self.javaPlatformWindow setJObject:nil withEnv:env];
 460 
 461     self.nsWindow = nil;
 462     self.ownerWindow = nil;
 463     [super dealloc];
 464 }
 465 
 466 // Tests whether window is blocked by modal dialog/window
 467 - (BOOL) isBlocked {
 468     BOOL isBlocked = NO;
 469     
 470     JNIEnv *env = [ThreadUtilities getJNIEnv];
 471     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 472     if (platformWindow != NULL) {
 473         static JNF_MEMBER_CACHE(jm_isBlocked, jc_CPlatformWindow, "isBlocked", "()Z");
 474         isBlocked = JNFCallBooleanMethod(env, platformWindow, jm_isBlocked) == JNI_TRUE ? YES : NO;
 475         (*env)->DeleteLocalRef(env, platformWindow);
 476     }
 477     
 478     return isBlocked;
 479 }
 480 
 481 // Tests whether the corresponding Java platform window is visible or not
 482 + (BOOL) isJavaPlatformWindowVisible:(NSWindow *)window {
 483     BOOL isVisible = NO;
 484 
 485     if ([AWTWindow isAWTWindow:window] && [window delegate] != nil) {
 486         AWTWindow *awtWindow = (AWTWindow *)[window delegate];
 487         [AWTToolkit eventCountPlusPlus];
 488 
 489         JNIEnv *env = [ThreadUtilities getJNIEnv];
 490         jobject platformWindow = [awtWindow.javaPlatformWindow jObjectWithEnv:env];
 491         if (platformWindow != NULL) {
 492             static JNF_MEMBER_CACHE(jm_isVisible, jc_CPlatformWindow, "isVisible", "()Z");
 493             isVisible = JNFCallBooleanMethod(env, platformWindow, jm_isVisible) == JNI_TRUE ? YES : NO;
 494             (*env)->DeleteLocalRef(env, platformWindow);
 495 
 496         }
 497     }
 498     return isVisible;
 499 }
 500 
 501 // Orders window's childs based on the current focus state
 502 - (void) orderChildWindows:(BOOL)focus {
 503 AWT_ASSERT_APPKIT_THREAD;
 504 
 505     if (self.isMinimizing || [self isBlocked]) {
 506         // Do not perform any ordering, if iconify is in progress
 507         // or the window is blocked by a modal window
 508         return;
 509     }
 510 
 511     NSEnumerator *windowEnumerator = [[NSApp windows]objectEnumerator];
 512     NSWindow *window;
 513     while ((window = [windowEnumerator nextObject]) != nil) {
 514         if ([AWTWindow isJavaPlatformWindowVisible:window]) {
 515             AWTWindow *awtWindow = (AWTWindow *)[window delegate];
 516             AWTWindow *owner = awtWindow.ownerWindow;
 517             if (IS(awtWindow.styleBits, ALWAYS_ON_TOP)) {
 518                 // Do not order 'always on top' windows
 519                 continue;
 520             }
 521             while (awtWindow.ownerWindow != nil) {
 522                 if (awtWindow.ownerWindow == self) {
 523                     if (focus) {
 524                         // Move the childWindow to floating level
 525                         // so it will appear in front of its
 526                         // parent which owns the focus
 527                         [window setLevel:NSFloatingWindowLevel];
 528                     } else {
 529                         // Focus owner has changed, move the childWindow
 530                         // back to normal window level
 531                         [window setLevel:NSNormalWindowLevel];
 532                     }
 533                     // The childWindow should be displayed in front of
 534                     // its nearest parentWindow
 535                     [window orderWindow:NSWindowAbove relativeTo:[owner.nsWindow windowNumber]];
 536                     break;
 537                 }
 538                 awtWindow = awtWindow.ownerWindow;
 539             }
 540         }
 541     }
 542 }
 543 
 544 // NSWindow overrides
 545 - (BOOL) canBecomeKeyWindow {
 546 AWT_ASSERT_APPKIT_THREAD;
 547     return self.isEnabled && IS(self.styleBits, SHOULD_BECOME_KEY);
 548 }
 549 
 550 - (BOOL) canBecomeMainWindow {
 551 AWT_ASSERT_APPKIT_THREAD;
 552     if (!self.isEnabled) {
 553         // Native system can bring up the NSWindow to
 554         // the top even if the window is not main.
 555         // We should bring up the modal dialog manually
 556         [AWTToolkit eventCountPlusPlus];
 557 
 558         JNIEnv *env = [ThreadUtilities getJNIEnv];
 559         jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 560         if (platformWindow != NULL) {
 561             static JNF_MEMBER_CACHE(jm_checkBlockingAndOrder, jc_CPlatformWindow,
 562                                     "checkBlockingAndOrder", "()Z");
 563             JNFCallBooleanMethod(env, platformWindow, jm_checkBlockingAndOrder);
 564             (*env)->DeleteLocalRef(env, platformWindow);
 565         }
 566     }
 567 
 568     return self.isEnabled && IS(self.styleBits, SHOULD_BECOME_MAIN);
 569 }
 570 
 571 - (BOOL) worksWhenModal {
 572 AWT_ASSERT_APPKIT_THREAD;
 573     return IS(self.styleBits, MODAL_EXCLUDED);
 574 }
 575 
 576 
 577 // NSWindowDelegate methods
 578 
 579 - (void) _deliverMoveResizeEvent {
 580 AWT_ASSERT_APPKIT_THREAD;
 581 
 582     // deliver the event if this is a user-initiated live resize or as a side-effect
 583     // of a Java initiated resize, because AppKit can override the bounds and force
 584     // the bounds of the window to avoid the Dock or remain on screen.
 585     [AWTToolkit eventCountPlusPlus];
 586     JNIEnv *env = [ThreadUtilities getJNIEnv];
 587     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 588     if (platformWindow == NULL) {
 589         // TODO: create generic AWT assert
 590     }
 591 
 592     NSRect frame = ConvertNSScreenRect(env, [self.nsWindow frame]);
 593 
 594     static JNF_MEMBER_CACHE(jm_deliverMoveResizeEvent, jc_CPlatformWindow, "deliverMoveResizeEvent", "(IIIIZ)V");
 595     JNFCallVoidMethod(env, platformWindow, jm_deliverMoveResizeEvent,
 596                       (jint)frame.origin.x,
 597                       (jint)frame.origin.y,
 598                       (jint)frame.size.width,
 599                       (jint)frame.size.height,
 600                       (jboolean)[self.nsWindow inLiveResize]);
 601     (*env)->DeleteLocalRef(env, platformWindow);
 602 
 603     [AWTWindow synthesizeMouseEnteredExitedEventsForAllWindows];
 604 }
 605 
 606 - (void)windowDidMove:(NSNotification *)notification {
 607 AWT_ASSERT_APPKIT_THREAD;
 608 
 609     [self _deliverMoveResizeEvent];
 610 }
 611 
 612 - (void)windowDidResize:(NSNotification *)notification {
 613 AWT_ASSERT_APPKIT_THREAD;
 614 
 615     [self _deliverMoveResizeEvent];
 616 }
 617 
 618 - (void)windowDidExpose:(NSNotification *)notification {
 619 AWT_ASSERT_APPKIT_THREAD;
 620 
 621     [AWTToolkit eventCountPlusPlus];
 622     // TODO: don't see this callback invoked anytime so we track
 623     // window exposing in _setVisible:(BOOL)
 624 }
 625 
 626 - (NSRect)windowWillUseStandardFrame:(NSWindow *)window
 627                         defaultFrame:(NSRect)newFrame {
 628 
 629     return NSEqualSizes(NSZeroSize, [self standardFrame].size)
 630                 ? newFrame
 631                 : [self standardFrame];
 632 }
 633 
 634 // Hides/shows window's childs during iconify/de-iconify operation
 635 - (void) iconifyChildWindows:(BOOL)iconify {
 636 AWT_ASSERT_APPKIT_THREAD;
 637 
 638     NSEnumerator *windowEnumerator = [[NSApp windows]objectEnumerator];
 639     NSWindow *window;
 640     while ((window = [windowEnumerator nextObject]) != nil) {
 641         if ([AWTWindow isJavaPlatformWindowVisible:window]) {
 642             AWTWindow *awtWindow = (AWTWindow *)[window delegate];
 643             while (awtWindow.ownerWindow != nil) {
 644                 if (awtWindow.ownerWindow == self) {
 645                     if (iconify) {
 646                         [window orderOut:window];
 647                     } else {
 648                         [window orderFront:window];
 649                     }
 650                     break;
 651                 }
 652                 awtWindow = awtWindow.ownerWindow;
 653             }
 654         }
 655     }
 656 }
 657 
 658 - (void) _deliverIconify:(BOOL)iconify {
 659 AWT_ASSERT_APPKIT_THREAD;
 660 
 661     [AWTToolkit eventCountPlusPlus];
 662     JNIEnv *env = [ThreadUtilities getJNIEnv];
 663     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 664     if (platformWindow != NULL) {
 665         static JNF_MEMBER_CACHE(jm_deliverIconify, jc_CPlatformWindow, "deliverIconify", "(Z)V");
 666         JNFCallVoidMethod(env, platformWindow, jm_deliverIconify, iconify);
 667         (*env)->DeleteLocalRef(env, platformWindow);
 668     }
 669 }
 670 
 671 - (void)windowWillMiniaturize:(NSNotification *)notification {
 672 AWT_ASSERT_APPKIT_THREAD;
 673 
 674     self.isMinimizing = YES;
 675 
 676     JNIEnv *env = [ThreadUtilities getJNIEnv];
 677     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 678     if (platformWindow != NULL) {
 679         static JNF_MEMBER_CACHE(jm_windowWillMiniaturize, jc_CPlatformWindow, "windowWillMiniaturize", "()V");
 680         JNFCallVoidMethod(env, platformWindow, jm_windowWillMiniaturize);
 681         (*env)->DeleteLocalRef(env, platformWindow);
 682     }
 683     // Excplicitly make myself a key window to avoid possible
 684     // negative visual effects during iconify operation
 685     [self.nsWindow makeKeyAndOrderFront:self.nsWindow];
 686     [self iconifyChildWindows:YES];
 687 }
 688 
 689 - (void)windowDidMiniaturize:(NSNotification *)notification {
 690 AWT_ASSERT_APPKIT_THREAD;
 691 
 692     [self _deliverIconify:JNI_TRUE];
 693     self.isMinimizing = NO;
 694 }
 695 
 696 - (void)windowDidDeminiaturize:(NSNotification *)notification {
 697 AWT_ASSERT_APPKIT_THREAD;
 698 
 699     [self _deliverIconify:JNI_FALSE];
 700     [self iconifyChildWindows:NO];
 701 }
 702 
 703 - (void) _deliverWindowFocusEvent:(BOOL)focused oppositeWindow:(AWTWindow *)opposite {
 704 //AWT_ASSERT_APPKIT_THREAD;
 705     JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 706     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 707     if (platformWindow != NULL) {
 708         jobject oppositeWindow = [opposite.javaPlatformWindow jObjectWithEnv:env];
 709 
 710         static JNF_MEMBER_CACHE(jm_deliverWindowFocusEvent, jc_CPlatformWindow, "deliverWindowFocusEvent", "(ZLsun/lwawt/macosx/CPlatformWindow;)V");
 711         JNFCallVoidMethod(env, platformWindow, jm_deliverWindowFocusEvent, (jboolean)focused, oppositeWindow);
 712         (*env)->DeleteLocalRef(env, platformWindow);
 713         (*env)->DeleteLocalRef(env, oppositeWindow);
 714     }
 715 }
 716 
 717 
 718 - (void) windowDidBecomeKey: (NSNotification *) notification {
 719 AWT_ASSERT_APPKIT_THREAD;
 720     [AWTToolkit eventCountPlusPlus];
 721     AWTWindow *opposite = [AWTWindow lastKeyWindow];
 722 
 723     // Finds appropriate menubar in our hierarchy,
 724     AWTWindow *awtWindow = self;
 725     while (awtWindow.ownerWindow != nil) {
 726         awtWindow = awtWindow.ownerWindow;
 727     }
 728 
 729     CMenuBar *menuBar = nil;
 730     BOOL isDisabled = NO;
 731     if ([awtWindow.nsWindow isVisible]){
 732         menuBar = awtWindow.javaMenuBar;
 733         isDisabled = !awtWindow.isEnabled;
 734     }
 735 
 736     if (menuBar == nil) {
 737         menuBar = [[ApplicationDelegate sharedDelegate] defaultMenuBar];
 738         isDisabled = NO;
 739     }
 740 
 741     [CMenuBar activate:menuBar modallyDisabled:isDisabled];
 742 
 743     [AWTWindow setLastKeyWindow:nil];
 744 
 745     [self _deliverWindowFocusEvent:YES oppositeWindow: opposite];
 746     [self orderChildWindows:YES];
 747 }
 748 
 749 - (void) windowDidResignKey: (NSNotification *) notification {
 750     // TODO: check why sometimes at start is invoked *not* on AppKit main thread.
 751 AWT_ASSERT_APPKIT_THREAD;
 752     [AWTToolkit eventCountPlusPlus];
 753     [self.javaMenuBar deactivate];
 754 
 755     // In theory, this might cause flickering if the window gaining focus
 756     // has its own menu. However, I couldn't reproduce it on practice, so
 757     // perhaps this is a non issue.
 758     CMenuBar* defaultMenu = [[ApplicationDelegate sharedDelegate] defaultMenuBar];
 759     if (defaultMenu != nil) {
 760         [CMenuBar activate:defaultMenu modallyDisabled:NO];
 761     }
 762 
 763     // the new key window
 764     NSWindow *keyWindow = [NSApp keyWindow];
 765     AWTWindow *opposite = nil;
 766     if ([AWTWindow isAWTWindow: keyWindow]) {
 767         opposite = (AWTWindow *)[keyWindow delegate];
 768         [AWTWindow setLastKeyWindow: self];
 769     } else {
 770         [AWTWindow setLastKeyWindow: nil];
 771     }
 772 
 773     [self _deliverWindowFocusEvent:NO oppositeWindow: opposite];
 774     [self orderChildWindows:NO];
 775 }
 776 
 777 - (void) windowDidBecomeMain: (NSNotification *) notification {
 778 AWT_ASSERT_APPKIT_THREAD;
 779     [AWTToolkit eventCountPlusPlus];
 780 
 781     JNIEnv *env = [ThreadUtilities getJNIEnv];
 782     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 783     if (platformWindow != NULL) {
 784         static JNF_MEMBER_CACHE(jm_windowDidBecomeMain, jc_CPlatformWindow, "windowDidBecomeMain", "()V");
 785         JNFCallVoidMethod(env, platformWindow, jm_windowDidBecomeMain);
 786         (*env)->DeleteLocalRef(env, platformWindow);
 787     }
 788 }
 789 
 790 - (BOOL)windowShouldClose:(id)sender {
 791 AWT_ASSERT_APPKIT_THREAD;
 792     [AWTToolkit eventCountPlusPlus];
 793     JNIEnv *env = [ThreadUtilities getJNIEnv];
 794     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 795     if (platformWindow != NULL) {
 796         static JNF_MEMBER_CACHE(jm_deliverWindowClosingEvent, jc_CPlatformWindow, "deliverWindowClosingEvent", "()V");
 797         JNFCallVoidMethod(env, platformWindow, jm_deliverWindowClosingEvent);
 798         (*env)->DeleteLocalRef(env, platformWindow);
 799     }
 800     // The window will be closed (if allowed) as result of sending Java event
 801     return NO;
 802 }
 803 
 804 
 805 - (void)_notifyFullScreenOp:(jint)op withEnv:(JNIEnv *)env {
 806     static JNF_CLASS_CACHE(jc_FullScreenHandler, "com/apple/eawt/FullScreenHandler");
 807     static JNF_STATIC_MEMBER_CACHE(jm_notifyFullScreenOperation, jc_FullScreenHandler, "handleFullScreenEventFromNative", "(Ljava/awt/Window;I)V");
 808     static JNF_MEMBER_CACHE(jf_target, jc_CPlatformWindow, "target", "Ljava/awt/Window;");
 809     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 810     if (platformWindow != NULL) {
 811         jobject awtWindow = JNFGetObjectField(env, platformWindow, jf_target);
 812         if (awtWindow != NULL) {
 813             JNFCallStaticVoidMethod(env, jm_notifyFullScreenOperation, awtWindow, op);
 814             (*env)->DeleteLocalRef(env, awtWindow);
 815         }
 816         (*env)->DeleteLocalRef(env, platformWindow);
 817     }
 818 }
 819 
 820 
 821 - (void)windowWillEnterFullScreen:(NSNotification *)notification {
 822     static JNF_MEMBER_CACHE(jm_windowWillEnterFullScreen, jc_CPlatformWindow, "windowWillEnterFullScreen", "()V");
 823     JNIEnv *env = [ThreadUtilities getJNIEnv];
 824     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 825     if (platformWindow != NULL) {
 826         JNFCallVoidMethod(env, platformWindow, jm_windowWillEnterFullScreen);
 827         [self _notifyFullScreenOp:com_apple_eawt_FullScreenHandler_FULLSCREEN_WILL_ENTER withEnv:env];
 828         (*env)->DeleteLocalRef(env, platformWindow);
 829     }
 830 }
 831 
 832 - (void)windowDidEnterFullScreen:(NSNotification *)notification {
 833     static JNF_MEMBER_CACHE(jm_windowDidEnterFullScreen, jc_CPlatformWindow, "windowDidEnterFullScreen", "()V");
 834     JNIEnv *env = [ThreadUtilities getJNIEnv];
 835     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 836     if (platformWindow != NULL) {
 837         JNFCallVoidMethod(env, platformWindow, jm_windowDidEnterFullScreen);
 838         [self _notifyFullScreenOp:com_apple_eawt_FullScreenHandler_FULLSCREEN_DID_ENTER withEnv:env];
 839         (*env)->DeleteLocalRef(env, platformWindow);
 840     }
 841     [AWTWindow synthesizeMouseEnteredExitedEventsForAllWindows];
 842 }
 843 
 844 - (void)windowWillExitFullScreen:(NSNotification *)notification {
 845     static JNF_MEMBER_CACHE(jm_windowWillExitFullScreen, jc_CPlatformWindow, "windowWillExitFullScreen", "()V");
 846     JNIEnv *env = [ThreadUtilities getJNIEnv];
 847     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 848     if (platformWindow != NULL) {
 849         JNFCallVoidMethod(env, platformWindow, jm_windowWillExitFullScreen);
 850         [self _notifyFullScreenOp:com_apple_eawt_FullScreenHandler_FULLSCREEN_WILL_EXIT withEnv:env];
 851         (*env)->DeleteLocalRef(env, platformWindow);
 852     }
 853 }
 854 
 855 - (void)windowDidExitFullScreen:(NSNotification *)notification {
 856     static JNF_MEMBER_CACHE(jm_windowDidExitFullScreen, jc_CPlatformWindow, "windowDidExitFullScreen", "()V");
 857     JNIEnv *env = [ThreadUtilities getJNIEnv];
 858     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 859     if (platformWindow != NULL) {
 860         JNFCallVoidMethod(env, platformWindow, jm_windowDidExitFullScreen);
 861         [self _notifyFullScreenOp:com_apple_eawt_FullScreenHandler_FULLSCREEN_DID_EXIT withEnv:env];
 862         (*env)->DeleteLocalRef(env, platformWindow);
 863     }
 864     [AWTWindow synthesizeMouseEnteredExitedEventsForAllWindows];
 865 }
 866 
 867 - (void)sendEvent:(NSEvent *)event {
 868         if ([event type] == NSLeftMouseDown || [event type] == NSRightMouseDown || [event type] == NSOtherMouseDown) {
 869             if ([self isBlocked]) {
 870                 // Move parent windows to front and make sure that a child window is displayed
 871                 // in front of its nearest parent.
 872                 if (self.ownerWindow != nil) {
 873                     JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 874                     jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 875                     if (platformWindow != NULL) {
 876                         static JNF_MEMBER_CACHE(jm_orderAboveSiblings, jc_CPlatformWindow, "orderAboveSiblings", "()V");
 877                         JNFCallVoidMethod(env,platformWindow, jm_orderAboveSiblings);
 878                         (*env)->DeleteLocalRef(env, platformWindow);
 879                     }
 880                 }
 881                 [self orderChildWindows:YES];
 882             }
 883 
 884             NSPoint p = [NSEvent mouseLocation];
 885             NSRect frame = [self.nsWindow frame];
 886             NSRect contentRect = [self.nsWindow contentRectForFrameRect:frame];
 887             


 888             JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 889             jobject platformWindow = [self.javaPlatformWindow jObjectWithEnv:env];
 890             
 891             // Check if the click happened in the non-client area (title bar)
 892             if (p.y >= (frame.origin.y + contentRect.size.height)) {
 893                 if (platformWindow != NULL) {
 894                     // Toggle full screen upon double click on title bar.
 895                     if([event clickCount] == 2) {
 896                         static JNF_MEMBER_CACHE(jm_deliverNCDblClick, jc_CPlatformWindow, "deliverNCDblClick", "()V");
 897                         JNFCallVoidMethod(env, platformWindow, jm_deliverNCDblClick);
 898                     } else {
 899                         // Currently, no need to deliver the whole NSEvent.
 900                         static JNF_MEMBER_CACHE(jm_deliverNCMouseDown, jc_CPlatformWindow, "deliverNCMouseDown", "()V");
 901                         JNFCallVoidMethod(env, platformWindow, jm_deliverNCMouseDown);

 902                     }
 903                 }
 904             }
 905             
 906             (*env)->DeleteLocalRef(env, platformWindow);
 907         }
 908 }
 909 
 910 - (void)constrainSize:(NSSize*)size {
 911     float minWidth = 0.f, minHeight = 0.f;
 912 
 913     if (IS(self.styleBits, DECORATED)) {
 914         NSRect frame = [self.nsWindow frame];
 915         NSRect contentRect = [NSWindow contentRectForFrameRect:frame styleMask:[self.nsWindow styleMask]];
 916 
 917         float top = frame.size.height - contentRect.size.height;
 918         float left = contentRect.origin.x - frame.origin.x;
 919         float bottom = contentRect.origin.y - frame.origin.y;
 920         float right = frame.size.width - (contentRect.size.width + left);
 921 
 922         // Speculative estimation: 80 - enough for window decorations controls
 923         minWidth += left + right + 80;
 924         minHeight += top + bottom;
 925     }
 926 
 927     minWidth = MAX(1.f, minWidth);
 928     minHeight = MAX(1.f, minHeight);
 929 
 930     size->width = MAX(size->width, minWidth);
 931     size->height = MAX(size->height, minHeight);
 932 }
 933 
 934 - (void) setEnabled: (BOOL)flag {
 935     self.isEnabled = flag;
 936 
 937     if (IS(self.styleBits, CLOSEABLE)) {
 938         [[self.nsWindow standardWindowButton:NSWindowCloseButton] setEnabled: flag];
 939     }
 940 
 941     if (IS(self.styleBits, MINIMIZABLE)) {
 942         [[self.nsWindow standardWindowButton:NSWindowMiniaturizeButton] setEnabled: flag];
 943     }
 944 
 945     if (IS(self.styleBits, ZOOMABLE)) {
 946         [[self.nsWindow standardWindowButton:NSWindowZoomButton] setEnabled: flag];
 947     }
 948 
 949     if (IS(self.styleBits, RESIZABLE)) {
 950         [self updateMinMaxSize:flag];
 951         [self.nsWindow setShowsResizeIndicator:flag];
 952     }
 953 }
 954 
 955 + (void) setLastKeyWindow:(AWTWindow *)window {
 956     [window retain];
 957     [lastKeyWindow release];
 958     lastKeyWindow = window;
 959 }
 960 
 961 + (AWTWindow *) lastKeyWindow {
 962     return lastKeyWindow;
 963 }
 964 
 965 - (BOOL)windowShouldZoom:(NSWindow *)window toFrame:(NSRect)newFrame {
 966     return !NSEqualSizes(self.nsWindow.frame.size, newFrame.size);
 967 }
 968 
 969 
 970 @end // AWTWindow
 971 
 972 
 973 /*
 974  * Class:     sun_lwawt_macosx_CPlatformWindow
 975  * Method:    nativeCreateNSWindow
 976  * Signature: (JJIIII)J
 977  */
 978 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeCreateNSWindow
 979 (JNIEnv *env, jobject obj, jlong contentViewPtr, jlong ownerPtr, jlong styleBits, jdouble x, jdouble y, jdouble w, jdouble h)
 980 {
 981     __block AWTWindow *window = nil;
 982 
 983 JNF_COCOA_ENTER(env);
 984 
 985     JNFWeakJObjectWrapper *platformWindow = [JNFWeakJObjectWrapper wrapperWithJObject:obj withEnv:env];
 986     NSView *contentView = OBJC(contentViewPtr);
 987     NSRect frameRect = NSMakeRect(x, y, w, h);
 988     AWTWindow *owner = [OBJC(ownerPtr) delegate];
 989     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
 990 
 991         window = [[AWTWindow alloc] initWithPlatformWindow:platformWindow
 992                                                ownerWindow:owner
 993                                                  styleBits:styleBits
 994                                                  frameRect:frameRect
 995                                                contentView:contentView];
 996         // the window is released is CPlatformWindow.nativeDispose()
 997 
 998         if (window) [window.nsWindow retain];
 999     }];
1000 
1001 JNF_COCOA_EXIT(env);
1002 
1003     return ptr_to_jlong(window ? window.nsWindow : nil);
1004 }
1005 
1006 /*
1007  * Class:     sun_lwawt_macosx_CPlatformWindow
1008  * Method:    nativeSetNSWindowStyleBits
1009  * Signature: (JII)V
1010  */
1011 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowStyleBits
1012 (JNIEnv *env, jclass clazz, jlong windowPtr, jint mask, jint bits)
1013 {
1014 JNF_COCOA_ENTER(env);
1015 
1016     NSWindow *nsWindow = OBJC(windowPtr);
1017     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1018 
1019         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1020 
1021         // scans the bit field, and only updates the values requested by the mask
1022         // (this implicity handles the _CALLBACK_PROP_BITMASK case, since those are passive reads)
1023         jint newBits = window.styleBits & ~mask | bits & mask;
1024 
1025         // resets the NSWindow's style mask if the mask intersects any of those bits
1026         if (mask & MASK(_STYLE_PROP_BITMASK)) {
1027             [nsWindow setStyleMask:[AWTWindow styleMaskForStyleBits:newBits]];
1028         }
1029 
1030         // calls methods on NSWindow to change other properties, based on the mask
1031         if (mask & MASK(_METHOD_PROP_BITMASK)) {
1032             [window setPropertiesForStyleBits:newBits mask:mask];
1033         }
1034 
1035         window.styleBits = newBits;
1036     }];
1037 
1038 JNF_COCOA_EXIT(env);
1039 }
1040 
1041 /*
1042  * Class:     sun_lwawt_macosx_CPlatformWindow
1043  * Method:    nativeSetNSWindowMenuBar
1044  * Signature: (JJ)V
1045  */
1046 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowMenuBar
1047 (JNIEnv *env, jclass clazz, jlong windowPtr, jlong menuBarPtr)
1048 {
1049 JNF_COCOA_ENTER(env);
1050 
1051     NSWindow *nsWindow = OBJC(windowPtr);
1052     CMenuBar *menuBar = OBJC(menuBarPtr);
1053     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1054 
1055         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1056 
1057         if ([nsWindow isKeyWindow]) {
1058             [window.javaMenuBar deactivate];
1059         }
1060 
1061         window.javaMenuBar = menuBar;
1062 
1063         CMenuBar* actualMenuBar = menuBar;
1064         if (actualMenuBar == nil) {
1065             actualMenuBar = [[ApplicationDelegate sharedDelegate] defaultMenuBar];
1066         }
1067 
1068         if ([nsWindow isKeyWindow]) {
1069             [CMenuBar activate:actualMenuBar modallyDisabled:NO];
1070         }
1071     }];
1072 
1073 JNF_COCOA_EXIT(env);
1074 }
1075 
1076 /*
1077  * Class:     sun_lwawt_macosx_CPlatformWindow
1078  * Method:    nativeGetNSWindowInsets
1079  * Signature: (J)Ljava/awt/Insets;
1080  */
1081 JNIEXPORT jobject JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeGetNSWindowInsets
1082 (JNIEnv *env, jclass clazz, jlong windowPtr)
1083 {
1084     jobject ret = NULL;
1085 
1086 JNF_COCOA_ENTER(env);
1087 
1088     NSWindow *nsWindow = OBJC(windowPtr);
1089     __block NSRect contentRect = NSZeroRect;
1090     __block NSRect frame = NSZeroRect;
1091 
1092     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
1093 
1094         frame = [nsWindow frame];
1095         contentRect = [NSWindow contentRectForFrameRect:frame styleMask:[nsWindow styleMask]];
1096     }];
1097 
1098     jint top = (jint)(frame.size.height - contentRect.size.height);
1099     jint left = (jint)(contentRect.origin.x - frame.origin.x);
1100     jint bottom = (jint)(contentRect.origin.y - frame.origin.y);
1101     jint right = (jint)(frame.size.width - (contentRect.size.width + left));
1102 
1103     static JNF_CLASS_CACHE(jc_Insets, "java/awt/Insets");
1104     static JNF_CTOR_CACHE(jc_Insets_ctor, jc_Insets, "(IIII)V");
1105     ret = JNFNewObject(env, jc_Insets_ctor, top, left, bottom, right);
1106 
1107 JNF_COCOA_EXIT(env);
1108     return ret;
1109 }
1110 
1111 /*
1112  * Class:     sun_lwawt_macosx_CPlatformWindow
1113  * Method:    nativeSetNSWindowBounds
1114  * Signature: (JDDDD)V
1115  */
1116 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowBounds
1117 (JNIEnv *env, jclass clazz, jlong windowPtr, jdouble originX, jdouble originY, jdouble width, jdouble height)
1118 {
1119 JNF_COCOA_ENTER(env);
1120 
1121     NSRect jrect = NSMakeRect(originX, originY, width, height);
1122 
1123     // TODO: not sure we need displayIfNeeded message in our view
1124     NSWindow *nsWindow = OBJC(windowPtr);
1125     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1126 
1127         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1128 
1129         NSRect rect = ConvertNSScreenRect(NULL, jrect);
1130         [window constrainSize:&rect.size];
1131 
1132         [nsWindow setFrame:rect display:YES];
1133 
1134         // only start tracking events if pointer is above the toplevel
1135         // TODO: should post an Entered event if YES.
1136         NSPoint mLocation = [NSEvent mouseLocation];
1137         [nsWindow setAcceptsMouseMovedEvents:NSPointInRect(mLocation, rect)];
1138 
1139         // ensure we repaint the whole window after the resize operation
1140         // (this will also re-enable screen updates, which were disabled above)
1141         // TODO: send PaintEvent
1142     }];
1143 
1144 JNF_COCOA_EXIT(env);
1145 }
1146 
1147 /*
1148  * Class:     sun_lwawt_macosx_CPlatformWindow
1149  * Method:    nativeSetNSWindowStandardFrame
1150  * Signature: (JDDDD)V
1151  */
1152 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowStandardFrame
1153 (JNIEnv *env, jclass clazz, jlong windowPtr, jdouble originX, jdouble originY,
1154      jdouble width, jdouble height)
1155 {
1156     JNF_COCOA_ENTER(env);
1157 
1158     NSRect jrect = NSMakeRect(originX, originY, width, height);
1159 
1160     NSWindow *nsWindow = OBJC(windowPtr);
1161     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1162 
1163         NSRect rect = ConvertNSScreenRect(NULL, jrect);
1164         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1165         window.standardFrame = rect;
1166     }];
1167 
1168     JNF_COCOA_EXIT(env);
1169 }
1170 
1171 /*
1172  * Class:     sun_lwawt_macosx_CPlatformWindow
1173  * Method:    nativeSetNSWindowLocationByPlatform
1174  * Signature: (J)V
1175  */
1176 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowLocationByPlatform
1177 (JNIEnv *env, jclass clazz, jlong windowPtr)
1178 {
1179     JNF_COCOA_ENTER(env);
1180 
1181     NSWindow *nsWindow = OBJC(windowPtr);
1182     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1183 
1184         if (NSEqualPoints(lastTopLeftPoint, NSZeroPoint)) {
1185             // This is the first usage of lastTopLeftPoint. So invoke cascadeTopLeftFromPoint
1186             // twice to avoid positioning the window's top left to zero-point, since it may
1187             // cause negative user experience.
1188             lastTopLeftPoint = [nsWindow cascadeTopLeftFromPoint:lastTopLeftPoint];
1189         }
1190         lastTopLeftPoint = [nsWindow cascadeTopLeftFromPoint:lastTopLeftPoint];
1191     }];
1192 
1193     JNF_COCOA_EXIT(env);
1194 }
1195 
1196 /*
1197  * Class:     sun_lwawt_macosx_CPlatformWindow
1198  * Method:    nativeSetNSWindowMinMax
1199  * Signature: (JDDDD)V
1200  */
1201 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowMinMax
1202 (JNIEnv *env, jclass clazz, jlong windowPtr, jdouble minW, jdouble minH, jdouble maxW, jdouble maxH)
1203 {
1204 JNF_COCOA_ENTER(env);
1205 
1206     if (minW < 1) minW = 1;
1207     if (minH < 1) minH = 1;
1208     if (maxW < 1) maxW = 1;
1209     if (maxH < 1) maxH = 1;
1210 
1211     NSWindow *nsWindow = OBJC(windowPtr);
1212     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1213 
1214         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1215 
1216         NSSize min = { minW, minH };
1217         NSSize max = { maxW, maxH };
1218 
1219         [window constrainSize:&min];
1220         [window constrainSize:&max];
1221 
1222         window.javaMinSize = min;
1223         window.javaMaxSize = max;
1224         [window updateMinMaxSize:IS(window.styleBits, RESIZABLE)];
1225     }];
1226 
1227 JNF_COCOA_EXIT(env);
1228 }
1229 
1230 /*
1231  * Class:     sun_lwawt_macosx_CPlatformWindow
1232  * Method:    nativePushNSWindowToBack
1233  * Signature: (J)V
1234  */
1235 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativePushNSWindowToBack
1236 (JNIEnv *env, jclass clazz, jlong windowPtr)
1237 {
1238 JNF_COCOA_ENTER(env);
1239 
1240     NSWindow *nsWindow = OBJC(windowPtr);
1241     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1242         [nsWindow orderBack:nil];
1243         // Order parent windows
1244         AWTWindow *awtWindow = (AWTWindow*)[nsWindow delegate];
1245         while (awtWindow.ownerWindow != nil) {
1246             awtWindow = awtWindow.ownerWindow;
1247             if ([AWTWindow isJavaPlatformWindowVisible:awtWindow.nsWindow]) {
1248                 [awtWindow.nsWindow orderBack:nil];
1249             }
1250         }
1251         // Order child windows
1252         [(AWTWindow*)[nsWindow delegate] orderChildWindows:NO];
1253     }];
1254 
1255 JNF_COCOA_EXIT(env);
1256 }
1257 
1258 /*
1259  * Class:     sun_lwawt_macosx_CPlatformWindow
1260  * Method:    nativePushNSWindowToFront
1261  * Signature: (J)V
1262  */
1263 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativePushNSWindowToFront
1264 (JNIEnv *env, jclass clazz, jlong windowPtr)
1265 {
1266 JNF_COCOA_ENTER(env);
1267 
1268     NSWindow *nsWindow = OBJC(windowPtr);
1269     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1270 
1271         if (![nsWindow isKeyWindow]) {
1272             [nsWindow makeKeyAndOrderFront:nsWindow];
1273         } else {
1274             [nsWindow orderFront:nsWindow];
1275         }
1276     }];
1277 
1278 JNF_COCOA_EXIT(env);
1279 }
1280 
1281 /*
1282  * Class:     sun_lwawt_macosx_CPlatformWindow
1283  * Method:    nativeSetNSWindowTitle
1284  * Signature: (JLjava/lang/String;)V
1285  */
1286 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowTitle
1287 (JNIEnv *env, jclass clazz, jlong windowPtr, jstring jtitle)
1288 {
1289 JNF_COCOA_ENTER(env);
1290 
1291     NSWindow *nsWindow = OBJC(windowPtr);
1292     [nsWindow performSelectorOnMainThread:@selector(setTitle:)
1293                               withObject:JNFJavaToNSString(env, jtitle)
1294                            waitUntilDone:NO];
1295 
1296 JNF_COCOA_EXIT(env);
1297 }
1298 
1299 /*
1300  * Class:     sun_lwawt_macosx_CPlatformWindow
1301  * Method:    nativeRevalidateNSWindowShadow
1302  * Signature: (J)V
1303  */
1304 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeRevalidateNSWindowShadow
1305 (JNIEnv *env, jclass clazz, jlong windowPtr)
1306 {
1307 JNF_COCOA_ENTER(env);
1308 
1309     NSWindow *nsWindow = OBJC(windowPtr);
1310     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1311         [nsWindow invalidateShadow];
1312     }];
1313 
1314 JNF_COCOA_EXIT(env);
1315 }
1316 
1317 /*
1318  * Class:     sun_lwawt_macosx_CPlatformWindow
1319  * Method:    nativeScreenOn_AppKitThread
1320  * Signature: (J)I
1321  */
1322 JNIEXPORT jint JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeScreenOn_1AppKitThread
1323 (JNIEnv *env, jclass clazz, jlong windowPtr)
1324 {
1325     jint ret = 0;
1326 
1327 JNF_COCOA_ENTER(env);
1328 AWT_ASSERT_APPKIT_THREAD;
1329 
1330     NSWindow *nsWindow = OBJC(windowPtr);
1331     NSDictionary *props = [[nsWindow screen] deviceDescription];
1332     ret = [[props objectForKey:@"NSScreenNumber"] intValue];
1333 
1334 JNF_COCOA_EXIT(env);
1335 
1336     return ret;
1337 }
1338 
1339 /*
1340  * Class:     sun_lwawt_macosx_CPlatformWindow
1341  * Method:    nativeSetNSWindowMinimizedIcon
1342  * Signature: (JJ)V
1343  */
1344 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowMinimizedIcon
1345 (JNIEnv *env, jclass clazz, jlong windowPtr, jlong nsImagePtr)
1346 {
1347 JNF_COCOA_ENTER(env);
1348 
1349     NSWindow *nsWindow = OBJC(windowPtr);
1350     NSImage *image = OBJC(nsImagePtr);
1351     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1352         [nsWindow setMiniwindowImage:image];
1353     }];
1354 
1355 JNF_COCOA_EXIT(env);
1356 }
1357 
1358 /*
1359  * Class:     sun_lwawt_macosx_CPlatformWindow
1360  * Method:    nativeSetNSWindowRepresentedFilename
1361  * Signature: (JLjava/lang/String;)V
1362  */
1363 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetNSWindowRepresentedFilename
1364 (JNIEnv *env, jclass clazz, jlong windowPtr, jstring filename)
1365 {
1366 JNF_COCOA_ENTER(env);
1367 
1368     NSWindow *nsWindow = OBJC(windowPtr);
1369     NSURL *url = (filename == NULL) ? nil : [NSURL fileURLWithPath:JNFNormalizedNSStringForPath(env, filename)];
1370     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1371         [nsWindow setRepresentedURL:url];
1372     }];
1373 
1374 JNF_COCOA_EXIT(env);
1375 }
1376 
1377 /*
1378  * Class:     sun_lwawt_macosx_CPlatformWindow
1379  * Method:    nativeGetTopmostPlatformWindowUnderMouse
1380  * Signature: (J)V
1381  */
1382 JNIEXPORT jobject
1383 JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeGetTopmostPlatformWindowUnderMouse
1384 (JNIEnv *env, jclass clazz)
1385 {
1386     __block jobject topmostWindowUnderMouse = nil;
1387 
1388     JNF_COCOA_ENTER(env);
1389 
1390     [ThreadUtilities performOnMainThreadWaiting:YES block:^{
1391         AWTWindow *awtWindow = [AWTWindow getTopmostWindowUnderMouse];
1392         if (awtWindow != nil) {
1393             topmostWindowUnderMouse = [awtWindow.javaPlatformWindow jObject];
1394         }
1395     }];
1396 
1397     JNF_COCOA_EXIT(env);
1398 
1399     return topmostWindowUnderMouse;
1400 }
1401 
1402 /*
1403  * Class:     sun_lwawt_macosx_CPlatformWindow
1404  * Method:    nativeSynthesizeMouseEnteredExitedEvents
1405  * Signature: ()V
1406  */
1407 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSynthesizeMouseEnteredExitedEvents__
1408 (JNIEnv *env, jclass clazz)
1409 {
1410     JNF_COCOA_ENTER(env);
1411 
1412     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1413         [AWTWindow synthesizeMouseEnteredExitedEventsForAllWindows];
1414     }];
1415 
1416     JNF_COCOA_EXIT(env);
1417 }
1418 
1419 /*
1420  * Class:     sun_lwawt_macosx_CPlatformWindow
1421  * Method:    nativeSynthesizeMouseEnteredExitedEvents
1422  * Signature: (JI)V
1423  */
1424 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSynthesizeMouseEnteredExitedEvents__JI
1425 (JNIEnv *env, jclass clazz, jlong windowPtr, jint eventType)
1426 {
1427 JNF_COCOA_ENTER(env);
1428 
1429     if (eventType == NSMouseEntered || eventType == NSMouseExited) {
1430         NSWindow *nsWindow = OBJC(windowPtr);
1431 
1432         [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1433             [AWTWindow synthesizeMouseEnteredExitedEvents:nsWindow withType:eventType];
1434         }];
1435     } else {
1436         [JNFException raise:env as:kIllegalArgumentException reason:"unknown event type"];
1437     }
1438 
1439 JNF_COCOA_EXIT(env);
1440 }
1441 
1442 /*
1443  * Class:     sun_lwawt_macosx_CPlatformWindow
1444  * Method:    _toggleFullScreenMode
1445  * Signature: (J)V
1446  */
1447 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow__1toggleFullScreenMode
1448 (JNIEnv *env, jobject peer, jlong windowPtr)
1449 {
1450 JNF_COCOA_ENTER(env);
1451 
1452     NSWindow *nsWindow = OBJC(windowPtr);
1453     SEL toggleFullScreenSelector = @selector(toggleFullScreen:);
1454     if (![nsWindow respondsToSelector:toggleFullScreenSelector]) return;
1455 
1456     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1457         [nsWindow performSelector:toggleFullScreenSelector withObject:nil];
1458     }];
1459 
1460 JNF_COCOA_EXIT(env);
1461 }
1462 
1463 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeSetEnabled
1464 (JNIEnv *env, jclass clazz, jlong windowPtr, jboolean isEnabled)
1465 {
1466 JNF_COCOA_ENTER(env);
1467 
1468     NSWindow *nsWindow = OBJC(windowPtr);
1469     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1470         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1471 
1472         [window setEnabled: isEnabled];
1473     }];
1474 
1475 JNF_COCOA_EXIT(env);
1476 }
1477 
1478 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeDispose
1479 (JNIEnv *env, jclass clazz, jlong windowPtr)
1480 {
1481 JNF_COCOA_ENTER(env);
1482 
1483     NSWindow *nsWindow = OBJC(windowPtr);
1484     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1485         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1486 
1487         if ([AWTWindow lastKeyWindow] == window) {
1488             [AWTWindow setLastKeyWindow: nil];
1489         }
1490 
1491         // AWTWindow holds a reference to the NSWindow in its nsWindow
1492         // property. Unsetting the delegate allows it to be deallocated
1493         // which releases the reference. This, in turn, allows the window
1494         // itself be deallocated.
1495         [nsWindow setDelegate: nil];
1496 
1497         [window release];
1498     }];
1499 
1500 JNF_COCOA_EXIT(env);
1501 }
1502 
1503 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeEnterFullScreenMode
1504 (JNIEnv *env, jclass clazz, jlong windowPtr)
1505 {
1506 JNF_COCOA_ENTER(env);
1507 
1508     NSWindow *nsWindow = OBJC(windowPtr);
1509     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1510         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1511         NSNumber* screenID = [AWTWindow getNSWindowDisplayID_AppKitThread: nsWindow];
1512         CGDirectDisplayID aID = [screenID intValue];
1513 
1514         if (CGDisplayCapture(aID) == kCGErrorSuccess) {
1515             // remove window decoration
1516             NSUInteger styleMask = [AWTWindow styleMaskForStyleBits:window.styleBits];
1517             [nsWindow setStyleMask:(styleMask & ~NSTitledWindowMask) | NSBorderlessWindowMask];
1518 
1519             int shieldLevel = CGShieldingWindowLevel();
1520             window.preFullScreenLevel = [nsWindow level];
1521             [nsWindow setLevel: shieldLevel];
1522 
1523             NSRect screenRect = [[nsWindow screen] frame];
1524             [nsWindow setFrame:screenRect display:YES];
1525         } else {
1526             [JNFException raise:[ThreadUtilities getJNIEnv]
1527                              as:kRuntimeException
1528                          reason:"Failed to enter full screen."];
1529         }
1530     }];
1531 
1532 JNF_COCOA_EXIT(env);
1533 }
1534 
1535 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CPlatformWindow_nativeExitFullScreenMode
1536 (JNIEnv *env, jclass clazz, jlong windowPtr)
1537 {
1538 JNF_COCOA_ENTER(env);
1539 
1540     NSWindow *nsWindow = OBJC(windowPtr);
1541     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1542         AWTWindow *window = (AWTWindow*)[nsWindow delegate];
1543         NSNumber* screenID = [AWTWindow getNSWindowDisplayID_AppKitThread: nsWindow];
1544         CGDirectDisplayID aID = [screenID intValue];
1545 
1546         if (CGDisplayRelease(aID) == kCGErrorSuccess) {
1547             NSUInteger styleMask = [AWTWindow styleMaskForStyleBits:window.styleBits];
1548             [nsWindow setStyleMask:styleMask];
1549             [nsWindow setLevel: window.preFullScreenLevel];
1550 
1551             // GraphicsDevice takes care of restoring pre full screen bounds
1552         } else {
1553             [JNFException raise:[ThreadUtilities getJNIEnv]
1554                              as:kRuntimeException
1555                          reason:"Failed to exit full screen."];
1556         }
1557     }];
1558 
1559 JNF_COCOA_EXIT(env);
1560 }
1561 
--- EOF ---