1 /*
   2  * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #import "CGLGraphicsConfig.h"
  27 
  28 #import <JavaNativeFoundation/JavaNativeFoundation.h>
  29 #import <JavaRuntimeSupport/JavaRuntimeSupport.h>
  30 
  31 #import "ThreadUtilities.h"
  32 #import "AWTView.h"
  33 #import "AWTEvent.h"
  34 #import "AWTWindow.h"
  35 #import "LWCToolkit.h"
  36 #import "JavaComponentAccessibility.h"
  37 #import "JavaTextAccessibility.h"
  38 #import "GeomUtilities.h"
  39 #import "OSVersion.h"
  40 #import "CGLLayer.h"
  41 
  42 @interface AWTView()
  43 @property (retain) CDropTarget *_dropTarget;
  44 @property (retain) CDragSource *_dragSource;
  45 @end
  46 
  47 // Uncomment this line to see fprintfs of each InputMethod API being called on this View
  48 //#define IM_DEBUG TRUE
  49 //#define EXTRA_DEBUG
  50 
  51 
  52 static BOOL shouldUsePressAndHold() {
  53     static int shouldUsePressAndHold = -1;
  54     if (shouldUsePressAndHold != -1) return shouldUsePressAndHold;
  55     shouldUsePressAndHold = !isSnowLeopardOrLower();
  56     return shouldUsePressAndHold;
  57 }
  58 
  59 @implementation AWTView
  60 
  61 @synthesize _dropTarget;
  62 @synthesize _dragSource;
  63 @synthesize cglLayer;
  64 @synthesize mouseIsOver;
  65 
  66 // Note: Must be called on main (AppKit) thread only
  67 - (id) initWithRect: (NSRect) rect
  68        platformView: (jobject) cPlatformView
  69        windowLayer: (CALayer*) windowLayer
  70 {
  71 AWT_ASSERT_APPKIT_THREAD;
  72     // Initialize ourselves
  73     self = [super initWithFrame: rect];
  74     if (self == nil) return self;
  75 
  76     m_cPlatformView = cPlatformView;
  77     fInputMethodLOCKABLE = NULL;
  78     fKeyEventsNeeded = NO;
  79     fProcessingKeystroke = NO;
  80 
  81     fEnablePressAndHold = shouldUsePressAndHold();
  82     fInPressAndHold = NO;
  83     fPAHNeedsToSelect = NO;
  84 
  85     if (windowLayer != nil) {
  86         self.cglLayer = windowLayer;
  87         [self setWantsLayer: YES];
  88         [self.layer addSublayer: (CALayer *)cglLayer];
  89         [self setLayerContentsRedrawPolicy: NSViewLayerContentsRedrawDuringViewResize];
  90         [self setLayerContentsPlacement: NSViewLayerContentsPlacementTopLeft];
  91         [self setAutoresizingMask: NSViewHeightSizable | NSViewWidthSizable];
  92 
  93 #ifdef REMOTELAYER
  94         CGLLayer *parentLayer = (CGLLayer*)self.cglLayer;
  95         parentLayer.parentLayer = NULL;
  96         parentLayer.remoteLayer = NULL;
  97         if (JRSRemotePort != 0 && remoteSocketFD > 0) {
  98             CGLLayer *remoteLayer = [[CGLLayer alloc] initWithJavaLayer: parentLayer.javaLayer];
  99             remoteLayer.target = GL_TEXTURE_2D;
 100             NSLog(@"Creating Parent=%p, Remote=%p", parentLayer, remoteLayer);
 101             parentLayer.remoteLayer = remoteLayer;
 102             remoteLayer.parentLayer = parentLayer;
 103             remoteLayer.remoteLayer = NULL;
 104             remoteLayer.jrsRemoteLayer = [remoteLayer createRemoteLayerBoundTo:JRSRemotePort];
 105             CFRetain(remoteLayer);  // REMIND
 106             remoteLayer.frame = CGRectMake(0, 0, 720, 500); // REMIND
 107             CFRetain(remoteLayer.jrsRemoteLayer); // REMIND
 108             int layerID = [remoteLayer.jrsRemoteLayer layerID];
 109             NSLog(@"layer id to send = %d", layerID);
 110             sendLayerID(layerID);
 111         }
 112 #endif /* REMOTELAYER */
 113     }
 114 
 115     return self;
 116 }
 117 
 118 - (void) dealloc {
 119 AWT_ASSERT_APPKIT_THREAD;
 120 
 121     self.cglLayer = nil;
 122 
 123     JNIEnv *env = [ThreadUtilities getJNIEnv];
 124     (*env)->DeleteGlobalRef(env, m_cPlatformView);
 125     m_cPlatformView = NULL;
 126 
 127     if (fInputMethodLOCKABLE != NULL)
 128     {
 129         JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 130 
 131         JNFDeleteGlobalRef(env, fInputMethodLOCKABLE);
 132         fInputMethodLOCKABLE = NULL;
 133     }
 134 
 135 
 136     [super dealloc];
 137 }
 138 
 139 - (void) viewDidMoveToWindow {
 140 AWT_ASSERT_APPKIT_THREAD;
 141 
 142     [AWTToolkit eventCountPlusPlus];
 143 
 144     [JNFRunLoop performOnMainThreadWaiting:NO withBlock:^() {
 145         [[self window] makeFirstResponder: self];
 146     }];
 147     if ([self window] != NULL) {
 148         [self resetTrackingRect];
 149     }
 150 }
 151 
 152 - (BOOL) acceptsFirstMouse: (NSEvent *)event {
 153     return YES;
 154 }
 155 
 156 - (BOOL) acceptsFirstResponder {
 157     return YES;
 158 }
 159 
 160 - (BOOL) becomeFirstResponder {
 161     return YES;
 162 }
 163 
 164 - (BOOL) preservesContentDuringLiveResize {
 165     return YES;
 166 }
 167 
 168 /*
 169  * Automatically triggered functions.
 170  */
 171 
 172 /*
 173  * MouseEvents support
 174  */
 175 
 176 - (void) mouseDown: (NSEvent *)event {
 177     NSInputManager *inputManager = [NSInputManager currentInputManager];
 178     if ([inputManager wantsToHandleMouseEvents]) {
 179 #if IM_DEBUG
 180         NSLog(@"-> IM wants to handle event");
 181 #endif
 182         if (![inputManager handleMouseEvent:event]) {
 183             [self deliverJavaMouseEvent: event];
 184         } else {
 185 #if IM_DEBUG
 186             NSLog(@"-> Event was handled.");
 187 #endif
 188         }
 189     } else {
 190         NSLog(@"-> IM does not want to handle event");
 191         [self deliverJavaMouseEvent: event];
 192     }
 193 }
 194 
 195 - (void) mouseUp: (NSEvent *)event {
 196     [self deliverJavaMouseEvent: event];
 197 }
 198 
 199 - (void) rightMouseDown: (NSEvent *)event {
 200     [self deliverJavaMouseEvent: event];
 201 }
 202 
 203 - (void) rightMouseUp: (NSEvent *)event {
 204     [self deliverJavaMouseEvent: event];
 205 }
 206 
 207 - (void) otherMouseDown: (NSEvent *)event {
 208     [self deliverJavaMouseEvent: event];
 209 }
 210 
 211 - (void) otherMouseUp: (NSEvent *)event {
 212     [self deliverJavaMouseEvent: event];
 213 }
 214 
 215 - (void) mouseMoved: (NSEvent *)event {
 216     // TODO: better way to redirect move events to the "under" view
 217 
 218     NSPoint eventLocation = [event locationInWindow];
 219     NSPoint localPoint = [self convertPoint: eventLocation fromView: nil];
 220 
 221     if  ([self mouse: localPoint inRect: [self bounds]]) {
 222         [self deliverJavaMouseEvent: event];
 223     } else {
 224         [[self nextResponder] mouseDown:event];
 225     }
 226 }
 227 
 228 - (void) mouseDragged: (NSEvent *)event {
 229     [self deliverJavaMouseEvent: event];
 230 }
 231 
 232 - (void) rightMouseDragged: (NSEvent *)event {
 233     [self deliverJavaMouseEvent: event];
 234 }
 235 
 236 - (void) otherMouseDragged: (NSEvent *)event {
 237     [self deliverJavaMouseEvent: event];
 238 }
 239 
 240 - (void) mouseEntered: (NSEvent *)event {
 241     [[self window] setAcceptsMouseMovedEvents:YES];
 242     //[[self window] makeFirstResponder:self];
 243     [self deliverJavaMouseEvent: event];
 244 }
 245 
 246 - (void) mouseExited: (NSEvent *)event {
 247     [[self window] setAcceptsMouseMovedEvents:NO];
 248     [self deliverJavaMouseEvent: event];
 249     //Restore the cursor back.
 250     //[CCursorManager _setCursor: [NSCursor arrowCursor]];
 251 }
 252 
 253 - (void) scrollWheel: (NSEvent*) event {
 254     [self deliverJavaMouseEvent: event];
 255 }
 256 
 257 /*
 258  * KeyEvents support
 259  */
 260 
 261 - (void) keyDown: (NSEvent *)event {
 262 
 263     fProcessingKeystroke = YES;
 264     fKeyEventsNeeded = YES;
 265 
 266     // Allow TSM to look at the event and potentially send back NSTextInputClient messages.
 267     [self interpretKeyEvents:[NSArray arrayWithObject:event]];
 268 
 269     if (fEnablePressAndHold && [event willBeHandledByComplexInputMethod]) {
 270         fProcessingKeystroke = NO;
 271         if (!fInPressAndHold) {
 272             fInPressAndHold = YES;
 273             fPAHNeedsToSelect = YES;
 274         }
 275         return;
 276     }
 277 
 278     if (![self hasMarkedText] && fKeyEventsNeeded) {
 279         [self deliverJavaKeyEventHelper: event];
 280     }
 281 
 282     fProcessingKeystroke = NO;
 283 }
 284 
 285 - (void) keyUp: (NSEvent *)event {
 286     [self deliverJavaKeyEventHelper: event];
 287 }
 288 
 289 - (void) flagsChanged: (NSEvent *)event {
 290     [self deliverJavaKeyEventHelper: event];
 291 }
 292 
 293 - (BOOL) performKeyEquivalent: (NSEvent *) event {
 294     [self deliverJavaKeyEventHelper: event];
 295     return NO;
 296 }
 297 
 298 /**
 299  * Utility methods and accessors
 300  */
 301 
 302 -(void) deliverJavaMouseEvent: (NSEvent *) event {
 303     
 304     NSEventType type = [event type];    
 305     
 306     // check synthesized mouse entered/exited events
 307     if ((type == NSMouseEntered && mouseIsOver) || (type == NSMouseExited && !mouseIsOver)) {
 308         return;
 309     }else if ((type == NSMouseEntered && !mouseIsOver) || (type == NSMouseExited && mouseIsOver)) {
 310         mouseIsOver = !mouseIsOver;
 311     }
 312     
 313     [AWTToolkit eventCountPlusPlus];
 314 
 315     JNIEnv *env = [ThreadUtilities getJNIEnv];
 316 
 317     NSPoint eventLocation = [event locationInWindow];
 318     NSPoint localPoint = [self convertPoint: eventLocation fromView: nil];
 319     NSPoint absP = [NSEvent mouseLocation];

 320 
 321     // Convert global numbers between Cocoa's coordinate system and Java.
 322     // TODO: need consitent way for doing that both with global as well as with local coordinates.
 323     // The reason to do it here is one more native method for getting screen dimension otherwise.
 324 
 325     NSRect screenRect = [[NSScreen mainScreen] frame];
 326     absP.y = screenRect.size.height - absP.y;
 327     jint clickCount;
 328 
 329     if (type == NSMouseEntered ||
 330         type == NSMouseExited ||
 331         type == NSScrollWheel ||
 332         type == NSMouseMoved) {
 333         clickCount = 0;
 334     } else {
 335         clickCount = [event clickCount];
 336     }
 337 
 338     static JNF_CLASS_CACHE(jc_NSEvent, "sun/lwawt/macosx/event/NSEvent");
 339     static JNF_CTOR_CACHE(jctor_NSEvent, jc_NSEvent, "(IIIIIIIIDD)V");
 340     jobject jEvent = JNFNewObject(env, jctor_NSEvent,
 341                                   [event type],
 342                                   [event modifierFlags],
 343                                   clickCount,
 344                                   [event buttonNumber],
 345                                   (jint)localPoint.x, (jint)localPoint.y,
 346                                   (jint)absP.x, (jint)absP.y,
 347                                   [event deltaY],
 348                                   [event deltaX]);
 349     if (jEvent == nil) {
 350         // Unable to create event by some reason.
 351         return;
 352     }
 353 
 354     static JNF_CLASS_CACHE(jc_PlatformView, "sun/lwawt/macosx/CPlatformView");
 355     static JNF_MEMBER_CACHE(jm_deliverMouseEvent, jc_PlatformView, "deliverMouseEvent", "(Lsun/lwawt/macosx/event/NSEvent;)V");
 356     JNFCallVoidMethod(env, m_cPlatformView, jm_deliverMouseEvent, jEvent);
 357 }
 358 
 359 
 360 - (void) clearTrackingRect {
 361     if (rolloverTrackingRectTag > 0) {
 362         [self removeTrackingRect:rolloverTrackingRectTag];
 363         rolloverTrackingRectTag = 0;
 364     }
 365 }
 366 
 367 - (void) resetTrackingRect {
 368     [self clearTrackingRect];
 369     rolloverTrackingRectTag = [self addTrackingRect:[self visibleRect]
 370                                               owner:self
 371                                            userData:NULL
 372                                        assumeInside:NO];
 373 }
 374 
 375 - (void)updateTrackingAreas {
 376     [super updateTrackingAreas];
 377     [self resetTrackingRect];
 378 }
 379 
 380 - (void) resetCursorRects {
 381     [super resetCursorRects];
 382     [self resetTrackingRect];
 383 }
 384 
 385 -(void) deliverJavaKeyEventHelper: (NSEvent *) event {
 386     [AWTToolkit eventCountPlusPlus];
 387     JNIEnv *env = [ThreadUtilities getJNIEnv];
 388 
 389     jstring characters = NULL;
 390     if ([event type] != NSFlagsChanged) {
 391         characters = JNFNSToJavaString(env, [event characters]);
 392     }
 393 
 394     static JNF_CLASS_CACHE(jc_NSEvent, "sun/lwawt/macosx/event/NSEvent");
 395     static JNF_CTOR_CACHE(jctor_NSEvent, jc_NSEvent, "(IISLjava/lang/String;)V");
 396     jobject jevent = JNFNewObject(env, jctor_NSEvent,
 397                                   [event type],
 398                                   [event modifierFlags],
 399                                   [event keyCode],
 400                                   characters);
 401 
 402     static JNF_CLASS_CACHE(jc_PlatformView, "sun/lwawt/macosx/CPlatformView");
 403     static JNF_MEMBER_CACHE(jm_deliverKeyEvent, jc_PlatformView,
 404                             "deliverKeyEvent", "(Lsun/lwawt/macosx/event/NSEvent;)V");
 405     JNFCallVoidMethod(env, m_cPlatformView, jm_deliverKeyEvent, jevent);
 406 
 407     if (characters != NULL) {
 408         (*env)->DeleteLocalRef(env, characters);
 409     }
 410 }
 411 
 412 - (void) drawRect:(NSRect)dirtyRect {
 413 AWT_ASSERT_APPKIT_THREAD;
 414 
 415     [super drawRect:dirtyRect];
 416     JNIEnv *env = [ThreadUtilities getJNIEnv];
 417     if (env != NULL) {
 418 /*
 419         if ([self inLiveResize]) {
 420         NSRect rs[4];
 421         NSInteger count;
 422         [self getRectsExposedDuringLiveResize:rs count:&count];
 423         for (int i = 0; i < count; i++) {
 424             JNU_CallMethodByName(env, NULL, [m_awtWindow cPlatformView],
 425                  "deliverWindowDidExposeEvent", "(FFFF)V",
 426                  (jfloat)rs[i].origin.x, (jfloat)rs[i].origin.y,
 427                  (jfloat)rs[i].size.width, (jfloat)rs[i].size.height);
 428         if ((*env)->ExceptionOccurred(env)) {
 429             (*env)->ExceptionDescribe(env);
 430             (*env)->ExceptionClear(env);
 431         }
 432         }
 433         } else {
 434 */
 435         static JNF_CLASS_CACHE(jc_CPlatformView, "sun/lwawt/macosx/CPlatformView");
 436         static JNF_MEMBER_CACHE(jm_deliverWindowDidExposeEvent, jc_CPlatformView, "deliverWindowDidExposeEvent", "()V");
 437         JNFCallVoidMethod(env, m_cPlatformView, jm_deliverWindowDidExposeEvent);
 438 /*
 439         }
 440 */
 441     }
 442 }
 443 
 444 // NSAccessibility support
 445 - (jobject)awtComponent:(JNIEnv*)env
 446 {
 447     static JNF_CLASS_CACHE(jc_CPlatformView, "sun/lwawt/macosx/CPlatformView");
 448     static JNF_MEMBER_CACHE(jf_Peer, jc_CPlatformView, "peer", "Lsun/lwawt/LWWindowPeer;");
 449     if ((env == NULL) || (m_cPlatformView == NULL)) {
 450         NSLog(@"Apple AWT : Error AWTView:awtComponent given bad parameters.");
 451         if (env != NULL)
 452         {
 453             JNFDumpJavaStack(env);
 454         }
 455         return NULL;
 456     }
 457     jobject peer = JNFGetObjectField(env, m_cPlatformView, jf_Peer);
 458     static JNF_CLASS_CACHE(jc_LWWindowPeer, "sun/lwawt/LWWindowPeer");
 459     static JNF_MEMBER_CACHE(jf_Target, jc_LWWindowPeer, "target", "Ljava/awt/Component;");
 460     if (peer == NULL) {
 461         NSLog(@"Apple AWT : Error AWTView:awtComponent got null peer from CPlatformView");
 462         JNFDumpJavaStack(env);
 463         return NULL;
 464     }
 465     return JNFGetObjectField(env, peer, jf_Target);
 466 }
 467 
 468 - (id)getAxData:(JNIEnv*)env
 469 {
 470     return [[[JavaComponentAccessibility alloc] initWithParent:self withEnv:env withAccessible:[self awtComponent:env] withIndex:-1 withView:self withJavaRole:nil] autorelease];
 471 }
 472 
 473 - (NSArray *)accessibilityAttributeNames
 474 {
 475     return [[super accessibilityAttributeNames] arrayByAddingObject:NSAccessibilityChildrenAttribute];
 476 }
 477 
 478 // NSAccessibility messages
 479 // attribute methods
 480 - (id)accessibilityAttributeValue:(NSString *)attribute
 481 {
 482     AWT_ASSERT_APPKIT_THREAD;
 483 
 484     if ([attribute isEqualToString:NSAccessibilityChildrenAttribute])
 485     {
 486         JNIEnv *env = [ThreadUtilities getJNIEnv];
 487 
 488         (*env)->PushLocalFrame(env, 4);
 489 
 490         id result = NSAccessibilityUnignoredChildrenForOnlyChild([self getAxData:env]);
 491 
 492         (*env)->PopLocalFrame(env, NULL);
 493 
 494         return result;
 495     }
 496     else
 497     {
 498         return [super accessibilityAttributeValue:attribute];
 499     }
 500 }
 501 - (BOOL)accessibilityIsIgnored
 502 {
 503     return YES;
 504 }
 505 
 506 - (id)accessibilityHitTest:(NSPoint)point
 507 {
 508     AWT_ASSERT_APPKIT_THREAD;
 509     JNIEnv *env = [ThreadUtilities getJNIEnv];
 510 
 511     (*env)->PushLocalFrame(env, 4);
 512 
 513     id result = [[self getAxData:env] accessibilityHitTest:point withEnv:env];
 514 
 515     (*env)->PopLocalFrame(env, NULL);
 516 
 517     return result;
 518 }
 519 
 520 - (id)accessibilityFocusedUIElement
 521 {
 522     AWT_ASSERT_APPKIT_THREAD;
 523 
 524     JNIEnv *env = [ThreadUtilities getJNIEnv];
 525 
 526     (*env)->PushLocalFrame(env, 4);
 527 
 528     id result = [[self getAxData:env] accessibilityFocusedUIElement];
 529 
 530     (*env)->PopLocalFrame(env, NULL);
 531 
 532     return result;
 533 }
 534 
 535 // --- Services menu support for lightweights ---
 536 
 537 // finds the focused accessable element, and if it's a text element, obtains the text from it
 538 - (NSString *)accessibleSelectedText
 539 {
 540     id focused = [self accessibilityFocusedUIElement];
 541     if (![focused isKindOfClass:[JavaTextAccessibility class]]) return nil;
 542     return [(JavaTextAccessibility *)focused accessibilitySelectedTextAttribute];
 543 }
 544 
 545 // same as above, but converts to RTFD
 546 - (NSData *)accessibleSelectedTextAsRTFD
 547 {
 548     NSString *selectedText = [self accessibleSelectedText];
 549     NSAttributedString *styledText = [[NSAttributedString alloc] initWithString:selectedText];
 550     NSData *rtfdData = [styledText RTFDFromRange:NSMakeRange(0, [styledText length]) documentAttributes:nil];
 551     [styledText release];
 552     return rtfdData;
 553 }
 554 
 555 // finds the focused accessable element, and if it's a text element, sets the text in it
 556 - (BOOL)replaceAccessibleTextSelection:(NSString *)text
 557 {
 558     id focused = [self accessibilityFocusedUIElement];
 559     if (![focused isKindOfClass:[JavaTextAccessibility class]]) return NO;
 560     [(JavaTextAccessibility *)focused accessibilitySetSelectedTextAttribute:text];
 561     return YES;
 562 }
 563 
 564 // called for each service in the Services menu - only handle text for now
 565 - (id)validRequestorForSendType:(NSString *)sendType returnType:(NSString *)returnType
 566 {
 567     if ([[self window] firstResponder] != self) return nil; // let AWT components handle themselves
 568 
 569     if ([sendType isEqual:NSStringPboardType] || [returnType isEqual:NSStringPboardType]) {
 570         NSString *selectedText = [self accessibleSelectedText];
 571         if (selectedText) return self;
 572     }
 573 
 574     return nil;
 575 }
 576 
 577 // fetch text from Java and hand off to the service
 578 - (BOOL)writeSelectionToPasteboard:(NSPasteboard *)pboard types:(NSArray *)types
 579 {
 580     if ([types containsObject:NSStringPboardType])
 581     {
 582         [pboard declareTypes:[NSArray arrayWithObject:NSStringPboardType] owner:nil];
 583         return [pboard setString:[self accessibleSelectedText] forType:NSStringPboardType];
 584     }
 585 
 586     if ([types containsObject:NSRTFDPboardType])
 587     {
 588         [pboard declareTypes:[NSArray arrayWithObject:NSRTFDPboardType] owner:nil];
 589         return [pboard setData:[self accessibleSelectedTextAsRTFD] forType:NSRTFDPboardType];
 590     }
 591 
 592     return NO;
 593 }
 594 
 595 // write text back to Java from the service
 596 - (BOOL)readSelectionFromPasteboard:(NSPasteboard *)pboard
 597 {
 598     if ([[pboard types] containsObject:NSStringPboardType])
 599     {
 600         NSString *text = [pboard stringForType:NSStringPboardType];
 601         return [self replaceAccessibleTextSelection:text];
 602     }
 603 
 604     if ([[pboard types] containsObject:NSRTFDPboardType])
 605     {
 606         NSData *rtfdData = [pboard dataForType:NSRTFDPboardType];
 607         NSAttributedString *styledText = [[NSAttributedString alloc] initWithRTFD:rtfdData documentAttributes:nil];
 608         NSString *text = [styledText string];
 609         [styledText release];
 610 
 611         return [self replaceAccessibleTextSelection:text];
 612     }
 613 
 614     return NO;
 615 }
 616 
 617 
 618 -(void) setDragSource:(CDragSource *)source {
 619     self._dragSource = source;
 620 }
 621 
 622 
 623 - (void) setDropTarget:(CDropTarget *)target {
 624     self._dropTarget = target;
 625     [ThreadUtilities performOnMainThread:@selector(controlModelControlValid) onObject:self._dropTarget withObject:nil waitUntilDone:YES awtMode:YES];
 626 }
 627 
 628 /********************************  BEGIN NSDraggingSource Interface  ********************************/
 629 
 630 - (NSDragOperation)draggingSourceOperationMaskForLocal:(BOOL)flag
 631 {
 632     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 633     CDragSource *dragSource = self._dragSource;
 634     NSDragOperation dragOp = NSDragOperationNone;
 635 
 636     if (dragSource != nil)
 637         dragOp = [dragSource draggingSourceOperationMaskForLocal:flag];
 638     else if ([super respondsToSelector:@selector(draggingSourceOperationMaskForLocal:)])
 639         dragOp = [super draggingSourceOperationMaskForLocal:flag];
 640 
 641     return dragOp;
 642 }
 643 
 644 - (NSArray *)namesOfPromisedFilesDroppedAtDestination:(NSURL *)dropDestination
 645 {
 646     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 647     CDragSource *dragSource = self._dragSource;
 648     NSArray* array = nil;
 649 
 650     if (dragSource != nil)
 651         array = [dragSource namesOfPromisedFilesDroppedAtDestination:dropDestination];
 652     else if ([super respondsToSelector:@selector(namesOfPromisedFilesDroppedAtDestination:)])
 653         array = [super namesOfPromisedFilesDroppedAtDestination:dropDestination];
 654 
 655     return array;
 656 }
 657 
 658 - (void)draggedImage:(NSImage *)image beganAt:(NSPoint)screenPoint
 659 {
 660     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 661     CDragSource *dragSource = self._dragSource;
 662 
 663     if (dragSource != nil)
 664         [dragSource draggedImage:image beganAt:screenPoint];
 665     else if ([super respondsToSelector:@selector(draggedImage::)])
 666         [super draggedImage:image beganAt:screenPoint];
 667 }
 668 
 669 - (void)draggedImage:(NSImage *)image endedAt:(NSPoint)screenPoint operation:(NSDragOperation)operation
 670 {
 671     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 672     CDragSource *dragSource = self._dragSource;
 673 
 674     if (dragSource != nil)
 675         [dragSource draggedImage:image endedAt:screenPoint operation:operation];
 676     else if ([super respondsToSelector:@selector(draggedImage:::)])
 677         [super draggedImage:image endedAt:screenPoint operation:operation];
 678 }
 679 
 680 - (void)draggedImage:(NSImage *)image movedTo:(NSPoint)screenPoint
 681 {
 682     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 683     CDragSource *dragSource = self._dragSource;
 684 
 685     if (dragSource != nil)
 686         [dragSource draggedImage:image movedTo:screenPoint];
 687     else if ([super respondsToSelector:@selector(draggedImage::)])
 688         [super draggedImage:image movedTo:screenPoint];
 689 }
 690 
 691 - (BOOL)ignoreModifierKeysWhileDragging
 692 {
 693     // If draggingSource is nil route the message to the superclass (if responding to the selector):
 694     CDragSource *dragSource = self._dragSource;
 695     BOOL result = FALSE;
 696 
 697     if (dragSource != nil)
 698         result = [dragSource ignoreModifierKeysWhileDragging];
 699     else if ([super respondsToSelector:@selector(ignoreModifierKeysWhileDragging)])
 700         result = [super ignoreModifierKeysWhileDragging];
 701 
 702     return result;
 703 }
 704 
 705 /********************************  END NSDraggingSource Interface  ********************************/
 706 
 707 /********************************  BEGIN NSDraggingDestination Interface  ********************************/
 708 
 709 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 710 {
 711     // If draggingDestination is nil route the message to the superclass:
 712     CDropTarget *dropTarget = self._dropTarget;
 713     NSDragOperation dragOp = NSDragOperationNone;
 714 
 715     if (dropTarget != nil)
 716         dragOp = [dropTarget draggingEntered:sender];
 717     else if ([super respondsToSelector:@selector(draggingEntered:)])
 718         dragOp = [super draggingEntered:sender];
 719 
 720     return dragOp;
 721 }
 722 
 723 - (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 724 {
 725     // If draggingDestination is nil route the message to the superclass:
 726     CDropTarget *dropTarget = self._dropTarget;
 727     NSDragOperation dragOp = NSDragOperationNone;
 728 
 729     if (dropTarget != nil)
 730         dragOp = [dropTarget draggingUpdated:sender];
 731     else if ([super respondsToSelector:@selector(draggingUpdated:)])
 732         dragOp = [super draggingUpdated:sender];
 733 
 734     return dragOp;
 735 }
 736 
 737 - (void)draggingExited:(id <NSDraggingInfo>)sender
 738 {
 739     // If draggingDestination is nil route the message to the superclass:
 740     CDropTarget *dropTarget = self._dropTarget;
 741 
 742     if (dropTarget != nil)
 743         [dropTarget draggingExited:sender];
 744     else if ([super respondsToSelector:@selector(draggingExited:)])
 745         [super draggingExited:sender];
 746 }
 747 
 748 - (BOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender
 749 {
 750     // If draggingDestination is nil route the message to the superclass:
 751     CDropTarget *dropTarget = self._dropTarget;
 752     BOOL result = FALSE;
 753 
 754     if (dropTarget != nil)
 755         result = [dropTarget prepareForDragOperation:sender];
 756     else if ([super respondsToSelector:@selector(prepareForDragOperation:)])
 757         result = [super prepareForDragOperation:sender];
 758 
 759     return result;
 760 }
 761 
 762 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 763 {
 764     // If draggingDestination is nil route the message to the superclass:
 765     CDropTarget *dropTarget = self._dropTarget;
 766     BOOL result = FALSE;
 767 
 768     if (dropTarget != nil)
 769         result = [dropTarget performDragOperation:sender];
 770     else if ([super respondsToSelector:@selector(performDragOperation:)])
 771         result = [super performDragOperation:sender];
 772 
 773     return result;
 774 }
 775 
 776 - (void)concludeDragOperation:(id <NSDraggingInfo>)sender
 777 {
 778     // If draggingDestination is nil route the message to the superclass:
 779     CDropTarget *dropTarget = self._dropTarget;
 780 
 781     if (dropTarget != nil)
 782         [dropTarget concludeDragOperation:sender];
 783     else if ([super respondsToSelector:@selector(concludeDragOperation:)])
 784         [super concludeDragOperation:sender];
 785 }
 786 
 787 - (void)draggingEnded:(id <NSDraggingInfo>)sender
 788 {
 789     // If draggingDestination is nil route the message to the superclass:
 790     CDropTarget *dropTarget = self._dropTarget;
 791 
 792     if (dropTarget != nil)
 793         [dropTarget draggingEnded:sender];
 794     else if ([super respondsToSelector:@selector(draggingEnded:)])
 795         [super draggingEnded:sender];
 796 }
 797 
 798 /********************************  END NSDraggingDestination Interface  ********************************/
 799 
 800 /********************************  BEGIN NSTextInputClient Protocol  ********************************/
 801 
 802 
 803 JNF_CLASS_CACHE(jc_CInputMethod, "sun/lwawt/macosx/CInputMethod");
 804 
 805 - (void) insertText:(id)aString replacementRange:(NSRange)replacementRange
 806 {
 807 #ifdef IM_DEBUG
 808     fprintf(stderr, "AWTView InputMethod Selector Called : [insertText]: %s\n", [aString UTF8String]);
 809 #endif // IM_DEBUG
 810 
 811     if (fInputMethodLOCKABLE == NULL) {
 812         return;
 813     }
 814 
 815     // Insert happens at the end of PAH
 816     fInPressAndHold = NO;
 817 
 818     // insertText gets called when the user commits text generated from an input method.  It also gets
 819     // called during ordinary input as well.  We only need to send an input method event when we have marked
 820     // text, or 'text in progress'.  We also need to send the event if we get an insert text out of the blue!
 821     // (i.e., when the user uses the Character palette or Inkwell), or when the string to insert is a complex
 822     // Unicode value.
 823     NSUInteger utf8Length = [aString lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 824 
 825     if ([self hasMarkedText] || !fProcessingKeystroke || (utf8Length > 1)) {
 826         JNIEnv *env = [ThreadUtilities getJNIEnv];
 827 
 828         static JNF_MEMBER_CACHE(jm_selectPreviousGlyph, jc_CInputMethod, "selectPreviousGlyph", "()V");
 829         // We need to select the previous glyph so that it is overwritten.
 830         if (fPAHNeedsToSelect) {
 831             JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_selectPreviousGlyph);
 832             fPAHNeedsToSelect = NO;
 833         }
 834 
 835         static JNF_MEMBER_CACHE(jm_insertText, jc_CInputMethod, "insertText", "(Ljava/lang/String;)V");
 836         jstring insertedText =  JNFNSToJavaString(env, aString);
 837         JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_insertText, insertedText); // AWT_THREADING Safe (AWTRunLoopMode)
 838         (*env)->DeleteLocalRef(env, insertedText);
 839 
 840         // The input method event will create psuedo-key events for each character in the committed string.
 841         // We also don't want to send the character that triggered the insertText, usually a return. [3337563]
 842         fKeyEventsNeeded = NO;
 843     }
 844 
 845     fPAHNeedsToSelect = NO;
 846 
 847 }
 848 
 849 - (void) doCommandBySelector:(SEL)aSelector
 850 {
 851 #ifdef IM_DEBUG
 852     fprintf(stderr, "AWTView InputMethod Selector Called : [doCommandBySelector]\n");
 853     NSLog(@"%@", NSStringFromSelector(aSelector));
 854 #endif // IM_DEBUG
 855     if (@selector(insertNewline:) == aSelector || @selector(insertTab:) == aSelector || @selector(deleteBackward:) == aSelector)
 856     {
 857         fKeyEventsNeeded = YES;
 858     }
 859 }
 860 
 861 // setMarkedText: cannot take a nil first argument. aString can be NSString or NSAttributedString
 862 - (void) setMarkedText:(id)aString selectedRange:(NSRange)selectionRange replacementRange:(NSRange)replacementRange
 863 {
 864     if (!fInputMethodLOCKABLE)
 865         return;
 866 
 867     BOOL isAttributedString = [aString isKindOfClass:[NSAttributedString class]];
 868     NSAttributedString *attrString = (isAttributedString ? (NSAttributedString *)aString : nil);
 869     NSString *incomingString = (isAttributedString ? [aString string] : aString);
 870 #ifdef IM_DEBUG
 871     fprintf(stderr, "AWTView InputMethod Selector Called : [setMarkedText] \"%s\", loc=%lu, length=%lu\n", [incomingString UTF8String], (unsigned long)selectionRange.location, (unsigned long)selectionRange.length);
 872 #endif // IM_DEBUG
 873     static JNF_MEMBER_CACHE(jm_startIMUpdate, jc_CInputMethod, "startIMUpdate", "(Ljava/lang/String;)V");
 874     static JNF_MEMBER_CACHE(jm_addAttribute, jc_CInputMethod, "addAttribute", "(ZZII)V");
 875     static JNF_MEMBER_CACHE(jm_dispatchText, jc_CInputMethod, "dispatchText", "(IIZ)V");
 876     JNIEnv *env = [ThreadUtilities getJNIEnv];
 877 
 878     // NSInputContext already did the analysis of the TSM event and created attributes indicating
 879     // the underlining and color that should be done to the string.  We need to look at the underline
 880     // style and color to determine what kind of Java hilighting needs to be done.
 881     jstring inProcessText = JNFNSToJavaString(env, incomingString);
 882     JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_startIMUpdate, inProcessText); // AWT_THREADING Safe (AWTRunLoopMode)
 883     (*env)->DeleteLocalRef(env, inProcessText);
 884 
 885     if (isAttributedString) {
 886         NSUInteger length;
 887         NSRange effectiveRange;
 888         NSDictionary *attributes;
 889         length = [attrString length];
 890         effectiveRange = NSMakeRange(0, 0);
 891         while (NSMaxRange(effectiveRange) < length) {
 892             attributes = [attrString attributesAtIndex:NSMaxRange(effectiveRange)
 893                                         effectiveRange:&effectiveRange];
 894             if (attributes) {
 895                 BOOL isThickUnderline, isGray;
 896                 NSNumber *underlineSizeObj =
 897                 (NSNumber *)[attributes objectForKey:NSUnderlineStyleAttributeName];
 898                 NSInteger underlineSize = [underlineSizeObj integerValue];
 899                 isThickUnderline = (underlineSize > 1);
 900 
 901                 NSColor *underlineColorObj =
 902                 (NSColor *)[attributes objectForKey:NSUnderlineColorAttributeName];
 903                 isGray = !([underlineColorObj isEqual:[NSColor blackColor]]);
 904 
 905                 JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_addAttribute, isThickUnderline, isGray, effectiveRange.location, effectiveRange.length); // AWT_THREADING Safe (AWTRunLoopMode)
 906             }
 907         }
 908     }
 909 
 910     static JNF_MEMBER_CACHE(jm_selectPreviousGlyph, jc_CInputMethod, "selectPreviousGlyph", "()V");
 911     // We need to select the previous glyph so that it is overwritten.
 912     if (fPAHNeedsToSelect) {
 913         JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_selectPreviousGlyph);
 914         fPAHNeedsToSelect = NO;
 915     }
 916 
 917     JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_dispatchText, selectionRange.location, selectionRange.length, JNI_FALSE); // AWT_THREADING Safe (AWTRunLoopMode)
 918 
 919     // If the marked text is being cleared (zero-length string) don't handle the key event.
 920     if ([incomingString length] == 0) {
 921         fKeyEventsNeeded = NO;
 922     }
 923 }
 924 
 925 - (void) unmarkText
 926 {
 927 #ifdef IM_DEBUG
 928     fprintf(stderr, "AWTView InputMethod Selector Called : [unmarkText]\n");
 929 #endif // IM_DEBUG
 930 
 931     if (!fInputMethodLOCKABLE) {
 932         return;
 933     }
 934 
 935     // unmarkText cancels any input in progress and commits it to the text field.
 936     static JNF_MEMBER_CACHE(jm_unmarkText, jc_CInputMethod, "unmarkText", "()V");
 937     JNIEnv *env = [ThreadUtilities getJNIEnv];
 938     JNFCallVoidMethod(env, fInputMethodLOCKABLE, jm_unmarkText); // AWT_THREADING Safe (AWTRunLoopMode)
 939 
 940 }
 941 
 942 - (BOOL) hasMarkedText
 943 {
 944 #ifdef IM_DEBUG
 945     fprintf(stderr, "AWTView InputMethod Selector Called : [hasMarkedText]\n");
 946 #endif // IM_DEBUG
 947 
 948     if (!fInputMethodLOCKABLE) {
 949         return NO;
 950     }
 951 
 952     static JNF_MEMBER_CACHE(jf_fCurrentText, jc_CInputMethod, "fCurrentText", "Ljava/text/AttributedString;");
 953     static JNF_MEMBER_CACHE(jf_fCurrentTextLength, jc_CInputMethod, "fCurrentTextLength", "I");
 954     JNIEnv *env = [ThreadUtilities getJNIEnv];
 955     jobject currentText = JNFGetObjectField(env, fInputMethodLOCKABLE, jf_fCurrentText);
 956 
 957     jint currentTextLength = JNFGetIntField(env, fInputMethodLOCKABLE, jf_fCurrentTextLength);
 958 
 959     BOOL hasMarkedText = (currentText != NULL && currentTextLength > 0);
 960 
 961     if (currentText != NULL) {
 962         (*env)->DeleteLocalRef(env, currentText);
 963     }
 964 
 965     return hasMarkedText;
 966 }
 967 
 968 - (NSInteger) conversationIdentifier
 969 {
 970 #ifdef IM_DEBUG
 971     fprintf(stderr, "AWTView InputMethod Selector Called : [conversationIdentifier]\n");
 972 #endif // IM_DEBUG
 973 
 974     return (NSInteger) self;
 975 }
 976 
 977 /* Returns attributed string at the range.  This allows input mangers to
 978  query any range in backing-store (Andy's request)
 979  */
 980 - (NSAttributedString *) attributedSubstringForProposedRange:(NSRange)theRange actualRange:(NSRangePointer)actualRange
 981 {
 982 #ifdef IM_DEBUG
 983     fprintf(stderr, "AWTView InputMethod Selector Called : [attributedSubstringFromRange] location=%lu, length=%lu\n", (unsigned long)theRange.location, (unsigned long)theRange.length);
 984 #endif // IM_DEBUG
 985 
 986     static JNF_MEMBER_CACHE(jm_substringFromRange, jc_CInputMethod, "attributedSubstringFromRange", "(II)Ljava/lang/String;");
 987     JNIEnv *env = [ThreadUtilities getJNIEnv];
 988     jobject theString = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_substringFromRange, theRange.location, theRange.length); // AWT_THREADING Safe (AWTRunLoopMode)
 989 
 990     id result = [[[NSAttributedString alloc] initWithString:JNFJavaToNSString(env, theString)] autorelease];
 991 #ifdef IM_DEBUG
 992     NSLog(@"attributedSubstringFromRange returning \"%@\"", result);
 993 #endif // IM_DEBUG
 994 
 995     (*env)->DeleteLocalRef(env, theString);
 996     return result;
 997 }
 998 
 999 /* This method returns the range for marked region.  If hasMarkedText == false,
1000  it'll return NSNotFound location & 0 length range.
1001  */
1002 - (NSRange) markedRange
1003 {
1004 
1005 #ifdef IM_DEBUG
1006     fprintf(stderr, "AWTView InputMethod Selector Called : [markedRange]\n");
1007 #endif // IM_DEBUG
1008 
1009     if (!fInputMethodLOCKABLE) {
1010         return NSMakeRange(NSNotFound, 0);
1011     }
1012 
1013     static JNF_MEMBER_CACHE(jm_markedRange, jc_CInputMethod, "markedRange", "()[I");
1014     JNIEnv *env = [ThreadUtilities getJNIEnv];
1015     jarray array;
1016     jboolean isCopy;
1017     jint *_array;
1018     NSRange range;
1019 
1020     array = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_markedRange); // AWT_THREADING Safe (AWTRunLoopMode)
1021 
1022     if (array) {
1023         _array = (*env)->GetIntArrayElements(env, array, &isCopy);
1024         range = NSMakeRange(_array[0], _array[1]);
1025 
1026 #ifdef IM_DEBUG
1027         fprintf(stderr, "markedRange returning (%lu, %lu)\n", (unsigned long)range.location, (unsigned long)range.length);
1028 #endif // IM_DEBUG
1029         (*env)->ReleaseIntArrayElements(env, array, _array, 0);
1030         (*env)->DeleteLocalRef(env, array);
1031     } else {
1032         range = NSMakeRange(NSNotFound, 0);
1033     }
1034 
1035     return range;
1036 }
1037 
1038 /* This method returns the range for selected region.  Just like markedRange method,
1039  its location field contains char index from the text beginning.
1040  */
1041 - (NSRange) selectedRange
1042 {
1043     if (!fInputMethodLOCKABLE) {
1044         return NSMakeRange(NSNotFound, 0);
1045     }
1046 
1047     static JNF_MEMBER_CACHE(jm_selectedRange, jc_CInputMethod, "selectedRange", "()[I");
1048     JNIEnv *env = [ThreadUtilities getJNIEnv];
1049     jarray array;
1050     jboolean isCopy;
1051     jint *_array;
1052     NSRange range;
1053 
1054 #ifdef IM_DEBUG
1055     fprintf(stderr, "AWTView InputMethod Selector Called : [selectedRange]\n");
1056 #endif // IM_DEBUG
1057 
1058     array = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_selectedRange); // AWT_THREADING Safe (AWTRunLoopMode)
1059     if (array) {
1060         _array = (*env)->GetIntArrayElements(env, array, &isCopy);
1061         range = NSMakeRange(_array[0], _array[1]);
1062         (*env)->ReleaseIntArrayElements(env, array, _array, 0);
1063         (*env)->DeleteLocalRef(env, array);
1064     } else {
1065         range = NSMakeRange(NSNotFound, 0);
1066     }
1067 
1068     return range;
1069 
1070 }
1071 
1072 /* This method returns the first frame of rects for theRange in screen coordindate system.
1073  */
1074 - (NSRect) firstRectForCharacterRange:(NSRange)theRange actualRange:(NSRangePointer)actualRange
1075 {
1076     if (!fInputMethodLOCKABLE) {
1077         return NSMakeRect(0, 0, 0, 0);
1078     }
1079 
1080     static JNF_MEMBER_CACHE(jm_firstRectForCharacterRange, jc_CInputMethod,
1081                             "firstRectForCharacterRange", "(I)[I");
1082     JNIEnv *env = [ThreadUtilities getJNIEnv];
1083     jarray array;
1084     jboolean isCopy;
1085     jint *_array;
1086     NSRect rect;
1087 
1088 #ifdef IM_DEBUG
1089     fprintf(stderr, "AWTView InputMethod Selector Called : [firstRectForCharacterRange:] location=%lu, length=%lu\n", (unsigned long)theRange.location, (unsigned long)theRange.length);
1090 #endif // IM_DEBUG
1091 
1092     array = JNFCallObjectMethod(env, fInputMethodLOCKABLE, jm_firstRectForCharacterRange, theRange.location); // AWT_THREADING Safe (AWTRunLoopMode)
1093 
1094     _array = (*env)->GetIntArrayElements(env, array, &isCopy);
1095     rect = ConvertNSScreenRect(env, NSMakeRect(_array[0], _array[1], _array[2], _array[3]));
1096     (*env)->ReleaseIntArrayElements(env, array, _array, 0);
1097     (*env)->DeleteLocalRef(env, array);
1098 
1099 #ifdef IM_DEBUG
1100     fprintf(stderr, "firstRectForCharacterRange returning x=%f, y=%f, width=%f, height=%f\n", rect.origin.x, rect.origin.y, rect.size.width, rect.size.height);
1101 #endif // IM_DEBUG
1102     return rect;
1103 }
1104 
1105 /* This method returns the index for character that is nearest to thePoint.  thPoint is in
1106  screen coordinate system.
1107  */
1108 - (NSUInteger)characterIndexForPoint:(NSPoint)thePoint
1109 {
1110     if (!fInputMethodLOCKABLE) {
1111         return NSNotFound;
1112     }
1113 
1114     static JNF_MEMBER_CACHE(jm_characterIndexForPoint, jc_CInputMethod,
1115                             "characterIndexForPoint", "(II)I");
1116     JNIEnv *env = [ThreadUtilities getJNIEnv];
1117 
1118     NSPoint flippedLocation = ConvertNSScreenPoint(env, thePoint);
1119 
1120 #ifdef IM_DEBUG
1121     fprintf(stderr, "AWTView InputMethod Selector Called : [characterIndexForPoint:(NSPoint)thePoint] x=%f, y=%f\n", flippedLocation.x, flippedLocation.y);
1122 #endif // IM_DEBUG
1123 
1124     jint index = JNFCallIntMethod(env, fInputMethodLOCKABLE, jm_characterIndexForPoint, (jint)flippedLocation.x, (jint)flippedLocation.y); // AWT_THREADING Safe (AWTRunLoopMode)
1125 
1126 #ifdef IM_DEBUG
1127     fprintf(stderr, "characterIndexForPoint returning %ld\n", index);
1128 #endif // IM_DEBUG
1129 
1130     if (index == -1) {
1131         return NSNotFound;
1132     } else {
1133         return (NSUInteger)index;
1134     }
1135 }
1136 
1137 - (NSArray*) validAttributesForMarkedText
1138 {
1139 #ifdef IM_DEBUG
1140     fprintf(stderr, "AWTView InputMethod Selector Called : [validAttributesForMarkedText]\n");
1141 #endif // IM_DEBUG
1142 
1143     return [NSArray array];
1144 }
1145 
1146 - (void)setInputMethod:(jobject)inputMethod
1147 {
1148 #ifdef IM_DEBUG
1149     fprintf(stderr, "AWTView InputMethod Selector Called : [setInputMethod]\n");
1150 #endif // IM_DEBUG
1151 
1152     JNIEnv *env = [ThreadUtilities getJNIEnv];
1153 
1154     // Get rid of the old one
1155     if (fInputMethodLOCKABLE) {
1156         JNFDeleteGlobalRef(env, fInputMethodLOCKABLE);
1157     }
1158 
1159     // Save a global ref to the new input method.
1160     if (inputMethod != NULL)
1161         fInputMethodLOCKABLE = JNFNewGlobalRef(env, inputMethod);
1162     else
1163         fInputMethodLOCKABLE = NULL;
1164 }
1165 
1166 - (void)abandonInput
1167 {
1168 #ifdef IM_DEBUG
1169     fprintf(stderr, "AWTView InputMethod Selector Called : [abandonInput]\n");
1170 #endif // IM_DEBUG
1171 
1172     [ThreadUtilities performOnMainThread:@selector(markedTextAbandoned:) onObject:[NSInputManager currentInputManager] withObject:self waitUntilDone:YES awtMode:YES];
1173     [self unmarkText];
1174 }
1175 
1176 /********************************   END NSTextInputClient Protocol   ********************************/
1177 
1178 
1179 
1180 
1181 @end // AWTView
1182 
1183 /*
1184  * Class:     sun_lwawt_macosx_CPlatformView
1185  * Method:    nativeCreateView
1186  * Signature: (IIII)J
1187  */
1188 JNIEXPORT jlong JNICALL
1189 Java_sun_lwawt_macosx_CPlatformView_nativeCreateView
1190 (JNIEnv *env, jobject obj, jint originX, jint originY, jint width, jint height, jlong windowLayerPtr)
1191 {
1192     __block AWTView *newView = nil;
1193 
1194 JNF_COCOA_ENTER(env);
1195 AWT_ASSERT_NOT_APPKIT_THREAD;
1196 
1197     NSRect rect = NSMakeRect(originX, originY, width, height);
1198     jobject cPlatformView = (*env)->NewGlobalRef(env, obj);
1199 
1200     [JNFRunLoop performOnMainThreadWaiting:YES withBlock:^(){
1201         AWT_ASSERT_APPKIT_THREAD;
1202 
1203         CALayer *windowLayer = jlong_to_ptr(windowLayerPtr);
1204         AWTView *view = [[AWTView alloc] initWithRect:rect
1205                                          platformView:cPlatformView
1206                                          windowLayer:windowLayer];
1207         CFRetain(view);
1208         [view release]; // GC
1209 
1210         newView = view;
1211     }];
1212 
1213 JNF_COCOA_EXIT(env);
1214 
1215     return ptr_to_jlong(newView);
1216 }
--- EOF ---