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