1 /*
   2  * Copyright (c) 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 "jni_util.h"
  27 #import "CGLGraphicsConfig.h"
  28 #import "AWTView.h"
  29 #import "AWTWindow.h"
  30 #import "JavaComponentAccessibility.h"
  31 #import "JavaTextAccessibility.h"
  32 #import "JavaAccessibilityUtilities.h"
  33 #import "GeomUtilities.h"
  34 #import "OSVersion.h"
  35 #import "ThreadUtilities.h"
  36 
  37 #import <JavaNativeFoundation/JavaNativeFoundation.h>
  38 
  39 @interface AWTView()
  40 @property (retain) CDropTarget *_dropTarget;
  41 @property (retain) CDragSource *_dragSource;
  42 
  43 -(void) deliverResize: (NSRect) rect;
  44 -(void) resetTrackingArea;
  45 -(void) deliverJavaKeyEventHelper: (NSEvent*) event;
  46 -(BOOL) isCodePointInUnicodeBlockNeedingIMEvent: (unichar) codePoint;
  47 -(NSMutableString *) parseString : (id) complexString;
  48 @end
  49 
  50 // Uncomment this line to see fprintfs of each InputMethod API being called on this View
  51 //#define IM_DEBUG TRUE
  52 //#define EXTRA_DEBUG
  53 
  54 static BOOL shouldUsePressAndHold() {
  55     static int shouldUsePressAndHold = -1;
  56     if (shouldUsePressAndHold != -1) return shouldUsePressAndHold;
  57     shouldUsePressAndHold = !isSnowLeopardOrLower();
  58     return shouldUsePressAndHold;
  59 }
  60 
  61 @implementation AWTView
  62 
  63 @synthesize _dropTarget;
  64 @synthesize _dragSource;
  65 @synthesize cglLayer;
  66 @synthesize mouseIsOver;
  67 
  68 // Note: Must be called on main (AppKit) thread only
  69 - (id) initWithRect: (NSRect) rect
  70        platformView: (jobject) cPlatformView
  71         windowLayer: (CALayer*) windowLayer
  72 {
  73     AWT_ASSERT_APPKIT_THREAD;
  74     // Initialize ourselves
  75     self = [super initWithFrame: rect];
  76     if (self == nil) return self;
  77     
  78     m_cPlatformView = cPlatformView;
  79     fInputMethodLOCKABLE = NULL;
  80     fKeyEventsNeeded = NO;
  81     fProcessingKeystroke = NO;
  82     
  83     fEnablePressAndHold = shouldUsePressAndHold();
  84     fInPressAndHold = NO;
  85     fPAHNeedsToSelect = NO;
  86     
  87     mouseIsOver = NO;
  88     [self resetTrackingArea];
  89     [self setAutoresizesSubviews:NO];
  90     
  91     if (windowLayer != nil) {
  92         self.cglLayer = windowLayer;
  93         //Layer hosting view
  94         [self setLayer: cglLayer];
  95         [self setWantsLayer: YES];
  96         //Layer backed view
  97         //[self.layer addSublayer: (CALayer *)cglLayer];
  98         //[self setLayerContentsRedrawPolicy: NSViewLayerContentsRedrawDuringViewResize];
  99         //[self setLayerContentsPlacement: NSViewLayerContentsPlacementTopLeft];
 100         //[self setAutoresizingMask: NSViewHeightSizable | NSViewWidthSizable];
 101         
 102 #ifdef REMOTELAYER
 103         CGLLayer *parentLayer = (CGLLayer*)self.cglLayer;
 104         parentLayer.parentLayer = NULL;
 105         parentLayer.remoteLayer = NULL;
 106         if (JRSRemotePort != 0 && remoteSocketFD > 0) {
 107             CGLLayer *remoteLayer = [[CGLLayer alloc] initWithJavaLayer: parentLayer.javaLayer];
 108             remoteLayer.target = GL_TEXTURE_2D;
 109             NSLog(@"Creating Parent=%p, Remote=%p", parentLayer, remoteLayer);
 110             parentLayer.remoteLayer = remoteLayer;
 111             remoteLayer.parentLayer = parentLayer;
 112             remoteLayer.remoteLayer = NULL;
 113             remoteLayer.jrsRemoteLayer = [remoteLayer createRemoteLayerBoundTo:JRSRemotePort];
 114             [remoteLayer retain];  // REMIND
 115             remoteLayer.frame = CGRectMake(0, 0, 720, 500); // REMIND
 116             [remoteLayer.jrsRemoteLayer retain]; // REMIND
 117             int layerID = [remoteLayer.jrsRemoteLayer layerID];
 118             NSLog(@"layer id to send = %d", layerID);
 119             sendLayerID(layerID);
 120         }
 121 #endif /* REMOTELAYER */
 122     }
 123     
 124     return self;
 125 }
 126 
 127 - (void) dealloc {
 128     AWT_ASSERT_APPKIT_THREAD;
 129     
 130     self.cglLayer = nil;
 131     
 132     JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 133     (*env)->DeleteWeakGlobalRef(env, m_cPlatformView);
 134     m_cPlatformView = NULL;
 135     
 136     if (fInputMethodLOCKABLE != NULL)
 137     {
 138         JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 139         
 140         JNFDeleteGlobalRef(env, fInputMethodLOCKABLE);
 141         fInputMethodLOCKABLE = NULL;
 142     }
 143     
 144     
 145     [super dealloc];
 146 }
 147 
 148 - (void) viewDidMoveToWindow {
 149     AWT_ASSERT_APPKIT_THREAD;
 150     
 151     [AWTToolkit eventCountPlusPlus];
 152     
 153     [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^() {
 154         [[self window] makeFirstResponder: self];
 155     }];
 156     if ([self window] != NULL) {
 157         [self resetTrackingArea];
 158     }
 159 }
 160 
 161 - (BOOL) acceptsFirstMouse: (NSEvent *)event {
 162     return YES;
 163 }
 164 
 165 - (BOOL) acceptsFirstResponder {
 166     return YES;
 167 }
 168 
 169 - (BOOL) becomeFirstResponder {
 170     return YES;
 171 }
 172 
 173 - (BOOL) preservesContentDuringLiveResize {
 174     return YES;
 175 }
 176 
 177 /*
 178  * Automatically triggered functions.
 179  */
 180 
 181 - (void)resizeWithOldSuperviewSize:(NSSize)oldBoundsSize {
 182     [super resizeWithOldSuperviewSize: oldBoundsSize];
 183     [self deliverResize: [self frame]];
 184 }
 185 
 186 /*
 187  * MouseEvents support
 188  */
 189 
 190 - (void) mouseDown: (NSEvent *)event {
 191     NSInputManager *inputManager = [NSInputManager currentInputManager];
 192     if ([inputManager wantsToHandleMouseEvents]) {
 193 #if IM_DEBUG
 194         NSLog(@"-> IM wants to handle event");
 195 #endif
 196         if (![inputManager handleMouseEvent:event]) {
 197             [self deliverJavaMouseEvent: event];
 198         } else {
 199 #if IM_DEBUG
 200             NSLog(@"-> Event was handled.");
 201 #endif
 202         }
 203     } else {
 204 #if IM_DEBUG
 205         NSLog(@"-> IM does not want to handle event");
 206 #endif
 207         [self deliverJavaMouseEvent: event];
 208     }
 209 }
 210 
 211 - (void) mouseUp: (NSEvent *)event {
 212     [self deliverJavaMouseEvent: event];
 213 }
 214 
 215 - (void) rightMouseDown: (NSEvent *)event {
 216     [self deliverJavaMouseEvent: event];
 217 }
 218 
 219 - (void) rightMouseUp: (NSEvent *)event {
 220     [self deliverJavaMouseEvent: event];
 221 }
 222 
 223 - (void) otherMouseDown: (NSEvent *)event {
 224     [self deliverJavaMouseEvent: event];
 225 }
 226 
 227 - (void) otherMouseUp: (NSEvent *)event {
 228     [self deliverJavaMouseEvent: event];
 229 }
 230 
 231 - (void) mouseMoved: (NSEvent *)event {
 232     // TODO: better way to redirect move events to the "under" view
 233     
 234     NSPoint eventLocation = [event locationInWindow];
 235     NSPoint localPoint = [self convertPoint: eventLocation fromView: nil];
 236     
 237     if  ([self mouse: localPoint inRect: [self bounds]]) {
 238         [self deliverJavaMouseEvent: event];
 239     } else {
 240         [[self nextResponder] mouseDown:event];
 241     }
 242 }
 243 
 244 - (void) mouseDragged: (NSEvent *)event {
 245     [self deliverJavaMouseEvent: event];
 246 }
 247 
 248 - (void) rightMouseDragged: (NSEvent *)event {
 249     [self deliverJavaMouseEvent: event];
 250 }
 251 
 252 - (void) otherMouseDragged: (NSEvent *)event {
 253     [self deliverJavaMouseEvent: event];
 254 }
 255 
 256 - (void) mouseEntered: (NSEvent *)event {
 257     [[self window] setAcceptsMouseMovedEvents:YES];
 258     //[[self window] makeFirstResponder:self];
 259     [self deliverJavaMouseEvent: event];
 260 }
 261 
 262 - (void) mouseExited: (NSEvent *)event {
 263     [[self window] setAcceptsMouseMovedEvents:NO];
 264     [self deliverJavaMouseEvent: event];
 265     //Restore the cursor back.
 266     //[CCursorManager _setCursor: [NSCursor arrowCursor]];
 267 }
 268 
 269 - (void) scrollWheel: (NSEvent*) event {
 270     [self deliverJavaMouseEvent: event];
 271 }
 272 
 273 /*
 274  * KeyEvents support
 275  */
 276 
 277 - (void) keyDown: (NSEvent *)event {
 278     fProcessingKeystroke = YES;
 279     fKeyEventsNeeded = YES;
 280     
 281     // Allow TSM to look at the event and potentially send back NSTextInputClient messages.
 282     [self interpretKeyEvents:[NSArray arrayWithObject:event]];
 283     
 284     if (fEnablePressAndHold && [event willBeHandledByComplexInputMethod]) {
 285         fProcessingKeystroke = NO;
 286         if (!fInPressAndHold) {
 287             fInPressAndHold = YES;
 288             fPAHNeedsToSelect = YES;
 289         }
 290         return;
 291     }
 292     
 293     NSString *eventCharacters = [event characters];
 294     BOOL isDeadKey = (eventCharacters != nil && [eventCharacters length] == 0);
 295     
 296     if ((![self hasMarkedText] && fKeyEventsNeeded) || isDeadKey) {
 297         [self deliverJavaKeyEventHelper: event];
 298     }
 299     
 300     fProcessingKeystroke = NO;
 301 }
 302 
 303 - (void) keyUp: (NSEvent *)event {
 304     [self deliverJavaKeyEventHelper: event];
 305 }
 306 
 307 - (void) flagsChanged: (NSEvent *)event {
 308     [self deliverJavaKeyEventHelper: event];
 309 }
 310 
 311 - (BOOL) performKeyEquivalent: (NSEvent *) event {
 312     // if IM is active key events should be ignored
 313     if (![self hasMarkedText] && !fInPressAndHold) {
 314         [self deliverJavaKeyEventHelper: event];
 315     }
 316     
 317     // Workaround for 8020209: special case for "Cmd =" and "Cmd ."
 318     // because Cocoa calls performKeyEquivalent twice for these keystrokes
 319     NSUInteger modFlags = [event modifierFlags] &
 320     (NSCommandKeyMask | NSAlternateKeyMask | NSShiftKeyMask | NSControlKeyMask);
 321     if (modFlags == NSCommandKeyMask) {
 322         NSString *eventChars = [event charactersIgnoringModifiers];
 323         if ([eventChars length] == 1) {
 324             unichar ch = [eventChars characterAtIndex:0];
 325             if (ch == '=' || ch == '.') {
 326                 [[NSApp mainMenu] performKeyEquivalent: event];
 327                 return YES;
 328             }
 329         }
 330         
 331     }
 332     
 333     return NO;
 334 }
 335 
 336 /**
 337  * Utility methods and accessors
 338  */
 339 
 340 -(void) deliverJavaMouseEvent: (NSEvent *) event {
 341     BOOL isEnabled = YES;
 342     NSWindow* window = [self window];
 343     if ([window isKindOfClass: [AWTWindow_Panel class]] || [window isKindOfClass: [AWTWindow_Normal class]]) {
 344         isEnabled = [(AWTWindow*)[window delegate] isEnabled];
 345     }
 346     
 347     if (!isEnabled) {
 348         return;
 349     }
 350     
 351     NSEventType type = [event type];
 352     
 353     // check synthesized mouse entered/exited events
 354     if ((type == NSMouseEntered && mouseIsOver) || (type == NSMouseExited && !mouseIsOver)) {
 355         return;
 356     }else if ((type == NSMouseEntered && !mouseIsOver) || (type == NSMouseExited && mouseIsOver)) {
 357         mouseIsOver = !mouseIsOver;
 358     }
 359     
 360     [AWTToolkit eventCountPlusPlus];
 361     
 362     JNIEnv *env = [ThreadUtilities getJNIEnv];
 363     
 364     NSPoint eventLocation = [event locationInWindow];
 365     NSPoint localPoint = [self convertPoint: eventLocation fromView: nil];
 366     NSPoint absP = [NSEvent mouseLocation];
 367     
 368     // Convert global numbers between Cocoa's coordinate system and Java.
 369     // TODO: need consitent way for doing that both with global as well as with local coordinates.
 370     // The reason to do it here is one more native method for getting screen dimension otherwise.
 371     
 372     NSRect screenRect = [[[NSScreen screens] objectAtIndex:0] frame];
 373     absP.y = screenRect.size.height - absP.y;
 374     jint clickCount;
 375     
 376     if (type == NSMouseEntered ||
 377         type == NSMouseExited ||
 378         type == NSScrollWheel ||
 379         type == NSMouseMoved) {
 380         clickCount = 0;
 381     } else {
 382         clickCount = [event clickCount];
 383     }
 384     
 385     static JNF_CLASS_CACHE(jc_NSEvent, "sun/lwawt/macosx/NSEvent");
 386     static JNF_CTOR_CACHE(jctor_NSEvent, jc_NSEvent, "(IIIIIIIIDD)V");
 387     jobject jEvent = JNFNewObject(env, jctor_NSEvent,
 388                                   [event type],
 389                                   [event modifierFlags],
 390                                   clickCount,
 391                                   [event buttonNumber],
 392                                   (jint)localPoint.x, (jint)localPoint.y,
 393                                   (jint)absP.x, (jint)absP.y,
 394                                   [event deltaY],
 395                                   [event deltaX]);

 396     CHECK_NULL(jEvent);
 397     
 398     static JNF_CLASS_CACHE(jc_PlatformView, "sun/lwawt/macosx/CPlatformView");
 399     static JNF_MEMBER_CACHE(jm_deliverMouseEvent, jc_PlatformView, "deliverMouseEvent", "(Lsun/lwawt/macosx/NSEvent;)V");
 400     jobject jlocal = (*env)->NewLocalRef(env, m_cPlatformView);
 401     if (!(*env)->IsSameObject(env, jlocal, NULL)) {
 402         JNFCallVoidMethod(env, jlocal, jm_deliverMouseEvent, jEvent);
 403         (*env)->DeleteLocalRef(env, jlocal);
 404     }
 405     (*env)->DeleteLocalRef(env, jEvent);
 406 }
 407 
 408 - (void) resetTrackingArea {
 409     if (rolloverTrackingArea != nil) {
 410         [self removeTrackingArea:rolloverTrackingArea];
 411         [rolloverTrackingArea release];
 412     }
 413     
 414     int options = (NSTrackingActiveAlways | NSTrackingMouseEnteredAndExited |
 415                    NSTrackingMouseMoved | NSTrackingEnabledDuringMouseDrag);
 416     
 417     rolloverTrackingArea = [[NSTrackingArea alloc] initWithRect:[self visibleRect]
 418                                                         options: options
 419                                                           owner:self
 420                                                        userInfo:nil
 421                             ];
 422     [self addTrackingArea:rolloverTrackingArea];
 423 }
 424 
 425 - (void)updateTrackingAreas {
 426     [super updateTrackingAreas];
 427     [self resetTrackingArea];
 428 }
 429 
 430 - (void) resetCursorRects {
 431     [super resetCursorRects];
 432     [self resetTrackingArea];
 433 }
 434 
 435 -(void) deliverJavaKeyEventHelper: (NSEvent *) event {
 436     static NSEvent* sLastKeyEvent = nil;
 437     if (event == sLastKeyEvent) {
 438         // The event is repeatedly delivered by keyDown: after performKeyEquivalent:
 439         return;
 440     }
 441     [sLastKeyEvent release];
 442     sLastKeyEvent = [event retain];
 443     
 444     [AWTToolkit eventCountPlusPlus];
 445     JNIEnv *env = [ThreadUtilities getJNIEnv];
 446     
 447     jstring characters = NULL;
 448     jstring charactersIgnoringModifiers = NULL;
 449     if ([event type] != NSFlagsChanged) {
 450         characters = JNFNSToJavaString(env, [event characters]);
 451         charactersIgnoringModifiers = JNFNSToJavaString(env, [event charactersIgnoringModifiers]);
 452     }
 453     
 454     static JNF_CLASS_CACHE(jc_NSEvent, "sun/lwawt/macosx/NSEvent");
 455     static JNF_CTOR_CACHE(jctor_NSEvent, jc_NSEvent, "(IISLjava/lang/String;Ljava/lang/String;)V");
 456     jobject jEvent = JNFNewObject(env, jctor_NSEvent,
 457                                   [event type],
 458                                   [event modifierFlags],
 459                                   [event keyCode],
 460                                   characters,
 461                                   charactersIgnoringModifiers);
 462     CHECK_NULL(jEvent);
 463     
 464     static JNF_CLASS_CACHE(jc_PlatformView, "sun/lwawt/macosx/CPlatformView");
 465     static JNF_MEMBER_CACHE(jm_deliverKeyEvent, jc_PlatformView,
 466                             "deliverKeyEvent", "(Lsun/lwawt/macosx/NSEvent;)V");
 467     jobject jlocal = (*env)->NewLocalRef(env, m_cPlatformView);
 468     if (!(*env)->IsSameObject(env, jlocal, NULL)) {
 469         JNFCallVoidMethod(env, jlocal, jm_deliverKeyEvent, jEvent);
 470         (*env)->DeleteLocalRef(env, jlocal);
 471     }
 472     if (characters != NULL) {
 473         (*env)->DeleteLocalRef(env, characters);
 474     }
 475     (*env)->DeleteLocalRef(env, jEvent);
 476 }
 477 
 478 -(void) deliverResize: (NSRect) rect {
 479     jint x = (jint) rect.origin.x;
 480     jint y = (jint) rect.origin.y;
 481     jint w = (jint) rect.size.width;
 482     jint h = (jint) rect.size.height;
 483     JNIEnv *env = [ThreadUtilities getJNIEnv];
 484     static JNF_CLASS_CACHE(jc_PlatformView, "sun/lwawt/macosx/CPlatformView");
 485     static JNF_MEMBER_CACHE(jm_deliverResize, jc_PlatformView, "deliverResize", "(IIII)V");
 486 
 487     jobject jlocal = (*env)->NewLocalRef(env, m_cPlatformView);
 488     if (!(*env)->IsSameObject(env, jlocal, NULL)) {
 489         JNFCallVoidMethod(env, jlocal, jm_deliverResize, x,y,w,h);
 490         (*env)->DeleteLocalRef(env, jlocal);
 491     }
 492 }
 493 
 494 
 495 - (void) drawRect:(NSRect)dirtyRect {
 496     AWT_ASSERT_APPKIT_THREAD;
 497     
 498     [super drawRect:dirtyRect];
 499     JNIEnv *env = [ThreadUtilities getJNIEnv];
 500     if (env != NULL) {
 501         /*
 502          if ([self inLiveResize]) {
 503          NSRect rs[4];
 504          NSInteger count;
 505          [self getRectsExposedDuringLiveResize:rs count:&count];
 506          for (int i = 0; i < count; i++) {
 507          JNU_CallMethodByName(env, NULL, [m_awtWindow cPlatformView],
 508          "deliverWindowDidExposeEvent", "(FFFF)V",
 509          (jfloat)rs[i].origin.x, (jfloat)rs[i].origin.y,
 510          (jfloat)rs[i].size.width, (jfloat)rs[i].size.height);
 511          if ((*env)->ExceptionOccurred(env)) {
 512          (*env)->ExceptionDescribe(env);
 513          (*env)->ExceptionClear(env);
 514          }
 515          }
 516          } else {
 517          */
 518         static JNF_CLASS_CACHE(jc_CPlatformView, "sun/lwawt/macosx/CPlatformView");
 519         static JNF_MEMBER_CACHE(jm_deliverWindowDidExposeEvent, jc_CPlatformView, "deliverWindowDidExposeEvent", "()V");
 520         jobject jlocal = (*env)->NewLocalRef(env, m_cPlatformView);
 521         if (!(*env)->IsSameObject(env, jlocal, NULL)) {
 522             JNFCallVoidMethod(env, jlocal, jm_deliverWindowDidExposeEvent);
 523             (*env)->DeleteLocalRef(env, jlocal);
 524         }
 525         /*
 526          }
 527          */
 528     }
 529 }
 530 
 531 -(BOOL) isCodePointInUnicodeBlockNeedingIMEvent: (unichar) codePoint {
 532     if (((codePoint >= 0x3000) && (codePoint <= 0x303F)) ||
 533         ((codePoint >= 0xFF00) && (codePoint <= 0xFFEF))) {
 534         // Code point is in 'CJK Symbols and Punctuation' or
 535         // 'Halfwidth and Fullwidth Forms' Unicode block.
 536         return YES;
 537     }
 538     return NO;
 539 }
 540 
 541 -(NSMutableString *) parseString : (id) complexString {
 542     if ([complexString isKindOfClass:[NSString class]]) {
 543         return [complexString mutableCopy];
 544     }
 545     else {
 546         return [complexString mutableString];
 547     }
 548 }
 549 
 550 // NSAccessibility support
 551 - (jobject)awtComponent:(JNIEnv*)env
 552 {
 553     static JNF_CLASS_CACHE(jc_CPlatformView, "sun/lwawt/macosx/CPlatformView");
 554     static JNF_MEMBER_CACHE(jf_Peer, jc_CPlatformView, "peer", "Lsun/lwawt/LWWindowPeer;");
 555     if ((env == NULL) || (m_cPlatformView == NULL)) {
 556         NSLog(@"Apple AWT : Error AWTView:awtComponent given bad parameters.");
 557         if (env != NULL)
 558         {
 559             JNFDumpJavaStack(env);
 560         }
 561         return NULL;
 562     }
 563 
 564     jobject peer = NULL;
 565     jobject jlocal = (*env)->NewLocalRef(env, m_cPlatformView);
 566     if (!(*env)->IsSameObject(env, jlocal, NULL)) {
 567         peer = JNFGetObjectField(env, jlocal, jf_Peer);
 568         (*env)->DeleteLocalRef(env, jlocal);
 569     }
 570     static JNF_CLASS_CACHE(jc_LWWindowPeer, "sun/lwawt/LWWindowPeer");
 571     static JNF_MEMBER_CACHE(jf_Target, jc_LWWindowPeer, "target", "Ljava/awt/Component;");
 572     if (peer == NULL) {
 573         NSLog(@"Apple AWT : Error AWTView:awtComponent got null peer from CPlatformView");
 574         JNFDumpJavaStack(env);
 575         return NULL;
 576     }
 577     jobject comp = JNFGetObjectField(env, peer, jf_Target);
 578     (*env)->DeleteLocalRef(env, peer);
 579     return comp;
 580 }
 581 
 582 + (AWTView *) awtView:(JNIEnv*)env ofAccessible:(jobject)jaccessible
 583 {
 584     static JNF_STATIC_MEMBER_CACHE(jm_getAWTView, sjc_CAccessibility, "getAWTView", "(Ljavax/accessibility/Accessible;)J");
 585 
 586     jlong jptr = JNFCallStaticLongMethod(env, jm_getAWTView, jaccessible);
 587     if (jptr == 0) return nil;
 588 
 589     return (AWTView *)jlong_to_ptr(jptr);
 590 }
 591 
 592 - (id)getAxData:(JNIEnv*)env
 593 {
 594     jobject jcomponent = [self awtComponent:env];
 595     id ax = [[[JavaComponentAccessibility alloc] initWithParent:self withEnv:env withAccessible:jcomponent withIndex:-1 withView:self withJavaRole:nil] autorelease];
 596     (*env)->DeleteLocalRef(env, jcomponent);
 597     return ax;
 598 }
 599 
 600 - (NSArray *)accessibilityAttributeNames
 601 {
 602     return [[super accessibilityAttributeNames] arrayByAddingObject:NSAccessibilityChildrenAttribute];
 603 }
 604 
 605 // NSAccessibility messages
 606 // attribute methods
 607 - (id)accessibilityAttributeValue:(NSString *)attribute
 608 {
 609     AWT_ASSERT_APPKIT_THREAD;
 610     
 611     if ([attribute isEqualToString:NSAccessibilityChildrenAttribute])
 612     {
 613         JNIEnv *env = [ThreadUtilities getJNIEnv];
 614         
 615         (*env)->PushLocalFrame(env, 4);
 616         
 617         id result = NSAccessibilityUnignoredChildrenForOnlyChild([self getAxData:env]);
 618         
 619         (*env)->PopLocalFrame(env, NULL);
 620         
 621         return result;
 622     }
 623     else
 624     {
 625         return [super accessibilityAttributeValue:attribute];
 626     }
 627 }
 628 - (BOOL)accessibilityIsIgnored
 629 {
 630     return YES;
 631 }
 632 
 633 - (id)accessibilityHitTest:(NSPoint)point
 634 {
 635     AWT_ASSERT_APPKIT_THREAD;
 636     JNIEnv *env = [ThreadUtilities getJNIEnv];
 637     
 638     (*env)->PushLocalFrame(env, 4);
 639     
 640     id result = [[self getAxData:env] accessibilityHitTest:point withEnv:env];
 641     
 642     (*env)->PopLocalFrame(env, NULL);
 643     
 644     return result;
 645 }
 646 
 647 - (id)accessibilityFocusedUIElement
 648 {
 649     AWT_ASSERT_APPKIT_THREAD;
 650     
 651     JNIEnv *env = [ThreadUtilities getJNIEnv];
 652     
 653     (*env)->PushLocalFrame(env, 4);
 654     
 655     id result = [[self getAxData:env] accessibilityFocusedUIElement];
 656     
 657     (*env)->PopLocalFrame(env, NULL);
 658     
 659     return result;
 660 }
 661 
 662 // --- Services menu support for lightweights ---
 663 
 664 // finds the focused accessible element, and if it is a text element, obtains the text from it
 665 - (NSString *)accessibleSelectedText
 666 {
 667     id focused = [self accessibilityFocusedUIElement];
 668     if (![focused isKindOfClass:[JavaTextAccessibility class]]) return nil;
 669     return [(JavaTextAccessibility *)focused accessibilitySelectedTextAttribute];
 670 }
 671 
 672 // same as above, but converts to RTFD
 673 - (NSData *)accessibleSelectedTextAsRTFD
 674 {
 675     NSString *selectedText = [self accessibleSelectedText];
 676     NSAttributedString *styledText = [[NSAttributedString alloc] initWithString:selectedText];
 677     NSData *rtfdData = [styledText RTFDFromRange:NSMakeRange(0, [styledText length])
 678                               documentAttributes:
 679                                 @{NSDocumentTypeDocumentAttribute: NSRTFTextDocumentType}];
 680     [styledText release];
 681     return rtfdData;
 682 }
 683 
 684 // finds the focused accessible element, and if it is a text element, sets the text in it
 685 - (BOOL)replaceAccessibleTextSelection:(NSString *)text
 686 {
 687     id focused = [self accessibilityFocusedUIElement];
 688     if (![focused isKindOfClass:[JavaTextAccessibility class]]) return NO;
 689     [(JavaTextAccessibility *)focused accessibilitySetSelectedTextAttribute:text];
 690     return YES;
 691 }
 692 
 693 // called for each service in the Services menu - only handle text for now
 694 - (id)validRequestorForSendType:(NSString *)sendType returnType:(NSString *)returnType
 695 {
 696     if ([[self window] firstResponder] != self) return nil; // let AWT components handle themselves
 697     
 698     if ([sendType isEqual:NSStringPboardType] || [returnType isEqual:NSStringPboardType]) {
 699         NSString *selectedText = [self accessibleSelectedText];
 700         if (selectedText) return self;
 701     }
 702     
 703     return nil;
 704 }
 705 
 706 // fetch text from Java and hand off to the service
 707 - (BOOL)writeSelectionToPasteboard:(NSPasteboard *)pboard types:(NSArray *)types
 708 {
 709     if ([types containsObject:NSStringPboardType])
 710     {
 711         [pboard declareTypes:[NSArray arrayWithObject:NSStringPboardType] owner:nil];
 712         return [pboard setString:[self accessibleSelectedText] forType:NSStringPboardType];
 713     }
 714     
 715     if ([types containsObject:NSRTFDPboardType])
 716     {
 717         [pboard declareTypes:[NSArray arrayWithObject:NSRTFDPboardType] owner:nil];
 718         return [pboard setData:[self accessibleSelectedTextAsRTFD] forType:NSRTFDPboardType];
 719     }
 720     
 721     return NO;
 722 }
 723 
 724 // write text back to Java from the service
 725 - (BOOL)readSelectionFromPasteboard:(NSPasteboard *)pboard
 726 {
 727     if ([[pboard types] containsObject:NSStringPboardType])
 728     {
 729         NSString *text = [pboard stringForType:NSStringPboardType];
 730         return [self replaceAccessibleTextSelection:text];
 731     }
 732     
 733     if ([[pboard types] containsObject:NSRTFDPboardType])
 734     {
 735         NSData *rtfdData = [pboard dataForType:NSRTFDPboardType];
 736         NSAttributedString *styledText = [[NSAttributedString alloc] initWithRTFD:rtfdData documentAttributes:NULL];
 737         NSString *text = [styledText string];
 738         [styledText release];
 739         
 740         return [self replaceAccessibleTextSelection:text];
 741     }
 742     
 743     return NO;
 744 }
 745 
 746 
 747 -(void) setDragSource:(CDragSource *)source {
 748     self._dragSource = source;
 749 }
 750 
 751 
 752 - (void) setDropTarget:(CDropTarget *)target {
 753     self._dropTarget = target;
 754     [ThreadUtilities performOnMainThread:@selector(controlModelControlValid) on:self._dropTarget withObject:nil waitUntilDone:YES];
 755 }
 756 
 757 /********************************  BEGIN NSDraggingSource Interface  ********************************/
 758 
 759 - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)flag
 760 {
 761     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 762     CDragSource *dragSource = self._dragSource;
 763     NSDragOperation dragOp = NSDragOperationNone;
 764     
 765     if (dragSource != nil)
 766         dragOp = [dragSource draggingSourceOperationMaskForLocal:flag];
 767     else if ([super respondsToSelector:@selector(draggingSourceOperationMaskForLocal:)])
 768         dragOp = [super draggingSourceOperationMaskForLocal:flag];
 769     
 770     return dragOp;
 771 }
 772 
 773 - (NSArray *)namesOfPromisedFilesDroppedAtDestination:(NSURL *)dropDestination
 774 {
 775     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 776     CDragSource *dragSource = self._dragSource;
 777     NSArray* array = nil;
 778     
 779     if (dragSource != nil)
 780         array = [dragSource namesOfPromisedFilesDroppedAtDestination:dropDestination];
 781     else if ([super respondsToSelector:@selector(namesOfPromisedFilesDroppedAtDestination:)])
 782         array = [super namesOfPromisedFilesDroppedAtDestination:dropDestination];
 783     
 784     return array;
 785 }
 786 
 787 - (void)draggedImage:(NSImage *)image beganAt:(NSPoint)screenPoint
 788 {
 789     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 790     CDragSource *dragSource = self._dragSource;
 791     
 792     if (dragSource != nil)
 793         [dragSource draggedImage:image beganAt:screenPoint];
 794     else if ([super respondsToSelector:@selector(draggedImage::)])
 795         [super draggedImage:image beganAt:screenPoint];
 796 }
 797 
 798 - (void)draggedImage:(NSImage *)image endedAt:(NSPoint)screenPoint operation:(NSDragOperation)operation
 799 {
 800     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 801     CDragSource *dragSource = self._dragSource;
 802     
 803     if (dragSource != nil)
 804         [dragSource draggedImage:image endedAt:screenPoint operation:operation];
 805     else if ([super respondsToSelector:@selector(draggedImage:::)])
 806         [super draggedImage:image endedAt:screenPoint operation:operation];
 807 }
 808 
 809 - (void)draggedImage:(NSImage *)image movedTo:(NSPoint)screenPoint
 810 {
 811     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 812     CDragSource *dragSource = self._dragSource;
 813     
 814     if (dragSource != nil)
 815         [dragSource draggedImage:image movedTo:screenPoint];
 816     else if ([super respondsToSelector:@selector(draggedImage::)])
 817         [super draggedImage:image movedTo:screenPoint];
 818 }
 819 
 820 - (BOOL)ignoreModifierKeysWhileDragging
 821 {
 822     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 823     CDragSource *dragSource = self._dragSource;
 824     BOOL result = FALSE;
 825     
 826     if (dragSource != nil)
 827         result = [dragSource ignoreModifierKeysWhileDragging];
 828     else if ([super respondsToSelector:@selector(ignoreModifierKeysWhileDragging)])
 829         result = [super ignoreModifierKeysWhileDragging];
 830     
 831     return result;
 832 }
 833 
 834 /********************************  END NSDraggingSource Interface  ********************************/
 835 
 836 /********************************  BEGIN NSDraggingDestination Interface  ********************************/
 837 
 838 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 839 {
 840     // If draggingDestination is nil route the message to the superclass:
 841     CDropTarget *dropTarget = self._dropTarget;
 842     NSDragOperation dragOp = NSDragOperationNone;
 843     
 844     if (dropTarget != nil)
 845         dragOp = [dropTarget draggingEntered:sender];
 846     else if ([super respondsToSelector:@selector(draggingEntered:)])
 847         dragOp = [super draggingEntered:sender];
 848     
 849     return dragOp;
 850 }
 851 
 852 - (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 853 {
 854     // If draggingDestination is nil route the message to the superclass:
 855     CDropTarget *dropTarget = self._dropTarget;
 856     NSDragOperation dragOp = NSDragOperationNone;
 857     
 858     if (dropTarget != nil)
 859         dragOp = [dropTarget draggingUpdated:sender];
 860     else if ([super respondsToSelector:@selector(draggingUpdated:)])
 861         dragOp = [super draggingUpdated:sender];
 862     
 863     return dragOp;
 864 }
 865 
 866 - (void)draggingExited:(id <NSDraggingInfo>)sender
 867 {
 868     // If draggingDestination is nil route the message to the superclass:
 869     CDropTarget *dropTarget = self._dropTarget;
 870     
 871     if (dropTarget != nil)
 872         [dropTarget draggingExited:sender];
 873     else if ([super respondsToSelector:@selector(draggingExited:)])
 874         [super draggingExited:sender];
 875 }
 876 
 877 - (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender
 878 {
 879     // If draggingDestination is nil route the message to the superclass:
 880     CDropTarget *dropTarget = self._dropTarget;
 881     BOOL result = FALSE;
 882     
 883     if (dropTarget != nil)
 884         result = [dropTarget prepareForDragOperation:sender];
 885     else if ([super respondsToSelector:@selector(prepareForDragOperation:)])
 886         result = [super prepareForDragOperation:sender];
 887     
 888     return result;
 889 }
 890 
 891 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 892 {
 893     // If draggingDestination is nil route the message to the superclass:
 894     CDropTarget *dropTarget = self._dropTarget;
 895     BOOL result = FALSE;
 896     
 897     if (dropTarget != nil)
 898         result = [dropTarget performDragOperation:sender];
 899     else if ([super respondsToSelector:@selector(performDragOperation:)])
 900         result = [super performDragOperation:sender];
 901     
 902     return result;
 903 }
 904 
 905 - (void)concludeDragOperation:(id <NSDraggingInfo>)sender
 906 {
 907     // If draggingDestination is nil route the message to the superclass:
 908     CDropTarget *dropTarget = self._dropTarget;
 909     
 910     if (dropTarget != nil)
 911         [dropTarget concludeDragOperation:sender];
 912     else if ([super respondsToSelector:@selector(concludeDragOperation:)])
 913         [super concludeDragOperation:sender];
 914 }
 915 
 916 - (void)draggingEnded:(id <NSDraggingInfo>)sender
 917 {
 918     // If draggingDestination is nil route the message to the superclass:
 919     CDropTarget *dropTarget = self._dropTarget;
 920     
 921     if (dropTarget != nil)
 922         [dropTarget draggingEnded:sender];
 923     else if ([super respondsToSelector:@selector(draggingEnded:)])
 924         [super draggingEnded:sender];
 925 }
 926 
 927 /********************************  END NSDraggingDestination Interface  ********************************/
 928 
 929 /********************************  BEGIN NSTextInputClient Protocol  ********************************/
 930 
 931 
 932 JNF_CLASS_CACHE(jc_CInputMethod, "sun/lwawt/macosx/CInputMethod");
 933 
 934 - (void) insertText:(id)aString replacementRange:(NSRange)replacementRange
 935 {
 936 #ifdef IM_DEBUG
 937     fprintf(stderr, "AWTView InputMethod Selector Called : [insertText]: %s\n", [aString UTF8String]);
 938 #endif // IM_DEBUG
 939     
 940     if (fInputMethodLOCKABLE == NULL) {
 941         return;
 942     }
 943     
 944     // Insert happens at the end of PAH
 945     fInPressAndHold = NO;
 946     
 947     // insertText gets called when the user commits text generated from an input method.  It also gets
 948     // called during ordinary input as well.  We only need to send an input method event when we have marked
 949     // text, or 'text in progress'.  We also need to send the event if we get an insert text out of the blue!
 950     // (i.e., when the user uses the Character palette or Inkwell), or when the string to insert is a complex
 951     // Unicode value.
 952     
 953     NSMutableString * useString = [self parseString:aString];
 954     NSUInteger utf16Length = [useString lengthOfBytesUsingEncoding:NSUTF16StringEncoding];
 955     NSUInteger utf8Length = [useString lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 956     BOOL aStringIsComplex = NO;
 957     if ((utf16Length > 2) ||
 958         ((utf8Length > 1) && [self isCodePointInUnicodeBlockNeedingIMEvent:[useString characterAtIndex:0]])) {
 959         aStringIsComplex = YES;
 960     }
 961     
 962     if ([self hasMarkedText] || !fProcessingKeystroke || aStringIsComplex) {
 963         JNIEnv *env = [ThreadUtilities getJNIEnv];
 964         
 965         static JNF_MEMBER_CACHE(jm_selectPreviousGlyph, jc_CInputMethod, "selectPreviousGlyph", "()V");
 966         // We need to select the previous glyph so that it is overwritten.
 967         if (fPAHNeedsToSelect) {
 968             JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_selectPreviousGlyph);
 969             fPAHNeedsToSelect = NO;
 970         }
 971         
 972         static JNF_MEMBER_CACHE(jm_insertText, jc_CInputMethod, "insertText", "(Ljava/lang/String;)V");
 973         jstring insertedText =  JNFNSToJavaString(env, useString);
 974         JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_insertText, insertedText); // AWT_THREADING Safe (AWTRunLoopMode)
 975         (*env)->DeleteLocalRef(env, insertedText);
 976         
 977         // The input method event will create psuedo-key events for each character in the committed string.
 978         // We also don't want to send the character that triggered the insertText, usually a return. [3337563]
 979         fKeyEventsNeeded = NO;
 980     }
 981     fPAHNeedsToSelect = NO;
 982 }
 983 
 984 - (void) doCommandBySelector:(SEL)aSelector
 985 {
 986 #ifdef IM_DEBUG
 987     fprintf(stderr, "AWTView InputMethod Selector Called : [doCommandBySelector]\n");
 988     NSLog(@"%@", NSStringFromSelector(aSelector));
 989 #endif // IM_DEBUG
 990     if (@selector(insertNewline:) == aSelector || @selector(insertTab:) == aSelector || @selector(deleteBackward:) == aSelector)
 991     {
 992         fKeyEventsNeeded = YES;
 993     }
 994 }
 995 
 996 // setMarkedText: cannot take a nil first argument. aString can be NSString or NSAttributedString
 997 - (void) setMarkedText:(id)aString selectedRange:(NSRange)selectionRange replacementRange:(NSRange)replacementRange
 998 {
 999     if (!fInputMethodLOCKABLE)
1000         return;
1001     
1002     BOOL isAttributedString = [aString isKindOfClass:[NSAttributedString class]];
1003     NSAttributedString *attrString = (isAttributedString ? (NSAttributedString *)aString : nil);
1004     NSString *incomingString = (isAttributedString ? [aString string] : aString);
1005 #ifdef IM_DEBUG
1006     fprintf(stderr, "AWTView InputMethod Selector Called : [setMarkedText] \"%s\", loc=%lu, length=%lu\n", [incomingString UTF8String], (unsigned long)selectionRange.location, (unsigned long)selectionRange.length);
1007 #endif // IM_DEBUG
1008     static JNF_MEMBER_CACHE(jm_startIMUpdate, jc_CInputMethod, "startIMUpdate", "(Ljava/lang/String;)V");
1009     static JNF_MEMBER_CACHE(jm_addAttribute, jc_CInputMethod, "addAttribute", "(ZZII)V");
1010     static JNF_MEMBER_CACHE(jm_dispatchText, jc_CInputMethod, "dispatchText", "(IIZ)V");
1011     JNIEnv *env = [ThreadUtilities getJNIEnv];
1012     
1013     // NSInputContext already did the analysis of the TSM event and created attributes indicating
1014     // the underlining and color that should be done to the string.  We need to look at the underline
1015     // style and color to determine what kind of Java hilighting needs to be done.
1016     jstring inProcessText = JNFNSToJavaString(env, incomingString);
1017     JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_startIMUpdate, inProcessText); // AWT_THREADING Safe (AWTRunLoopMode)
1018     (*env)->DeleteLocalRef(env, inProcessText);
1019     
1020     if (isAttributedString) {
1021         NSUInteger length;
1022         NSRange effectiveRange;
1023         NSDictionary *attributes;
1024         length = [attrString length];
1025         effectiveRange = NSMakeRange(0, 0);
1026         while (NSMaxRange(effectiveRange) < length) {
1027             attributes = [attrString attributesAtIndex:NSMaxRange(effectiveRange)
1028                                         effectiveRange:&effectiveRange];
1029             if (attributes) {
1030                 BOOL isThickUnderline, isGray;
1031                 NSNumber *underlineSizeObj =
1032                 (NSNumber *)[attributes objectForKey:NSUnderlineStyleAttributeName];
1033                 NSInteger underlineSize = [underlineSizeObj integerValue];
1034                 isThickUnderline = (underlineSize > 1);
1035                 
1036                 NSColor *underlineColorObj =
1037                 (NSColor *)[attributes objectForKey:NSUnderlineColorAttributeName];
1038                 isGray = !([underlineColorObj isEqual:[NSColor blackColor]]);
1039                 
1040                 JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_addAttribute, isThickUnderline, isGray, effectiveRange.location, effectiveRange.length); // AWT_THREADING Safe (AWTRunLoopMode)
1041             }
1042         }
1043     }
1044     
1045     static JNF_MEMBER_CACHE(jm_selectPreviousGlyph, jc_CInputMethod, "selectPreviousGlyph", "()V");
1046     // We need to select the previous glyph so that it is overwritten.
1047     if (fPAHNeedsToSelect) {
1048         JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_selectPreviousGlyph);
1049         fPAHNeedsToSelect = NO;
1050     }
1051     
1052     JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_dispatchText, selectionRange.location, selectionRange.length, JNI_FALSE); // AWT_THREADING Safe (AWTRunLoopMode)
1053     
1054     // If the marked text is being cleared (zero-length string) don't handle the key event.
1055     if ([incomingString length] == 0) {
1056         fKeyEventsNeeded = NO;
1057     }
1058 }
1059 
1060 - (void) unmarkText
1061 {
1062 #ifdef IM_DEBUG
1063     fprintf(stderr, "AWTView InputMethod Selector Called : [unmarkText]\n");
1064 #endif // IM_DEBUG
1065     
1066     if (!fInputMethodLOCKABLE) {
1067         return;
1068     }
1069     
1070     // unmarkText cancels any input in progress and commits it to the text field.
1071     static JNF_MEMBER_CACHE(jm_unmarkText, jc_CInputMethod, "unmarkText", "()V");
1072     JNIEnv *env = [ThreadUtilities getJNIEnv];
1073     JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_unmarkText); // AWT_THREADING Safe (AWTRunLoopMode)
1074     
1075 }
1076 
1077 - (BOOL) hasMarkedText
1078 {
1079 #ifdef IM_DEBUG
1080     fprintf(stderr, "AWTView InputMethod Selector Called : [hasMarkedText]\n");
1081 #endif // IM_DEBUG
1082     
1083     if (!fInputMethodLOCKABLE) {
1084         return NO;
1085     }
1086     
1087     static JNF_MEMBER_CACHE(jf_fCurrentText, jc_CInputMethod, "fCurrentText", "Ljava/text/AttributedString;");
1088     static JNF_MEMBER_CACHE(jf_fCurrentTextLength, jc_CInputMethod, "fCurrentTextLength", "I");
1089     JNIEnv *env = [ThreadUtilities getJNIEnv];
1090     jobject currentText = JNFGetObjectField(env, fInputMethodLOCKABLE, jf_fCurrentText);
1091     
1092     jint currentTextLength = JNFGetIntField(env, fInputMethodLOCKABLE, jf_fCurrentTextLength);
1093     
1094     BOOL hasMarkedText = (currentText != NULL && currentTextLength > 0);
1095     
1096     if (currentText != NULL) {
1097         (*env)->DeleteLocalRef(env, currentText);
1098     }
1099     
1100     return hasMarkedText;
1101 }
1102 
1103 - (NSInteger) conversationIdentifier
1104 {
1105 #ifdef IM_DEBUG
1106     fprintf(stderr, "AWTView InputMethod Selector Called : [conversationIdentifier]\n");
1107 #endif // IM_DEBUG
1108     
1109     return (NSInteger) self;
1110 }
1111 
1112 /* Returns attributed string at the range.  This allows input mangers to
1113  query any range in backing-store (Andy's request)
1114  */
1115 - (NSAttributedString *) attributedSubstringForProposedRange:(NSRange)theRange actualRange:(NSRangePointer)actualRange
1116 {
1117 #ifdef IM_DEBUG
1118     fprintf(stderr, "AWTView InputMethod Selector Called : [attributedSubstringFromRange] location=%lu, length=%lu\n", (unsigned long)theRange.location, (unsigned long)theRange.length);
1119 #endif // IM_DEBUG
1120     
1121     static JNF_MEMBER_CACHE(jm_substringFromRange, jc_CInputMethod, "attributedSubstringFromRange", "(II)Ljava/lang/String;");
1122     JNIEnv *env = [ThreadUtilities getJNIEnv];
1123     jobject theString = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_substringFromRange, theRange.location, theRange.length); // AWT_THREADING Safe (AWTRunLoopMode)
1124     
1125     id result = [[[NSAttributedString alloc] initWithString:JNFJavaToNSString(env, theString)] autorelease];
1126 #ifdef IM_DEBUG
1127     NSLog(@"attributedSubstringFromRange returning \"%@\"", result);
1128 #endif // IM_DEBUG
1129     
1130     (*env)->DeleteLocalRef(env, theString);
1131     return result;
1132 }
1133 
1134 /* This method returns the range for marked region.  If hasMarkedText == false,
1135  it'll return NSNotFound location & 0 length range.
1136  */
1137 - (NSRange) markedRange
1138 {
1139     
1140 #ifdef IM_DEBUG
1141     fprintf(stderr, "AWTView InputMethod Selector Called : [markedRange]\n");
1142 #endif // IM_DEBUG
1143     
1144     if (!fInputMethodLOCKABLE) {
1145         return NSMakeRange(NSNotFound, 0);
1146     }
1147     
1148     static JNF_MEMBER_CACHE(jm_markedRange, jc_CInputMethod, "markedRange", "()[I");
1149     JNIEnv *env = [ThreadUtilities getJNIEnv];
1150     jarray array;
1151     jboolean isCopy;
1152     jint *_array;
1153     NSRange range = NSMakeRange(NSNotFound, 0);
1154     
1155     array = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_markedRange); // AWT_THREADING Safe (AWTRunLoopMode)
1156     
1157     if (array) {
1158         _array = (*env)->GetIntArrayElements(env, array, &isCopy);
1159         if (_array != NULL) {
1160             range.location = _array[0];
1161             range.length = _array[1];
1162 #ifdef IM_DEBUG
1163             fprintf(stderr, "markedRange returning (%lu, %lu)\n",
1164                     (unsigned long)range.location, (unsigned long)range.length);
1165 #endif // IM_DEBUG
1166             (*env)->ReleaseIntArrayElements(env, array, _array, 0);
1167         }
1168         (*env)->DeleteLocalRef(env, array);
1169     }
1170     
1171     return range;
1172 }
1173 
1174 /* This method returns the range for selected region.  Just like markedRange method,
1175  its location field contains char index from the text beginning.
1176  */
1177 - (NSRange) selectedRange
1178 {
1179     if (!fInputMethodLOCKABLE) {
1180         return NSMakeRange(NSNotFound, 0);
1181     }
1182     
1183     static JNF_MEMBER_CACHE(jm_selectedRange, jc_CInputMethod, "selectedRange", "()[I");
1184     JNIEnv *env = [ThreadUtilities getJNIEnv];
1185     jarray array;
1186     jboolean isCopy;
1187     jint *_array;
1188     NSRange range = NSMakeRange(NSNotFound, 0);
1189     
1190 #ifdef IM_DEBUG
1191     fprintf(stderr, "AWTView InputMethod Selector Called : [selectedRange]\n");
1192 #endif // IM_DEBUG
1193     
1194     array = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_selectedRange); // AWT_THREADING Safe (AWTRunLoopMode)
1195     if (array) {
1196         _array = (*env)->GetIntArrayElements(env, array, &isCopy);
1197         if (_array != NULL) {
1198             range.location = _array[0];
1199             range.length = _array[1];
1200             (*env)->ReleaseIntArrayElements(env, array, _array, 0);
1201         }
1202         (*env)->DeleteLocalRef(env, array);
1203     }
1204     
1205     return range;
1206 }
1207 
1208 /* This method returns the first frame of rects for theRange in screen coordindate system.
1209  */
1210 - (NSRect) firstRectForCharacterRange:(NSRange)theRange actualRange:(NSRangePointer)actualRange
1211 {
1212     if (!fInputMethodLOCKABLE) {
1213         return NSZeroRect;
1214     }
1215     
1216     static JNF_MEMBER_CACHE(jm_firstRectForCharacterRange, jc_CInputMethod,
1217                             "firstRectForCharacterRange", "(I)[I");
1218     JNIEnv *env = [ThreadUtilities getJNIEnv];
1219     jarray array;
1220     jboolean isCopy;
1221     jint *_array;
1222     NSRect rect;
1223     
1224 #ifdef IM_DEBUG
1225     fprintf(stderr,
1226             "AWTView InputMethod Selector Called : [firstRectForCharacterRange:] location=%lu, length=%lu\n",
1227             (unsigned long)theRange.location, (unsigned long)theRange.length);
1228 #endif // IM_DEBUG
1229     
1230     array = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_firstRectForCharacterRange,
1231                                 theRange.location); // AWT_THREADING Safe (AWTRunLoopMode)
1232     
1233     _array = (*env)->GetIntArrayElements(env, array, &isCopy);
1234     if (_array) {
1235         rect = ConvertNSScreenRect(env, NSMakeRect(_array[0], _array[1], _array[2], _array[3]));
1236         (*env)->ReleaseIntArrayElements(env, array, _array, 0);
1237     } else {
1238         rect = NSZeroRect;
1239     }
1240     (*env)->DeleteLocalRef(env, array);
1241     
1242 #ifdef IM_DEBUG
1243     fprintf(stderr,
1244             "firstRectForCharacterRange returning x=%f, y=%f, width=%f, height=%f\n",
1245             rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
1246 #endif // IM_DEBUG
1247     return rect;
1248 }
1249 
1250 /* This method returns the index for character that is nearest to thePoint.  thPoint is in
1251  screen coordinate system.
1252  */
1253 - (NSUInteger)characterIndexForPoint:(NSPoint)thePoint
1254 {
1255     if (!fInputMethodLOCKABLE) {
1256         return NSNotFound;
1257     }
1258     
1259     static JNF_MEMBER_CACHE(jm_characterIndexForPoint, jc_CInputMethod,
1260                             "characterIndexForPoint", "(II)I");
1261     JNIEnv *env = [ThreadUtilities getJNIEnv];
1262     
1263     NSPoint flippedLocation = ConvertNSScreenPoint(env, thePoint);
1264     
1265 #ifdef IM_DEBUG
1266     fprintf(stderr, "AWTView InputMethod Selector Called : [characterIndexForPoint:(NSPoint)thePoint] x=%f, y=%f\n", flippedLocation.x, flippedLocation.y);
1267 #endif // IM_DEBUG
1268     
1269     jint index = JNFCallIntMethod(env, fInputMethodLOCKABLE, jm_characterIndexForPoint, (jint)flippedLocation.x, (jint)flippedLocation.y); // AWT_THREADING Safe (AWTRunLoopMode)
1270     
1271 #ifdef IM_DEBUG
1272     fprintf(stderr, "characterIndexForPoint returning %ld\n", index);
1273 #endif // IM_DEBUG
1274     
1275     if (index == -1) {
1276         return NSNotFound;
1277     } else {
1278         return (NSUInteger)index;
1279     }
1280 }
1281 
1282 - (NSArray*) validAttributesForMarkedText
1283 {
1284 #ifdef IM_DEBUG
1285     fprintf(stderr, "AWTView InputMethod Selector Called : [validAttributesForMarkedText]\n");
1286 #endif // IM_DEBUG
1287     
1288     return [NSArray array];
1289 }
1290 
1291 - (void)setInputMethod:(jobject)inputMethod
1292 {
1293 #ifdef IM_DEBUG
1294     fprintf(stderr, "AWTView InputMethod Selector Called : [setInputMethod]\n");
1295 #endif // IM_DEBUG
1296     
1297     JNIEnv *env = [ThreadUtilities getJNIEnv];
1298     
1299     // Get rid of the old one
1300     if (fInputMethodLOCKABLE) {
1301         JNFDeleteGlobalRef(env, fInputMethodLOCKABLE);
1302     }
1303     
1304     // Save a global ref to the new input method.
1305     if (inputMethod != NULL)
1306         fInputMethodLOCKABLE = JNFNewGlobalRef(env, inputMethod);
1307     else
1308         fInputMethodLOCKABLE = NULL;
1309 }
1310 
1311 - (void)abandonInput
1312 {
1313 #ifdef IM_DEBUG
1314     fprintf(stderr, "AWTView InputMethod Selector Called : [abandonInput]\n");
1315 #endif // IM_DEBUG
1316     
1317     [ThreadUtilities performOnMainThread:@selector(markedTextAbandoned:) on:[NSInputManager currentInputManager] withObject:self waitUntilDone:YES];
1318     [self unmarkText];
1319 }
1320 
1321 /********************************   END NSTextInputClient Protocol   ********************************/
1322 
1323 
1324 
1325 
1326 @end // AWTView
1327 
1328 /*
1329  * Class:     sun_lwawt_macosx_CPlatformView
1330  * Method:    nativeCreateView
1331  * Signature: (IIII)J
1332  */
1333 JNIEXPORT jlong JNICALL
1334 Java_sun_lwawt_macosx_CPlatformView_nativeCreateView
1335 (JNIEnv *env, jobject obj, jint originX, jint originY, jint width, jint height, jlong windowLayerPtr)
1336 {
1337     __block AWTView *newView = nil;
1338     
1339     JNF_COCOA_ENTER(env);
1340     
1341     NSRect rect = NSMakeRect(originX, originY, width, height);
1342     jobject cPlatformView = (*env)->NewWeakGlobalRef(env, obj);
1343     
1344     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
1345         
1346         CALayer *windowLayer = jlong_to_ptr(windowLayerPtr);
1347         newView = [[AWTView alloc] initWithRect:rect
1348                                    platformView:cPlatformView
1349                                     windowLayer:windowLayer];
1350     }];
1351     
1352     JNF_COCOA_EXIT(env);
1353     
1354     return ptr_to_jlong(newView);
1355 }
1356 
1357 /*
1358  * Class:     sun_lwawt_macosx_CPlatformView
1359  * Method:    nativeSetAutoResizable
1360  * Signature: (JZ)V;
1361  */
1362 
1363 JNIEXPORT void JNICALL
1364 Java_sun_lwawt_macosx_CPlatformView_nativeSetAutoResizable
1365 (JNIEnv *env, jclass cls, jlong viewPtr, jboolean toResize)
1366 {
1367     JNF_COCOA_ENTER(env);
1368     
1369     NSView *view = (NSView *)jlong_to_ptr(viewPtr);
1370     
1371     [ThreadUtilities performOnMainThreadWaiting:NO block:^(){
1372         
1373         if (toResize) {
1374             [view setAutoresizingMask: NSViewHeightSizable | NSViewWidthSizable];
1375         } else {
1376             [view setAutoresizingMask: NSViewMinYMargin | NSViewMaxXMargin];
1377         }
1378         
1379         if ([view superview] != nil) {
1380             [[view superview] setAutoresizesSubviews:(BOOL)toResize];
1381         }
1382         
1383     }];
1384     JNF_COCOA_EXIT(env);
1385 }
1386 
1387 /*
1388  * Class:     sun_lwawt_macosx_CPlatformView
1389  * Method:    nativeGetNSViewDisplayID
1390  * Signature: (J)I;
1391  */
1392 
1393 JNIEXPORT jint JNICALL
1394 Java_sun_lwawt_macosx_CPlatformView_nativeGetNSViewDisplayID
1395 (JNIEnv *env, jclass cls, jlong viewPtr)
1396 {
1397     __block jint ret; //CGDirectDisplayID
1398     
1399     JNF_COCOA_ENTER(env);
1400     
1401     NSView *view = (NSView *)jlong_to_ptr(viewPtr);
1402     NSWindow *window = [view window];
1403     
1404     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
1405         
1406         ret = (jint)[[AWTWindow getNSWindowDisplayID_AppKitThread: window] intValue];
1407     }];
1408     
1409     JNF_COCOA_EXIT(env);
1410     
1411     return ret;
1412 }
1413 
1414 /*
1415  * Class:     sun_lwawt_macosx_CPlatformView
1416  * Method:    nativeGetLocationOnScreen
1417  * Signature: (J)Ljava/awt/Rectangle;
1418  */
1419 
1420 JNIEXPORT jobject JNICALL
1421 Java_sun_lwawt_macosx_CPlatformView_nativeGetLocationOnScreen
1422 (JNIEnv *env, jclass cls, jlong viewPtr)
1423 {
1424     jobject jRect = NULL;
1425     
1426     JNF_COCOA_ENTER(env);
1427     
1428     __block NSRect rect = NSZeroRect;
1429     
1430     NSView *view = (NSView *)jlong_to_ptr(viewPtr);
1431     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
1432         
1433         NSRect viewBounds = [view bounds];
1434         NSRect frameInWindow = [view convertRect:viewBounds toView:nil];
1435         rect = [[view window] convertRectToScreen:frameInWindow];
1436         NSRect screenRect = [[NSScreen mainScreen] frame];
1437         //Convert coordinates to top-left corner origin
1438         rect.origin.y = screenRect.size.height - rect.origin.y - viewBounds.size.height;
1439     }];
1440     jRect = NSToJavaRect(env, rect);
1441     
1442     JNF_COCOA_EXIT(env);
1443     
1444     return jRect;
1445 }
1446 
1447 /*
1448  * Class:     sun_lwawt_macosx_CPlatformView
1449  * Method:    nativeIsViewUnderMouse
1450  * Signature: (J)Z;
1451  */
1452 
1453 JNIEXPORT jboolean JNICALL Java_sun_lwawt_macosx_CPlatformView_nativeIsViewUnderMouse
1454 (JNIEnv *env, jclass clazz, jlong viewPtr)
1455 {
1456     __block jboolean underMouse = JNI_FALSE;
1457     
1458     JNF_COCOA_ENTER(env);
1459     
1460     NSView *nsView = OBJC(viewPtr);
1461     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){       
1462         NSPoint ptWindowCoords = [[nsView window] mouseLocationOutsideOfEventStream];
1463         NSPoint ptViewCoords = [nsView convertPoint:ptWindowCoords fromView:nil];
1464         underMouse = [nsView hitTest:ptViewCoords] != nil;
1465     }];
1466     
1467     JNF_COCOA_EXIT(env);
1468     
1469     return underMouse;
1470 }
--- EOF ---