rev 54094 : 8257853: Remove dependencies on JNF's JNI utility functions in AWT and 2D code
rev 54095 : 8259343: [macOS] Update JNI error handling in Cocoa code.
rev 54096 : 8259651: [macOS] Replace JNF_COCOA_ENTER/EXIT macros
rev 54097 : 8259869: [macOS] Remove desktop module dependencies on JNF Reference APIs
rev 54098 : 8260616: Removing remaining JNF dependencies in the java.desktop module
8259729: Missed JNFInstanceOf -> IsInstanceOf conversion
rev 54102 : 8261198: [macOS] Incorrect JNI parameters in number conversion in A11Y code
Reviewed-by: serb, psadhukhan
rev 54103 : 8263846: Bad JNI lookup getFocusOwner in accessibility code on Mac OS X
Reviewed-by: azvegint, prr

   1 /*
   2  * Copyright (c) 2011, 2018, 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 // External Java Accessibility links:
  27 //
  28 // <https://docs.oracle.com/javase/8/docs/technotes/guides/access/index.html>
  29 // <http://www-106.ibm.com/developerworks/library/j-access/?n-j-10172>
  30 // <http://archives.java.sun.com/archives/java-access.html> (Sun's mailing list for Java accessibility)
  31 
  32 #import "JavaComponentAccessibility.h"
  33 
  34 #import "sun_lwawt_macosx_CAccessibility.h"
  35 
  36 #import <AppKit/AppKit.h>
  37 
  38 #import <JavaNativeFoundation/JavaNativeFoundation.h>
  39 #import <JavaRuntimeSupport/JavaRuntimeSupport.h>
  40 
  41 #import <dlfcn.h>
  42 
  43 #import "JavaAccessibilityAction.h"
  44 #import "JavaAccessibilityUtilities.h"
  45 #import "JavaTextAccessibility.h"
  46 #import "ThreadUtilities.h"

  47 #import "AWTView.h"
  48 
  49 
  50 // these constants are duplicated in CAccessibility.java
  51 #define JAVA_AX_ALL_CHILDREN (-1)
  52 #define JAVA_AX_SELECTED_CHILDREN (-2)
  53 #define JAVA_AX_VISIBLE_CHILDREN (-3)
  54 // If the value is >=0, it's an index
  55 
  56 static JNF_STATIC_MEMBER_CACHE(jm_getChildrenAndRoles, sjc_CAccessibility, "getChildrenAndRoles", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;IZ)[Ljava/lang/Object;");
  57 static JNF_STATIC_MEMBER_CACHE(sjm_getAccessibleComponent, sjc_CAccessibility, "getAccessibleComponent", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljavax/accessibility/AccessibleComponent;");
  58 static JNF_STATIC_MEMBER_CACHE(sjm_getAccessibleValue, sjc_CAccessibility, "getAccessibleValue", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljavax/accessibility/AccessibleValue;");
  59 static JNF_STATIC_MEMBER_CACHE(sjm_getAccessibleName, sjc_CAccessibility, "getAccessibleName", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/String;");
  60 static JNF_STATIC_MEMBER_CACHE(sjm_getAccessibleDescription, sjc_CAccessibility, "getAccessibleDescription", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/String;");
  61 static JNF_STATIC_MEMBER_CACHE(sjm_isFocusTraversable, sjc_CAccessibility, "isFocusTraversable", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Z");
  62 static JNF_STATIC_MEMBER_CACHE(sjm_getAccessibleIndexInParent, sjc_CAccessibility, "getAccessibleIndexInParent", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)I");
  63 
  64 static JNF_CLASS_CACHE(sjc_CAccessible, "sun/lwawt/macosx/CAccessible");


























  65 
  66 static JNF_MEMBER_CACHE(jf_ptr, sjc_CAccessible, "ptr", "J");
  67 static JNF_STATIC_MEMBER_CACHE(sjm_getCAccessible, sjc_CAccessible, "getCAccessible", "(Ljavax/accessibility/Accessible;)Lsun/lwawt/macosx/CAccessible;");
  68 
  69 static jobject sAccessibilityClass = NULL;
  70 
  71 // sAttributeNamesForRoleCache holds the names of the attributes to which each java
  72 // AccessibleRole responds (see AccessibleRole.java).
  73 // This cache is queried before attempting to access a given attribute for a particular role.
  74 static NSMutableDictionary *sAttributeNamesForRoleCache = nil;
  75 static NSObject *sAttributeNamesLOCK = nil;
  76 
  77 @interface TabGroupAccessibility : JavaComponentAccessibility {
  78     NSInteger _numTabs;
  79 }
  80 
  81 - (id)currentTabWithEnv:(JNIEnv *)env withAxContext:(jobject)axContext;
  82 - (NSArray *)tabControlsWithEnv:(JNIEnv *)env withTabGroupAxContext:(jobject)axContext withTabCode:(NSInteger)whichTabs allowIgnored:(BOOL)allowIgnored;
  83 - (NSArray *)contentsWithEnv:(JNIEnv *)env withTabGroupAxContext:(jobject)axContext withTabCode:(NSInteger)whichTabs allowIgnored:(BOOL)allowIgnored;
  84 - (NSArray *)initializeAttributeNamesWithEnv:(JNIEnv *)env;
  85 
  86 - (NSArray *)accessibilityArrayAttributeValues:(NSString *)attribute index:(NSUInteger)index maxCount:(NSUInteger)maxCount;
  87 - (NSArray *)accessibilityChildrenAttribute;
  88 - (id) accessibilityTabsAttribute;
  89 - (BOOL)accessibilityIsTabsAttributeSettable;
  90 - (NSArray *)accessibilityContentsAttribute;
  91 - (BOOL)accessibilityIsContentsAttributeSettable;
  92 - (id) accessibilityValueAttribute;
  93 
  94 @end
  95 
  96 
  97 @interface TabGroupControlAccessibility : JavaComponentAccessibility {
  98     jobject fTabGroupAxContext;
  99 }
 100 - (id)initWithParent:(NSObject *)parent withEnv:(JNIEnv *)env withAccessible:(jobject)accessible withIndex:(jint)index withTabGroup:(jobject)tabGroup withView:(NSView *)view withJavaRole:(NSString *)javaRole;
 101 - (jobject)tabGroup;
 102 - (void)getActionsWithEnv:(JNIEnv *)env;
 103 
 104 - (id)accessibilityValueAttribute;
 105 @end
 106 
 107 
 108 @interface ScrollAreaAccessibility : JavaComponentAccessibility {
 109 
 110 }
 111 - (NSArray *)initializeAttributeNamesWithEnv:(JNIEnv *)env;
 112 - (NSArray *)accessibilityContentsAttribute;
 113 - (BOOL)accessibilityIsContentsAttributeSettable;
 114 - (id)accessibilityVerticalScrollBarAttribute;
 115 - (BOOL)accessibilityIsVerticalScrollBarAttributeSettable;
 116 - (id)accessibilityHorizontalScrollBarAttribute;
 117 - (BOOL)accessibilityIsHorizontalScrollBarAttributeSettable;
 118 @end
 119 
 120 
 121 @implementation JavaComponentAccessibility
 122 
 123 - (NSString *)description
 124 {
 125     return [NSString stringWithFormat:@"%@(title:'%@', desc:'%@', value:'%@')", [self accessibilityRoleAttribute],
 126         [self accessibilityTitleAttribute], [self accessibilityRoleDescriptionAttribute], [self accessibilityValueAttribute]];
 127 }
 128 
 129 - (id)initWithParent:(NSObject *)parent withEnv:(JNIEnv *)env withAccessible:(jobject)accessible withIndex:(jint)index withView:(NSView *)view withJavaRole:(NSString *)javaRole
 130 {
 131     self = [super init];
 132     if (self)
 133     {
 134         fParent = [parent retain];
 135         fView = [view retain];
 136         fJavaRole = [javaRole retain];
 137 
 138         fAccessible = (*env)->NewWeakGlobalRef(env, accessible);
 139         (*env)->ExceptionClear(env); // in case of OOME
 140         jobject jcomponent = [(AWTView *)fView awtComponent:env];
 141         fComponent = (*env)->NewWeakGlobalRef(env, jcomponent);
 142         (*env)->DeleteLocalRef(env, jcomponent);
 143 
 144         fIndex = index;
 145 
 146         fActions = nil;
 147         fActionsLOCK = [[NSObject alloc] init];
 148     }
 149     return self;
 150 }
 151 
 152 - (void)unregisterFromCocoaAXSystem
 153 {
 154     AWT_ASSERT_APPKIT_THREAD;
 155     static dispatch_once_t initialize_unregisterUniqueId_once;
 156     static void (*unregisterUniqueId)(id);
 157     dispatch_once(&initialize_unregisterUniqueId_once, ^{
 158         void *jrsFwk = dlopen("/System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/JavaRuntimeSupport", RTLD_LAZY | RTLD_LOCAL);
 159         unregisterUniqueId = dlsym(jrsFwk, "JRSAccessibilityUnregisterUniqueIdForUIElement");
 160     });
 161     if (unregisterUniqueId) unregisterUniqueId(self);
 162 }
 163 
 164 - (void)dealloc
 165 {
 166     [self unregisterFromCocoaAXSystem];
 167 
 168     JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
 169 
 170     (*env)->DeleteWeakGlobalRef(env, fAccessible);
 171     fAccessible = NULL;
 172 
 173     (*env)->DeleteWeakGlobalRef(env, fComponent);
 174     fComponent = NULL;
 175 
 176     [fParent release];
 177     fParent = nil;
 178 
 179     [fNSRole release];
 180     fNSRole = nil;
 181 
 182     [fJavaRole release];
 183     fJavaRole = nil;
 184 
 185     [fView release];
 186     fView = nil;
 187 
 188     [fActions release];
 189     fActions = nil;
 190 
 191     [fActionsLOCK release];
 192     fActionsLOCK = nil;
 193 
 194     [super dealloc];
 195 }
 196 
 197 - (void)postValueChanged
 198 {
 199     AWT_ASSERT_APPKIT_THREAD;
 200     NSAccessibilityPostNotification(self, NSAccessibilityValueChangedNotification);
 201 }
 202 
 203 - (void)postSelectedTextChanged
 204 {
 205     AWT_ASSERT_APPKIT_THREAD;
 206     NSAccessibilityPostNotification(self, NSAccessibilitySelectedTextChangedNotification);
 207 }
 208 
 209 - (void)postSelectionChanged
 210 {
 211     AWT_ASSERT_APPKIT_THREAD;
 212     NSAccessibilityPostNotification(self, NSAccessibilitySelectedChildrenChangedNotification);
 213 }
 214 
 215 - (void)postMenuOpened
 216 {
 217     AWT_ASSERT_APPKIT_THREAD;
 218     NSAccessibilityPostNotification(self, (NSString *)kAXMenuOpenedNotification);
 219 }
 220 
 221 - (void)postMenuClosed
 222 {
 223     AWT_ASSERT_APPKIT_THREAD;
 224     NSAccessibilityPostNotification(self, (NSString *)kAXMenuClosedNotification);
 225 }
 226 
 227 - (void)postMenuItemSelected
 228 {
 229     AWT_ASSERT_APPKIT_THREAD;
 230     NSAccessibilityPostNotification(self, (NSString *)kAXMenuItemSelectedNotification);
 231 }
 232 
 233 - (BOOL)isEqual:(id)anObject
 234 {
 235     if (![anObject isKindOfClass:[self class]]) return NO;
 236     JavaComponentAccessibility *accessibility = (JavaComponentAccessibility *)anObject;
 237 
 238     JNIEnv* env = [ThreadUtilities getJNIEnv];
 239     return (*env)->IsSameObject(env, accessibility->fAccessible, fAccessible);
 240 }
 241 
 242 - (BOOL)isAccessibleWithEnv:(JNIEnv *)env forAccessible:(jobject)accessible
 243 {
 244     return (*env)->IsSameObject(env, fAccessible, accessible);
 245 }
 246 
 247 + (void)initialize
 248 {
 249     if (sAttributeNamesForRoleCache == nil) {
 250         sAttributeNamesLOCK = [[NSObject alloc] init];
 251         sAttributeNamesForRoleCache = [[NSMutableDictionary alloc] initWithCapacity:60];
 252     }
 253 
 254     if (sRoles == nil) {
 255         initializeRoles();
 256     }
 257 
 258     if (sAccessibilityClass == NULL) {
 259         JNF_STATIC_MEMBER_CACHE(jm_getAccessibility, sjc_CAccessibility, "getAccessibility", "([Ljava/lang/String;)Lsun/lwawt/macosx/CAccessibility;");



 260 
 261 #ifdef JAVA_AX_NO_IGNORES
 262         NSArray *ignoredKeys = [NSArray array];
 263 #else
 264         NSArray *ignoredKeys = [sRoles allKeysForObject:JavaAccessibilityIgnore];
 265 #endif
 266         jobjectArray result = NULL;
 267         jsize count = [ignoredKeys count];
 268 
 269         JNIEnv *env = [ThreadUtilities getJNIEnv];
 270 
 271         static JNF_CLASS_CACHE(jc_String, "java/lang/String");
 272         result = JNFNewObjectArray(env, &jc_String, count);
 273         if (!result) {
 274             NSLog(@"In %s, can't create Java array of String objects", __FUNCTION__);
 275             return;
 276         }
 277 
 278         NSInteger i;
 279         for (i = 0; i < count; i++) {
 280             jstring jString = JNFNSToJavaString(env, [ignoredKeys objectAtIndex:i]);
 281             (*env)->SetObjectArrayElement(env, result, i, jString);
 282             (*env)->DeleteLocalRef(env, jString);
 283         }
 284 
 285         sAccessibilityClass = JNFCallStaticObjectMethod(env, jm_getAccessibility, result); // AWT_THREADING Safe (known object)

 286     }
 287 }
 288 
 289 + (void)postFocusChanged:(id)message
 290 {
 291     AWT_ASSERT_APPKIT_THREAD;
 292     NSAccessibilityPostNotification([NSApp accessibilityFocusedUIElement], NSAccessibilityFocusedUIElementChangedNotification);
 293 }
 294 
 295 + (jobject) getCAccessible:(jobject)jaccessible withEnv:(JNIEnv *)env {
 296     if (JNFIsInstanceOf(env, jaccessible, &sjc_CAccessible)) {




 297         return jaccessible;
 298     } else if (JNFIsInstanceOf(env, jaccessible, &sjc_Accessible)) {
 299         return JNFCallStaticObjectMethod(env, sjm_getCAccessible, jaccessible);


 300     }
 301     return NULL;
 302 }
 303 
 304 + (NSArray *)childrenOfParent:(JavaComponentAccessibility *)parent withEnv:(JNIEnv *)env withChildrenCode:(NSInteger)whichChildren allowIgnored:(BOOL)allowIgnored
 305 {
 306     if (parent->fAccessible == NULL) return nil;
 307     jobjectArray jchildrenAndRoles = (jobjectArray)JNFCallStaticObjectMethod(env, jm_getChildrenAndRoles, parent->fAccessible, parent->fComponent, whichChildren, allowIgnored); // AWT_THREADING Safe (AWTRunLoop)



 308     if (jchildrenAndRoles == NULL) return nil;
 309 
 310     jsize arrayLen = (*env)->GetArrayLength(env, jchildrenAndRoles);
 311     NSMutableArray *children = [NSMutableArray arrayWithCapacity:arrayLen/2]; //childrenAndRoles array contains two elements (child, role) for each child
 312 
 313     NSInteger i;
 314     NSUInteger childIndex = (whichChildren >= 0) ? whichChildren : 0; // if we're getting one particular child, make sure to set its index correctly
 315     for(i = 0; i < arrayLen; i+=2)
 316     {
 317         jobject /* Accessible */ jchild = (*env)->GetObjectArrayElement(env, jchildrenAndRoles, i);
 318         jobject /* String */ jchildJavaRole = (*env)->GetObjectArrayElement(env, jchildrenAndRoles, i+1);
 319 
 320         NSString *childJavaRole = nil;
 321         if (jchildJavaRole != NULL) {
 322             jobject jkey = JNFGetObjectField(env, jchildJavaRole, sjf_key);
 323             childJavaRole = JNFJavaToNSString(env, jkey);



 324             (*env)->DeleteLocalRef(env, jkey);
 325         }
 326 
 327         JavaComponentAccessibility *child = [self createWithParent:parent accessible:jchild role:childJavaRole index:childIndex withEnv:env withView:parent->fView];
 328 
 329         (*env)->DeleteLocalRef(env, jchild);
 330         (*env)->DeleteLocalRef(env, jchildJavaRole);
 331 
 332         [children addObject:child];
 333         childIndex++;
 334     }
 335     (*env)->DeleteLocalRef(env, jchildrenAndRoles);
 336 
 337     return children;
 338 }
 339 
 340 + (JavaComponentAccessibility *)createWithAccessible:(jobject)jaccessible withEnv:(JNIEnv *)env withView:(NSView *)view
 341 {

 342     JavaComponentAccessibility *ret = nil;
 343     jobject jcomponent = [(AWTView *)view awtComponent:env];
 344     jint index = JNFCallStaticIntMethod(env, sjm_getAccessibleIndexInParent, jaccessible, jcomponent);

 345     if (index >= 0) {
 346       NSString *javaRole = getJavaRole(env, jaccessible, jcomponent);
 347       ret = [self createWithAccessible:jaccessible role:javaRole index:index withEnv:env withView:view];
 348     }
 349     (*env)->DeleteLocalRef(env, jcomponent);
 350     return ret;
 351 }
 352 
 353 + (JavaComponentAccessibility *) createWithAccessible:(jobject)jaccessible role:(NSString *)javaRole index:(jint)index withEnv:(JNIEnv *)env withView:(NSView *)view
 354 {
 355     return [self createWithParent:nil accessible:jaccessible role:javaRole index:index withEnv:env withView:view];
 356 }
 357 
 358 + (JavaComponentAccessibility *) createWithParent:(JavaComponentAccessibility *)parent accessible:(jobject)jaccessible role:(NSString *)javaRole index:(jint)index withEnv:(JNIEnv *)env withView:(NSView *)view
 359 {


 360     // try to fetch the jCAX from Java, and return autoreleased
 361     jobject jCAX = [JavaComponentAccessibility getCAccessible:jaccessible withEnv:env];
 362     if (jCAX == NULL) return nil;
 363     JavaComponentAccessibility *value = (JavaComponentAccessibility *) jlong_to_ptr(JNFGetLongField(env, jCAX, jf_ptr));
 364     if (value != nil) {
 365         (*env)->DeleteLocalRef(env, jCAX);
 366         return [[value retain] autorelease];
 367     }
 368 
 369     // otherwise, create a new instance
 370     JavaComponentAccessibility *newChild = nil;
 371     if ([javaRole isEqualToString:@"pagetablist"]) {
 372         newChild = [TabGroupAccessibility alloc];
 373     } else if ([javaRole isEqualToString:@"scrollpane"]) {
 374         newChild = [ScrollAreaAccessibility alloc];
 375     } else {
 376         NSString *nsRole = [sRoles objectForKey:javaRole];
 377         if ([nsRole isEqualToString:NSAccessibilityStaticTextRole] || [nsRole isEqualToString:NSAccessibilityTextAreaRole] || [nsRole isEqualToString:NSAccessibilityTextFieldRole]) {
 378             newChild = [JavaTextAccessibility alloc];
 379         } else {
 380             newChild = [JavaComponentAccessibility alloc];
 381         }
 382     }
 383 
 384     // must init freshly -alloc'd object
 385     [newChild initWithParent:parent withEnv:env withAccessible:jCAX withIndex:index withView:view withJavaRole:javaRole]; // must init new instance
 386 
 387     // If creating a JPopupMenu (not a combobox popup list) need to fire menuOpened.
 388     // This is the only way to know if the menu is opening; visible state change
 389     // can't be caught because the listeners are not set up in time.
 390     if ( [javaRole isEqualToString:@"popupmenu"] &&
 391          ![[parent javaRole] isEqualToString:@"combobox"] ) {
 392         [newChild postMenuOpened];
 393     }
 394 
 395     // must hard retain pointer poked into Java object
 396     [newChild retain];
 397     JNFSetLongField(env, jCAX, jf_ptr, ptr_to_jlong(newChild));
 398     (*env)->DeleteLocalRef(env, jCAX);
 399 
 400     // return autoreleased instance
 401     return [newChild autorelease];
 402 }
 403 
 404 - (NSArray *)initializeAttributeNamesWithEnv:(JNIEnv *)env
 405 {
 406     static JNF_STATIC_MEMBER_CACHE(jm_getInitialAttributeStates, sjc_CAccessibility, "getInitialAttributeStates", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)[Z");


 407 
 408     NSMutableArray *attributeNames = [NSMutableArray arrayWithCapacity:20];
 409     [attributeNames retain];
 410 
 411     // all elements respond to parent, role, role description, window, topLevelUIElement, help
 412     [attributeNames addObject:NSAccessibilityParentAttribute];
 413     [attributeNames addObject:NSAccessibilityRoleAttribute];
 414     [attributeNames addObject:NSAccessibilityRoleDescriptionAttribute];
 415     [attributeNames addObject:NSAccessibilityHelpAttribute];
 416 
 417     // cmcnote: AXMenu usually doesn't respond to window / topLevelUIElement. But menus within a Java app's window
 418     // probably should. Should we use some role other than AXMenu / AXMenuBar for Java menus?
 419     [attributeNames addObject:NSAccessibilityWindowAttribute];
 420     [attributeNames addObject:NSAccessibilityTopLevelUIElementAttribute];
 421 
 422     // set accessible subrole
 423     NSString *javaRole = [self javaRole];
 424     if (javaRole != nil && [javaRole isEqualToString:@"passwordtext"]) {
 425         //cmcnote: should turn this into a constant
 426         [attributeNames addObject:NSAccessibilitySubroleAttribute];
 427     }
 428 
 429     // Get all the other accessibility attributes states we need in one swell foop.
 430     // javaRole isn't pulled in because we need protected access to AccessibleRole.key
 431     jbooleanArray attributeStates = (jbooleanArray)JNFCallStaticObjectMethod(env, jm_getInitialAttributeStates, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)


 432     if (attributeStates == NULL) return nil;
 433     jboolean *attributeStatesArray = (*env)->GetBooleanArrayElements(env, attributeStates, 0);
 434     if (attributeStatesArray == NULL) {
 435         // Note: Java will not be on the stack here so a java exception can't happen and no need to call ExceptionCheck.
 436         NSLog(@"%s failed calling GetBooleanArrayElements", __FUNCTION__);
 437         return nil;
 438     }
 439 
 440     // if there's a component, it can be enabled and it has a size/position
 441     if (attributeStatesArray[0]) {
 442         [attributeNames addObject:NSAccessibilityEnabledAttribute];
 443         [attributeNames addObject:NSAccessibilitySizeAttribute];
 444         [attributeNames addObject:NSAccessibilityPositionAttribute];
 445     }
 446 
 447     // According to javadoc, a component that is focusable will return true from isFocusTraversable,
 448     // as well as having AccessibleState.FOCUSABLE in it's AccessibleStateSet.
 449     // We use the former heuristic; if the component focus-traversable, add a focused attribute
 450     // See also: accessibilityIsFocusedAttributeSettable
 451     if (attributeStatesArray[1])
 452     {
 453         [attributeNames addObject:NSAccessibilityFocusedAttribute];
 454     }
 455 
 456     // if it's a pagetab / radiobutton, it has a value but no min/max value.
 457     BOOL hasAxValue = attributeStatesArray[2];
 458     if ([javaRole isEqualToString:@"pagetab"] || [javaRole isEqualToString:@"radiobutton"]) {
 459         [attributeNames addObject:NSAccessibilityValueAttribute];
 460     } else {
 461         // if not a pagetab/radio button, and it has a value, it has a min/max/current value.
 462         if (hasAxValue) {
 463             // er, it has a min/max/current value if it's not a button.
 464             // See AppKit/NSButtonCellAccessibility.m
 465             if (![javaRole isEqualToString:@"pushbutton"]) {
 466                 //cmcnote: make this (and "passwordtext") constants instead of magic strings
 467                 [attributeNames addObject:NSAccessibilityMinValueAttribute];
 468                 [attributeNames addObject:NSAccessibilityMaxValueAttribute];
 469                 [attributeNames addObject:NSAccessibilityValueAttribute];
 470             }
 471         }
 472     }
 473 
 474     // does it have an orientation?
 475     if (attributeStatesArray[4]) {
 476         [attributeNames addObject:NSAccessibilityOrientationAttribute];
 477     }
 478 
 479     // name
 480     if (attributeStatesArray[5]) {
 481         [attributeNames addObject:NSAccessibilityTitleAttribute];
 482     }
 483 
 484     // children
 485     if (attributeStatesArray[6]) {
 486         [attributeNames addObject:NSAccessibilityChildrenAttribute];
 487         if ([javaRole isEqualToString:@"list"]) {
 488             [attributeNames addObject:NSAccessibilitySelectedChildrenAttribute];
 489             [attributeNames addObject:NSAccessibilityVisibleChildrenAttribute];
 490         }
 491         // Just above, the below mentioned support has been added back in for lists.
 492         // However, the following comments may still be useful for future fixes.
 493 //        [attributeNames addObject:NSAccessibilitySelectedChildrenAttribute];
 494 //        [attributeNames addObject:NSAccessibilityVisibleChildrenAttribute];
 495                 //According to AXRoles.txt:
 496                 //VisibleChildren: radio group, list, row, table row subrole
 497                 //SelectedChildren: list
 498     }
 499 
 500     // Cleanup
 501     (*env)->ReleaseBooleanArrayElements(env, attributeStates, attributeStatesArray, JNI_ABORT);
 502 
 503     return attributeNames;
 504 }
 505 
 506 - (NSDictionary *)getActions:(JNIEnv *)env
 507 {
 508     @synchronized(fActionsLOCK) {
 509         if (fActions == nil) {
 510             fActions = [[NSMutableDictionary alloc] initWithCapacity:3];
 511             [self getActionsWithEnv:env];
 512         }
 513     }
 514 
 515     return fActions;
 516 }
 517 
 518 - (void)getActionsWithEnv:(JNIEnv *)env
 519 {
 520     static JNF_STATIC_MEMBER_CACHE(jm_getAccessibleAction, sjc_CAccessibility, "getAccessibleAction", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljavax/accessibility/AccessibleAction;");


 521 
 522     // On MacOSX, text doesn't have actions, in java it does.
 523     // cmcnote: NOT TRUE - Editable text has AXShowMenu. Textfields have AXConfirm. Static text has no actions.
 524     jobject axAction = JNFCallStaticObjectMethod(env, jm_getAccessibleAction, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)

 525     if (axAction != NULL) {
 526         //+++gdb NOTE: In MacOSX, there is just a single Action, not multiple. In java,
 527         //  the first one seems to be the most basic, so this will be used.
 528         // cmcnote: NOT TRUE - Sometimes there are multiple actions, eg sliders have AXDecrement AND AXIncrement (radr://3893192)
 529         JavaAxAction *action = [[JavaAxAction alloc] initWithEnv:env withAccessibleAction:axAction withIndex:0 withComponent:fComponent];
 530         [fActions setObject:action forKey:[self isMenu] ? NSAccessibilityPickAction : NSAccessibilityPressAction];
 531         [action release];
 532         (*env)->DeleteLocalRef(env, axAction);
 533     }
 534 }
 535 
 536 - (jobject)axContextWithEnv:(JNIEnv *)env
 537 {
 538     return getAxContext(env, fAccessible, fComponent);
 539 }
 540 
 541 - (id)parent
 542 {
 543     static JNF_CLASS_CACHE(sjc_Window, "java/awt/Window");
 544     static JNF_STATIC_MEMBER_CACHE(sjm_getAccessibleParent, sjc_CAccessibility, "getAccessibleParent", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljavax/accessibility/Accessible;");
 545     static JNF_STATIC_MEMBER_CACHE(sjm_getSwingAccessible, sjc_CAccessible, "getSwingAccessible", "(Ljavax/accessibility/Accessible;)Ljavax/accessibility/Accessible;");
 546 
 547     if(fParent == nil) {
 548         JNIEnv* env = [ThreadUtilities getJNIEnv];







 549 
 550         jobject jparent = JNFCallStaticObjectMethod(env, sjm_getAccessibleParent, fAccessible, fComponent);

 551 
 552         if (jparent == NULL) {
 553             fParent = fView;
 554         } else {
 555             AWTView *view = fView;
 556             jobject jax = JNFCallStaticObjectMethod(env, sjm_getSwingAccessible, fAccessible);

 557 
 558             if (JNFIsInstanceOf(env, jax, &sjc_Window)) {
 559                 // In this case jparent is an owner toplevel and we should retrieve its own view
 560                 view = [AWTView awtView:env ofAccessible:jparent];
 561             }
 562             if (view != nil) {
 563                 fParent = [JavaComponentAccessibility createWithAccessible:jparent withEnv:env withView:view];
 564             }
 565             if (fParent == nil) {
 566                 fParent = fView;
 567             }
 568             (*env)->DeleteLocalRef(env, jparent);
 569             (*env)->DeleteLocalRef(env, jax );
 570         }
 571         [fParent retain];
 572     }
 573     return fParent;
 574 }
 575 
 576 - (NSView *)view
 577 {
 578     return fView;
 579 }
 580 
 581 - (NSWindow *)window
 582 {
 583     return [[self view] window];
 584 }
 585 
 586 - (NSString *)javaRole
 587 {
 588     if(fJavaRole == nil) {
 589         JNIEnv* env = [ThreadUtilities getJNIEnv];
 590         fJavaRole = getJavaRole(env, fAccessible, fComponent);
 591         [fJavaRole retain];
 592     }
 593     return fJavaRole;
 594 }
 595 
 596 - (BOOL)isMenu
 597 {
 598     id role = [self accessibilityRoleAttribute];
 599     return [role isEqualToString:NSAccessibilityMenuBarRole] || [role isEqualToString:NSAccessibilityMenuRole] || [role isEqualToString:NSAccessibilityMenuItemRole];
 600 }
 601 
 602 - (BOOL)isSelected:(JNIEnv *)env
 603 {
 604     if (fIndex == -1) {
 605         return NO;
 606     }
 607 
 608     return isChildSelected(env, ((JavaComponentAccessibility *)[self parent])->fAccessible, fIndex, fComponent);
 609 }
 610 
 611 - (BOOL)isSelectable:(JNIEnv *)env
 612 {
 613     jobject axContext = [self axContextWithEnv:env];
 614     BOOL selectable = isSelectable(env, axContext, fComponent);
 615     (*env)->DeleteLocalRef(env, axContext);
 616     return selectable;
 617 }
 618 
 619 - (BOOL)isVisible:(JNIEnv *)env
 620 {
 621     if (fIndex == -1) {
 622         return NO;
 623     }
 624 
 625     jobject axContext = [self axContextWithEnv:env];
 626     BOOL showing = isShowing(env, axContext, fComponent);
 627     (*env)->DeleteLocalRef(env, axContext);
 628     return showing;
 629 }
 630 
 631 // the array of names for each role is cached in the sAttributeNamesForRoleCache
 632 - (NSArray *)accessibilityAttributeNames
 633 {
 634     JNIEnv* env = [ThreadUtilities getJNIEnv];
 635 
 636     @synchronized(sAttributeNamesLOCK) {
 637         NSString *javaRole = [self javaRole];
 638         NSArray *names =
 639             (NSArray *)[sAttributeNamesForRoleCache objectForKey:javaRole];
 640         if (names == nil) {
 641             names = [self initializeAttributeNamesWithEnv:env];
 642 #ifdef JAVA_AX_DEBUG
 643             NSLog(@"Initializing: %s for %@: %@", __FUNCTION__, javaRole, names);
 644 #endif
 645             [sAttributeNamesForRoleCache setObject:names forKey:javaRole];
 646         }
 647         // The above set of attributes is immutable per role, but some objects, if
 648         // they are the child of a list, need to add the selected and index attributes.
 649         if ([self accessibilityIsIgnored]) {
 650             return names;
 651         }
 652         id myParent = [self accessibilityParentAttribute];
 653         if ([myParent isKindOfClass:[JavaComponentAccessibility class]]) {
 654             NSString *parentRole = [(JavaComponentAccessibility *)myParent javaRole];
 655             if ([parentRole isEqualToString:@"list"]) {
 656                 NSMutableArray *moreNames =
 657                     [[NSMutableArray alloc] initWithCapacity: [names count] + 2];
 658                 [moreNames addObjectsFromArray: names];
 659                 [moreNames addObject:NSAccessibilitySelectedAttribute];
 660                 [moreNames addObject:NSAccessibilityIndexAttribute];
 661                 return moreNames;
 662             }
 663         }
 664         // popupmenu's return values not selected children
 665         if ( [javaRole isEqualToString:@"popupmenu"] &&
 666              ![[[self parent] javaRole] isEqualToString:@"combobox"] ) {
 667             NSMutableArray *moreNames =
 668                 [[NSMutableArray alloc] initWithCapacity: [names count] + 1];
 669             [moreNames addObjectsFromArray: names];
 670             [moreNames addObject:NSAccessibilityValueAttribute];
 671             return moreNames;
 672         }
 673         return names;
 674 
 675     }  // end @synchronized
 676 
 677 #ifdef JAVA_AX_DEBUG
 678     NSLog(@"Warning in %s: could not find attribute names for role: %@", __FUNCTION__, [self javaRole]);
 679 #endif
 680 
 681     return nil;
 682 }
 683 
 684 // -- accessibility attributes --
 685 
 686 - (BOOL)accessibilityShouldUseUniqueId {
 687     return YES;
 688 }
 689 
 690 - (BOOL)accessibilitySupportsOverriddenAttributes {
 691     return YES;
 692 }
 693 
 694 
 695 // generic getters & setters
 696 // cmcnote: it would make more sense if these generic getters/setters were in JavaAccessibilityUtilities
 697 - (id)accessibilityAttributeValue:(NSString *)attribute
 698 {
 699     AWT_ASSERT_APPKIT_THREAD;
 700 
 701     // turns attribute "NSAccessibilityEnabledAttribute" into getter "accessibilityEnabledAttribute",
 702     // calls getter on self
 703     return JavaAccessibilityAttributeValue(self, attribute);
 704 }
 705 
 706 - (BOOL)accessibilityIsAttributeSettable:(NSString *)attribute
 707 {
 708     AWT_ASSERT_APPKIT_THREAD;
 709 
 710     // turns attribute "NSAccessibilityParentAttribute" into selector "accessibilityIsParentAttributeSettable",
 711     // calls selector on self
 712     return JavaAccessibilityIsAttributeSettable(self, attribute);
 713 }
 714 
 715 - (void)accessibilitySetValue:(id)value forAttribute:(NSString *)attribute
 716 {
 717     AWT_ASSERT_APPKIT_THREAD;
 718 
 719     if ([self accessibilityIsAttributeSettable:attribute]) {
 720         // turns attribute "NSAccessibilityFocusAttribute" into setter "accessibilitySetFocusAttribute",
 721         // calls setter on self
 722         JavaAccessibilitySetAttributeValue(self, attribute, value);
 723     }
 724 }
 725 
 726 
 727 // specific attributes, in alphabetical order a la
 728 // http://developer.apple.com/documentation/Cocoa/Reference/ApplicationKit/ObjC_classic/Protocols/NSAccessibility.html
 729 
 730 // Elements that current element contains (NSArray)
 731 - (NSArray *)accessibilityChildrenAttribute
 732 {
 733     JNIEnv* env = [ThreadUtilities getJNIEnv];
 734     NSArray *children = [JavaComponentAccessibility childrenOfParent:self
 735                                                     withEnv:env
 736                                                     withChildrenCode:JAVA_AX_ALL_CHILDREN
 737                                                     allowIgnored:NO];
 738 
 739     NSArray *value = nil;
 740     if ([children count] > 0) {
 741         value = children;
 742     }
 743 
 744     return value;
 745 }
 746 
 747 - (BOOL)accessibilityIsChildrenAttributeSettable
 748 {
 749     return NO;
 750 }
 751 
 752 - (NSUInteger)accessibilityIndexOfChild:(id)child
 753 {
 754     // Only special-casing for Lists, for now. This allows lists to be accessible, fixing radr://3856139 "JLists are broken".
 755     // Will probably want to special-case for Tables when we implement them (radr://3096643 "Accessibility: Table").
 756     // In AppKit, NSMatrixAccessibility (which uses NSAccessibilityListRole), NSTableRowAccessibility, and NSTableViewAccessibility are the
 757     // only ones that override the default implementation in NSAccessibility
 758     if (![[self accessibilityRoleAttribute] isEqualToString:NSAccessibilityListRole]) {
 759         return [super accessibilityIndexOfChild:child];
 760     }
 761 


 762     jint returnValue =
 763         JNFCallStaticIntMethod( [ThreadUtilities getJNIEnv],

 764                                 sjm_getAccessibleIndexInParent,
 765                                 ((JavaComponentAccessibility *)child)->fAccessible,
 766                                 ((JavaComponentAccessibility *)child)->fComponent );

 767     return (returnValue == -1) ? NSNotFound : returnValue;
 768 }
 769 
 770 // Without this optimization accessibilityChildrenAttribute is called in order to get the entire array of children.
 771 - (NSArray *)accessibilityArrayAttributeValues:(NSString *)attribute index:(NSUInteger)index maxCount:(NSUInteger)maxCount {
 772     if ( (maxCount == 1) && [attribute isEqualToString:NSAccessibilityChildrenAttribute]) {
 773         // Children codes for ALL, SELECTED, VISIBLE are <0. If the code is >=0, we treat it as an index to a single child
 774         NSArray *child = [JavaComponentAccessibility childrenOfParent:self withEnv:[ThreadUtilities getJNIEnv] withChildrenCode:(NSInteger)index allowIgnored:NO];
 775         if ([child count] > 0) {
 776             return child;
 777         }
 778     }
 779     return [super accessibilityArrayAttributeValues:attribute index:index maxCount:maxCount];
 780 }
 781 
 782 // Flag indicating enabled state of element (NSNumber)
 783 - (NSNumber *)accessibilityEnabledAttribute
 784 {
 785     static JNF_STATIC_MEMBER_CACHE(jm_isEnabled, sjc_CAccessibility, "isEnabled", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Z");
 786 
 787     JNIEnv* env = [ThreadUtilities getJNIEnv];
 788     NSNumber *value = [NSNumber numberWithBool:JNFCallStaticBooleanMethod(env, jm_isEnabled, fAccessible, fComponent)]; // AWT_THREADING Safe (AWTRunLoop)




 789     if (value == nil) {
 790         NSLog(@"WARNING: %s called on component that has no accessible component: %@", __FUNCTION__, self);
 791     }
 792     return value;
 793 }
 794 
 795 - (BOOL)accessibilityIsEnabledAttributeSettable
 796 {
 797     return NO;
 798 }
 799 
 800 // Flag indicating presence of keyboard focus (NSNumber)
 801 - (NSNumber *)accessibilityFocusedAttribute
 802 {
 803     if ([self accessibilityIsFocusedAttributeSettable]) {
 804         return [NSNumber numberWithBool:[self isEqual:[NSApp accessibilityFocusedUIElement]]];
 805     }
 806     return [NSNumber numberWithBool:NO];
 807 }
 808 
 809 - (BOOL)accessibilityIsFocusedAttributeSettable
 810 {
 811     JNIEnv* env = [ThreadUtilities getJNIEnv];



 812     // According to javadoc, a component that is focusable will return true from isFocusTraversable,
 813     // as well as having AccessibleState.FOCUSABLE in its AccessibleStateSet.
 814     // We use the former heuristic; if the component focus-traversable, add a focused attribute
 815     // See also initializeAttributeNamesWithEnv:
 816     if (JNFCallStaticBooleanMethod(env, sjm_isFocusTraversable, fAccessible, fComponent)) { // AWT_THREADING Safe (AWTRunLoop)
 817         return YES;
 818     }

 819 
 820     return NO;
 821 }
 822 
 823 - (void)accessibilitySetFocusedAttribute:(id)value
 824 {
 825     static JNF_STATIC_MEMBER_CACHE(jm_requestFocus, sjc_CAccessibility, "requestFocus", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)V");



 826 
 827     if ([(NSNumber*)value boolValue])
 828     {
 829         JNIEnv* env = [ThreadUtilities getJNIEnv];
 830         JNFCallStaticVoidMethod(env, jm_requestFocus, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
 831     }
 832 }
 833 
 834 // Instance description, such as a help tag string (NSString)
 835 - (NSString *)accessibilityHelpAttribute
 836 {
 837     JNIEnv* env = [ThreadUtilities getJNIEnv];
 838 
 839     jobject val = JNFCallStaticObjectMethod(env, sjm_getAccessibleDescription, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)





 840     if (val == NULL) {
 841         return nil;
 842     }
 843     NSString* str = JNFJavaToNSString(env, val);
 844     (*env)->DeleteLocalRef(env, val);
 845     return str;
 846 }
 847 
 848 - (BOOL)accessibilityIsHelpAttributeSettable
 849 {
 850     return NO;
 851 }
 852 
 853 - (NSValue *)accessibilityIndexAttribute
 854 {
 855     NSInteger index = fIndex;
 856     NSValue *returnValue = [NSValue value:&index withObjCType:@encode(NSInteger)];
 857     return returnValue;
 858 }
 859 
 860 - (BOOL)accessibilityIsIndexAttributeSettable
 861 {
 862     return NO;
 863 }
 864 


























 865 // Element's maximum value (id)
 866 - (id)accessibilityMaxValueAttribute
 867 {
 868     static JNF_STATIC_MEMBER_CACHE(jm_getMaximumAccessibleValue, sjc_CAccessibility, "getMaximumAccessibleValue", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/Number;");
 869 
 870     JNIEnv* env = [ThreadUtilities getJNIEnv];



 871 
 872     jobject axValue = JNFCallStaticObjectMethod(env, jm_getMaximumAccessibleValue, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)

 873     if (axValue == NULL) {
 874         return [NSNumber numberWithInt:0];
 875     }
 876     NSNumber* num = JNFJavaToNSNumber(env, axValue);
 877     (*env)->DeleteLocalRef(env, axValue);
 878     return num;
 879 }
 880 
 881 - (BOOL)accessibilityIsMaxValueAttributeSettable
 882 {
 883     return NO;
 884 }
 885 
 886 // Element's minimum value (id)
 887 - (id)accessibilityMinValueAttribute
 888 {
 889     static JNF_STATIC_MEMBER_CACHE(jm_getMinimumAccessibleValue, sjc_CAccessibility, "getMinimumAccessibleValue", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/Number;");
 890 
 891     JNIEnv* env = [ThreadUtilities getJNIEnv];



 892 
 893     jobject axValue = JNFCallStaticObjectMethod(env, jm_getMinimumAccessibleValue, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)

 894     if (axValue == NULL) {
 895         return [NSNumber numberWithInt:0];
 896     }
 897     NSNumber* num = JNFJavaToNSNumber(env, axValue);
 898     (*env)->DeleteLocalRef(env, axValue);
 899     return num;
 900 }
 901 
 902 - (BOOL)accessibilityIsMinValueAttributeSettable
 903 {
 904     return NO;
 905 }
 906 
 907 - (id)accessibilityOrientationAttribute
 908 {
 909     JNIEnv* env = [ThreadUtilities getJNIEnv];
 910     jobject axContext = [self axContextWithEnv:env];
 911 
 912     // cmcnote - should batch these two calls into one that returns an array of two bools, one for vertical and one for horiz
 913     if (isVertical(env, axContext, fComponent)) {
 914         (*env)->DeleteLocalRef(env, axContext);
 915         return NSAccessibilityVerticalOrientationValue;
 916     }
 917 
 918     if (isHorizontal(env, axContext, fComponent)) {
 919         (*env)->DeleteLocalRef(env, axContext);
 920         return NSAccessibilityHorizontalOrientationValue;
 921     }
 922 
 923     (*env)->DeleteLocalRef(env, axContext);
 924     return nil;
 925 }
 926 
 927 - (BOOL)accessibilityIsOrientationAttributeSettable
 928 {
 929     return NO;
 930 }
 931 
 932 // Element containing current element (id)
 933 - (id)accessibilityParentAttribute
 934 {
 935     return NSAccessibilityUnignoredAncestor([self parent]);
 936 }
 937 
 938 - (BOOL)accessibilityIsParentAttributeSettable
 939 {
 940     return NO;
 941 }
 942 
 943 // Screen position of element's lower-left corner in lower-left relative screen coordinates (NSValue)
 944 - (NSValue *)accessibilityPositionAttribute
 945 {
 946     JNIEnv* env = [ThreadUtilities getJNIEnv];
 947     jobject axComponent = JNFCallStaticObjectMethod(env, sjm_getAccessibleComponent, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)



 948 
 949     // NSAccessibility wants the bottom left point of the object in
 950     // bottom left based screen coords
 951 
 952     // Get the java screen coords, and make a NSPoint of the bottom left of the AxComponent.
 953     NSSize size = getAxComponentSize(env, axComponent, fComponent);
 954     NSPoint point = getAxComponentLocationOnScreen(env, axComponent, fComponent);
 955     (*env)->DeleteLocalRef(env, axComponent);
 956 
 957     point.y += size.height;
 958 
 959     // Now make it into Cocoa screen coords.
 960     point.y = [[[[self view] window] screen] frame].size.height - point.y;
 961 
 962     return [NSValue valueWithPoint:point];
 963 }
 964 
 965 - (BOOL)accessibilityIsPositionAttributeSettable
 966 {
 967     // In AppKit, position is only settable for a window (NSAccessibilityWindowRole). Our windows are taken care of natively, so we don't need to deal with this here
 968     // We *could* make use of Java's AccessibleComponent.setLocation() method. Investigate. radr://3953869
 969     return NO;
 970 }
 971 
 972 // Element type, such as NSAccessibilityRadioButtonRole (NSString). See the role table
 973 // at http://developer.apple.com/documentation/Cocoa/Reference/ApplicationKit/ObjC_classic/Protocols/NSAccessibility.html
 974 - (NSString *)accessibilityRoleAttribute
 975 {
 976     if (fNSRole == nil) {
 977         NSString *javaRole = [self javaRole];
 978         fNSRole = [sRoles objectForKey:javaRole];
 979         // The sRoles NSMutableDictionary maps popupmenu to Mac's popup button.
 980         // JComboBox behavior currently relies on this.  However this is not the
 981         // proper mapping for a JPopupMenu so fix that.
 982         if ( [javaRole isEqualToString:@"popupmenu"] &&
 983              ![[[self parent] javaRole] isEqualToString:@"combobox"] ) {
 984              fNSRole = NSAccessibilityMenuRole;
 985         }
 986         if (fNSRole == nil) {
 987             // this component has assigned itself a custom AccessibleRole not in the sRoles array
 988             fNSRole = javaRole;
 989         }
 990         [fNSRole retain];
 991     }
 992     return fNSRole;
 993 }
 994 
 995 - (BOOL)accessibilityIsRoleAttributeSettable
 996 {
 997     return NO;
 998 }
 999 
1000 // Localized, user-readable description of role, such as radio button (NSString)
1001 - (NSString *)accessibilityRoleDescriptionAttribute
1002 {
1003     // first ask AppKit for its accessible role description for a given AXRole
1004     NSString *value = NSAccessibilityRoleDescription([self accessibilityRoleAttribute], nil);
1005 
1006     if (value == nil) {
1007         // query java if necessary
1008         static JNF_STATIC_MEMBER_CACHE(jm_getAccessibleRoleDisplayString, sjc_CAccessibility, "getAccessibleRoleDisplayString", "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)Ljava/lang/String;");
1009 
1010         JNIEnv* env = [ThreadUtilities getJNIEnv];



1011 
1012         jobject axRole = JNFCallStaticObjectMethod(env, jm_getAccessibleRoleDisplayString, fAccessible, fComponent);


1013         if (axRole != NULL) {
1014             value = JNFJavaToNSString(env, axRole);
1015             (*env)->DeleteLocalRef(env, axRole);
1016         } else {
1017             value = @"unknown";
1018         }
1019     }
1020 
1021     return value;
1022 }
1023 
1024 - (BOOL)accessibilityIsRoleDescriptionAttributeSettable
1025 {
1026     return NO;
1027 }
1028 
1029 // Currently selected children (NSArray)
1030 - (NSArray *)accessibilitySelectedChildrenAttribute
1031 {
1032     JNIEnv* env = [ThreadUtilities getJNIEnv];
1033     NSArray *selectedChildren = [JavaComponentAccessibility childrenOfParent:self withEnv:env withChildrenCode:JAVA_AX_SELECTED_CHILDREN allowIgnored:NO];
1034     if ([selectedChildren count] > 0) {
1035         return selectedChildren;
1036     }
1037 
1038     return nil;
1039 }
1040 
1041 - (BOOL)accessibilityIsSelectedChildrenAttributeSettable
1042 {
1043     return NO; // cmcnote: actually it should be. so need to write accessibilitySetSelectedChildrenAttribute also
1044 }
1045 
1046 - (NSNumber *)accessibilitySelectedAttribute
1047 {
1048     return [NSNumber numberWithBool:[self isSelected:[ThreadUtilities getJNIEnv]]];
1049 }
1050 
1051 - (BOOL)accessibilityIsSelectedAttributeSettable
1052 {
1053     if ([self isSelectable:[ThreadUtilities getJNIEnv]]) {
1054         return YES;
1055     } else {
1056         return NO;
1057     }
1058 }
1059 
1060 - (void)accessibilitySetSelectedAttribute:(id)value
1061 {
1062     static JNF_STATIC_MEMBER_CACHE( jm_requestSelection,


1063                                     sjc_CAccessibility,
1064                                     "requestSelection",
1065                                     "(Ljavax/accessibility/Accessible;Ljava/awt/Component;)V" );
1066 
1067     if ([(NSNumber*)value boolValue]) {
1068         JNIEnv* env = [ThreadUtilities getJNIEnv];
1069         JNFCallStaticVoidMethod(env, jm_requestSelection, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)
1070     }
1071 }
1072 
1073 // Element size (NSValue)
1074 - (NSValue *)accessibilitySizeAttribute {
1075     JNIEnv* env = [ThreadUtilities getJNIEnv];
1076     jobject axComponent = JNFCallStaticObjectMethod(env, sjm_getAccessibleComponent, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)



1077     NSValue* size = [NSValue valueWithSize:getAxComponentSize(env, axComponent, fComponent)];
1078     (*env)->DeleteLocalRef(env, axComponent);
1079     return size;
1080 }
1081 
1082 - (BOOL)accessibilityIsSizeAttributeSettable
1083 {
1084     // SIZE is settable in windows if [self styleMask] & NSResizableWindowMask - but windows are heavyweight so we're ok here
1085     // SIZE is settable in columns if [[self tableValue] allowsColumnResizing - haven't dealt with columns yet
1086     return NO;
1087 }
1088 
1089 // Element subrole type, such as NSAccessibilityTableRowSubrole (NSString). See the subrole attribute table at
1090 // http://developer.apple.com/documentation/Cocoa/Reference/ApplicationKit/ObjC_classic/Protocols/NSAccessibility.html
1091 - (NSString *)accessibilitySubroleAttribute
1092 {
1093     NSString *value = nil;
1094     if ([[self javaRole] isEqualToString:@"passwordtext"]) {
1095         value = NSAccessibilitySecureTextFieldSubrole;
1096     }
1097     /*
1098     // other subroles. TableRow and OutlineRow may be relevant to us
1099      NSAccessibilityCloseButtonSubrole // no, heavyweight window takes care of this
1100      NSAccessibilityMinimizeButtonSubrole // "
1101      NSAccessibilityOutlineRowSubrole    // maybe?
1102      NSAccessibilitySecureTextFieldSubrole // currently used
1103      NSAccessibilityTableRowSubrole        // maybe?
1104      NSAccessibilityToolbarButtonSubrole // maybe?
1105      NSAccessibilityUnknownSubrole
1106      NSAccessibilityZoomButtonSubrole    // no, heavyweight window takes care of this
1107      NSAccessibilityStandardWindowSubrole// no, heavyweight window takes care of this
1108      NSAccessibilityDialogSubrole        // maybe?
1109      NSAccessibilitySystemDialogSubrole    // no
1110      NSAccessibilityFloatingWindowSubrole // in 1.5 if we implement these, heavyweight will take care of them anyway
1111      NSAccessibilitySystemFloatingWindowSubrole
1112      NSAccessibilityIncrementArrowSubrole  // no
1113      NSAccessibilityDecrementArrowSubrole  // no
1114      NSAccessibilityIncrementPageSubrole   // no
1115      NSAccessibilityDecrementPageSubrole   // no
1116      NSAccessibilitySearchFieldSubrole    //no
1117      */
1118     return value;
1119 }
1120 
1121 - (BOOL)accessibilityIsSubroleAttributeSettable
1122 {
1123     return NO;
1124 }
1125 
1126 // Title of element, such as button text (NSString)
1127 - (NSString *)accessibilityTitleAttribute
1128 {
1129     // Return empty string for labels, since their value and tile end up being the same thing and this leads to repeated text.
1130     if ([[self accessibilityRoleAttribute] isEqualToString:NSAccessibilityStaticTextRole]) {
1131         return @"";
1132     }
1133 
1134     JNIEnv* env = [ThreadUtilities getJNIEnv];
1135 
1136     jobject val = JNFCallStaticObjectMethod(env, sjm_getAccessibleName, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)


1137     if (val == NULL) {
1138         return nil;
1139     }
1140     NSString* str = JNFJavaToNSString(env, val);
1141     (*env)->DeleteLocalRef(env, val);
1142     return str;
1143 }
1144 
1145 - (BOOL)accessibilityIsTitleAttributeSettable
1146 {
1147     return NO;
1148 }
1149 
1150 - (NSWindow *)accessibilityTopLevelUIElementAttribute
1151 {
1152     return [self window];
1153 }
1154 
1155 - (BOOL)accessibilityIsTopLevelUIElementAttributeSettable
1156 {
1157     return NO;
1158 }
1159 
1160 // Element's value (id)
1161 // note that the appKit meaning of "accessibilityValue" is different from the java
1162 // meaning of "accessibleValue", which is specific to numerical values
1163 // (https://docs.oracle.com/javase/8/docs/api/javax/accessibility/AccessibleValue.html#setCurrentAccessibleValue-java.lang.Number-)
1164 - (id)accessibilityValueAttribute
1165 {
1166     static JNF_STATIC_MEMBER_CACHE(jm_getCurrentAccessibleValue, sjc_CAccessibility, "getCurrentAccessibleValue", "(Ljavax/accessibility/AccessibleValue;Ljava/awt/Component;)Ljava/lang/Number;");
1167 
1168     JNIEnv* env = [ThreadUtilities getJNIEnv];
1169 
1170     // Need to handle popupmenus differently.
1171     //
1172     // At least for now don't handle combo box menus.
1173     // This may change when later fixing issues which currently
1174     // exist for combo boxes, but for now the following is only
1175     // for JPopupMenus, not for combobox menus.
1176     id parent = [self parent];
1177     if ( [[self javaRole] isEqualToString:@"popupmenu"] &&
1178          ![[parent javaRole] isEqualToString:@"combobox"] ) {
1179         NSArray *children =
1180             [JavaComponentAccessibility childrenOfParent:self
1181                                         withEnv:env
1182                                         withChildrenCode:JAVA_AX_ALL_CHILDREN
1183                                         allowIgnored:YES];
1184         if ([children count] > 0) {
1185             // handle case of AXMenuItem
1186             // need to ask menu what is selected
1187             NSArray *selectedChildrenOfMenu =
1188                 [self accessibilitySelectedChildrenAttribute];
1189             JavaComponentAccessibility *selectedMenuItem =
1190                 [selectedChildrenOfMenu objectAtIndex:0];
1191             if (selectedMenuItem != nil) {


1192                 jobject itemValue =
1193                         JNFCallStaticObjectMethod( env,
1194                                                    sjm_getAccessibleName,
1195                                                    selectedMenuItem->fAccessible,
1196                                                    selectedMenuItem->fComponent ); // AWT_THREADING Safe (AWTRunLoop)

1197                 if (itemValue == NULL) {
1198                     return nil;
1199                 }
1200                 NSString* itemString = JNFJavaToNSString(env, itemValue);
1201                 (*env)->DeleteLocalRef(env, itemValue);
1202                 return itemString;
1203             } else {
1204                 return nil;
1205             }
1206         }
1207     }
1208 
1209     // ask Java for the component's accessibleValue. In java, the "accessibleValue" just means a numerical value
1210     // a text value is taken care of in JavaTextAccessibility
1211 
1212     // cmcnote should coalesce these calls into one java call
1213     NSNumber *num = nil;
1214     jobject axValue = JNFCallStaticObjectMethod(env, sjm_getAccessibleValue, fAccessible, fComponent); // AWT_THREADING Safe (AWTRunLoop)




1215     if (axValue != NULL) {
1216         jobject str = JNFCallStaticObjectMethod(env, jm_getCurrentAccessibleValue, axValue, fComponent);



1217         if (str != NULL) {
1218             num = JNFJavaToNSNumber(env, str); // AWT_THREADING Safe (AWTRunLoop)
1219             (*env)->DeleteLocalRef(env, str);
1220         }
1221         (*env)->DeleteLocalRef(env, axValue);
1222     }
1223     if (num == nil) {
1224         num = [NSNumber numberWithInt:0];
1225     }
1226     return num;
1227 }
1228 
1229 - (BOOL)accessibilityIsValueAttributeSettable
1230 {
1231     // according ot AppKit sources, in general the value attribute is not settable, except in the cases
1232     // of an NSScroller, an NSSplitView, and text that's both enabled & editable
1233     BOOL isSettable = NO;
1234     NSString *role = [self accessibilityRoleAttribute];
1235 
1236     if ([role isEqualToString:NSAccessibilityScrollBarRole] || // according to NSScrollerAccessibility
1237         [role isEqualToString:NSAccessibilitySplitGroupRole] ) // according to NSSplitViewAccessibility
1238     {
1239         isSettable = YES;
1240     }
1241     return isSettable;
1242 }
1243 
1244 - (void)accessibilitySetValueAttribute:(id)value
1245 {
1246 #ifdef JAVA_AX_DEBUG
1247     NSLog(@"Not yet implemented: %s\n", __FUNCTION__); // radr://3954018
1248 #endif
1249 }
1250 
1251 
1252 // Child elements that are visible (NSArray)
1253 - (NSArray *)accessibilityVisibleChildrenAttribute
1254 {
1255     JNIEnv *env = [ThreadUtilities getJNIEnv];
1256     NSArray *visibleChildren = [JavaComponentAccessibility childrenOfParent:self withEnv:env withChildrenCode:JAVA_AX_VISIBLE_CHILDREN allowIgnored:NO];
1257     if ([visibleChildren count] <= 0) return nil;
1258     return visibleChildren;
1259 }
1260 
1261 - (BOOL)accessibilityIsVisibleChildrenAttributeSettable
1262 {
1263     return NO;
1264 }
1265 
1266 // Window containing current element (id)
1267 - (id)accessibilityWindowAttribute
1268 {
1269     return [self window];
1270 }
1271 
1272 - (BOOL)accessibilityIsWindowAttributeSettable
1273 {
1274     return NO;
1275 }
1276 
1277 
1278 // -- accessibility actions --
1279 - (NSArray *)accessibilityActionNames
1280 {
1281     JNIEnv *env = [ThreadUtilities getJNIEnv];
1282     return [[self getActions:env] allKeys];
1283 }
1284 
1285 - (NSString *)accessibilityActionDescription:(NSString *)action
1286 {
1287     AWT_ASSERT_APPKIT_THREAD;
1288 
1289     JNIEnv *env = [ThreadUtilities getJNIEnv];
1290     return [(id <JavaAccessibilityAction>)[[self getActions:env] objectForKey:action] getDescription];
1291 }
1292 
1293 - (void)accessibilityPerformAction:(NSString *)action
1294 {
1295     AWT_ASSERT_APPKIT_THREAD;
1296 
1297     JNIEnv *env = [ThreadUtilities getJNIEnv];
1298     [(id <JavaAccessibilityAction>)[[self getActions:env] objectForKey:action] perform];
1299 }
1300 
1301 
1302 // -- misc accessibility --
1303 - (BOOL)accessibilityIsIgnored
1304 {
1305 #ifdef JAVA_AX_NO_IGNORES
1306     return NO;
1307 #else
1308     return [[self accessibilityRoleAttribute] isEqualToString:JavaAccessibilityIgnore];
1309 #endif /* JAVA_AX_NO_IGNORES */
1310 }
1311 
1312 - (id)accessibilityHitTest:(NSPoint)point withEnv:(JNIEnv *)env
1313 {
1314     static JNF_CLASS_CACHE(jc_Container, "java/awt/Container");
1315     static JNF_STATIC_MEMBER_CACHE(jm_accessibilityHitTest, sjc_CAccessibility, "accessibilityHitTest", "(Ljava/awt/Container;FF)Ljavax/accessibility/Accessible;");

1316 
1317     // Make it into java screen coords
1318     point.y = [[[[self view] window] screen] frame].size.height - point.y;
1319 
1320     jobject jparent = fComponent;
1321 
1322     id value = nil;
1323     if (JNFIsInstanceOf(env, jparent, &jc_Container)) {
1324         jobject jaccessible = JNFCallStaticObjectMethod(env, jm_accessibilityHitTest, jparent, (jfloat)point.x, (jfloat)point.y); // AWT_THREADING Safe (AWTRunLoop)


1325         if (jaccessible != NULL) {
1326             value = [JavaComponentAccessibility createWithAccessible:jaccessible withEnv:env withView:fView];
1327             (*env)->DeleteLocalRef(env, jaccessible);
1328         }
1329     }
1330 
1331     if (value == nil) {
1332         value = self;
1333     }
1334 
1335     if ([value accessibilityIsIgnored]) {
1336         value = NSAccessibilityUnignoredAncestor(value);
1337     }
1338 
1339 #ifdef JAVA_AX_DEBUG
1340     NSLog(@"%s: %@", __FUNCTION__, value);
1341 #endif
1342     return value;
1343 }
1344 
1345 - (id)accessibilityFocusedUIElement
1346 {
1347     static JNF_STATIC_MEMBER_CACHE(jm_getFocusOwner, sjc_CAccessibility, "getFocusOwner", "(Ljava/awt/Component;)Ljavax/accessibility/Accessible;");
1348 
1349     JNIEnv *env = [ThreadUtilities getJNIEnv];



1350     id value = nil;
1351 
1352     NSWindow* hostWindow = [[self->fView window] retain];
1353     jobject focused = JNFCallStaticObjectMethod(env, jm_getFocusOwner, fComponent); // AWT_THREADING Safe (AWTRunLoop)
1354     [hostWindow release];

1355 
1356     if (focused != NULL) {
1357         if (JNFIsInstanceOf(env, focused, &sjc_Accessible)) {

1358             value = [JavaComponentAccessibility createWithAccessible:focused withEnv:env withView:fView];
1359         }

1360         (*env)->DeleteLocalRef(env, focused);
1361     }
1362 
1363     if (value == nil) {
1364         value = self;
1365     }
1366 #ifdef JAVA_AX_DEBUG
1367     NSLog(@"%s: %@", __FUNCTION__, value);
1368 #endif
1369     return value;
1370 }
1371 
1372 @end
1373 
1374 /*
1375  * Class:     sun_lwawt_macosx_CAccessibility
1376  * Method:    focusChanged
1377  * Signature: ()V
1378  */
1379 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessibility_focusChanged
1380 (JNIEnv *env, jobject jthis)
1381 {
1382 JNF_COCOA_ENTER(env);
1383     [ThreadUtilities performOnMainThread:@selector(postFocusChanged:) on:[JavaComponentAccessibility class] withObject:nil waitUntilDone:NO];
1384 JNF_COCOA_EXIT(env);
1385 }
1386 
1387 /*
1388  * Class:     sun_lwawt_macosx_CAccessible
1389  * Method:    valueChanged
1390  * Signature: (I)V
1391  */
1392 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessible_valueChanged
1393 (JNIEnv *env, jclass jklass, jlong element)
1394 {
1395 JNF_COCOA_ENTER(env);
1396     [ThreadUtilities performOnMainThread:@selector(postValueChanged) on:(JavaComponentAccessibility *)jlong_to_ptr(element) withObject:nil waitUntilDone:NO];
1397 JNF_COCOA_EXIT(env);
1398 }
1399 
1400 /*
1401  * Class:     sun_lwawt_macosx_CAccessible
1402  * Method:    selectedTextChanged
1403  * Signature: (I)V
1404  */
1405 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessible_selectedTextChanged
1406 (JNIEnv *env, jclass jklass, jlong element)
1407 {
1408 JNF_COCOA_ENTER(env);
1409     [ThreadUtilities performOnMainThread:@selector(postSelectedTextChanged)
1410                      on:(JavaComponentAccessibility *)jlong_to_ptr(element)
1411                      withObject:nil
1412                      waitUntilDone:NO];
1413 JNF_COCOA_EXIT(env);
1414 }
1415 
1416 /*
1417  * Class:     sun_lwawt_macosx_CAccessible
1418  * Method:    selectionChanged
1419  * Signature: (I)V
1420  */
1421 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessible_selectionChanged
1422 (JNIEnv *env, jclass jklass, jlong element)
1423 {
1424 JNF_COCOA_ENTER(env);
1425     [ThreadUtilities performOnMainThread:@selector(postSelectionChanged) on:(JavaComponentAccessibility *)jlong_to_ptr(element) withObject:nil waitUntilDone:NO];
1426 JNF_COCOA_EXIT(env);
1427 }
1428 
1429 /*
1430  * Class:     sun_lwawt_macosx_CAccessible
1431  * Method:    menuOpened
1432  * Signature: (I)V
1433  */
1434 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessible_menuOpened
1435 (JNIEnv *env, jclass jklass, jlong element)
1436 {
1437 JNF_COCOA_ENTER(env);
1438     [ThreadUtilities performOnMainThread:@selector(postMenuOpened)
1439                      on:(JavaComponentAccessibility *)jlong_to_ptr(element)
1440                      withObject:nil
1441                      waitUntilDone:NO];
1442 JNF_COCOA_EXIT(env);
1443 }
1444 
1445 /*
1446  * Class:     sun_lwawt_macosx_CAccessible
1447  * Method:    menuClosed
1448  * Signature: (I)V
1449  */
1450 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessible_menuClosed
1451 (JNIEnv *env, jclass jklass, jlong element)
1452 {
1453 JNF_COCOA_ENTER(env);
1454     [ThreadUtilities performOnMainThread:@selector(postMenuClosed)
1455                      on:(JavaComponentAccessibility *)jlong_to_ptr(element)
1456                      withObject:nil
1457                      waitUntilDone:NO];
1458 JNF_COCOA_EXIT(env);
1459 }
1460 
1461 /*
1462  * Class:     sun_lwawt_macosx_CAccessible
1463  * Method:    menuItemSelected
1464  * Signature: (I)V
1465  */
1466 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessible_menuItemSelected
1467 (JNIEnv *env, jclass jklass, jlong element)
1468 {
1469 JNF_COCOA_ENTER(env);
1470     [ThreadUtilities performOnMainThread:@selector(postMenuItemSelected)
1471                      on:(JavaComponentAccessibility *)jlong_to_ptr(element)
1472                      withObject:nil
1473                      waitUntilDone:NO];
1474 JNF_COCOA_EXIT(env);
1475 }
1476 
1477 /*
1478  * Class:     sun_lwawt_macosx_CAccessible
1479  * Method:    unregisterFromCocoaAXSystem
1480  * Signature: (I)V
1481  */
1482 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CAccessible_unregisterFromCocoaAXSystem
1483 (JNIEnv *env, jclass jklass, jlong element)
1484 {
1485 JNF_COCOA_ENTER(env);
1486     [ThreadUtilities performOnMainThread:@selector(unregisterFromCocoaAXSystem) on:(JavaComponentAccessibility *)jlong_to_ptr(element) withObject:nil waitUntilDone:NO];
1487 JNF_COCOA_EXIT(env);
1488 }
1489 
1490 @implementation TabGroupAccessibility
1491 
1492 - (id)initWithParent:(NSObject *)parent withEnv:(JNIEnv *)env withAccessible:(jobject)accessible withIndex:(jint)index withView:(NSView *)view withJavaRole:(NSString *)javaRole
1493 {
1494     self = [super initWithParent:parent withEnv:env withAccessible:accessible withIndex:index withView:view withJavaRole:javaRole];
1495     if (self) {
1496         _numTabs = -1; //flag for uninitialized numTabs
1497     }
1498     return self;
1499 }
1500 
1501 - (NSArray *)initializeAttributeNamesWithEnv:(JNIEnv *)env
1502 {
1503     NSMutableArray *names = (NSMutableArray *)[super initializeAttributeNamesWithEnv:env];
1504 
1505     [names addObject:NSAccessibilityTabsAttribute];
1506     [names addObject:NSAccessibilityContentsAttribute];
1507     [names addObject:NSAccessibilityValueAttribute];
1508 
1509     return names;
1510 }
1511 
1512 - (id)currentTabWithEnv:(JNIEnv *)env withAxContext:(jobject)axContext
1513 {
1514     NSArray *tabs = [self tabControlsWithEnv:env withTabGroupAxContext:axContext withTabCode:JAVA_AX_ALL_CHILDREN allowIgnored:NO];
1515 
1516     // Looking at the JTabbedPane sources, there is always one AccessibleSelection.
1517     jobject selAccessible = getAxContextSelection(env, axContext, 0, fComponent);
1518     if (selAccessible == NULL) return nil;
1519 
1520     // Go through the tabs and find selAccessible
1521     _numTabs = [tabs count];
1522     JavaComponentAccessibility *aTab;
1523     NSInteger i;
1524     for (i = 0; i < _numTabs; i++) {
1525         aTab = (JavaComponentAccessibility *)[tabs objectAtIndex:i];
1526         if ([aTab isAccessibleWithEnv:env forAccessible:selAccessible]) {
1527             (*env)->DeleteLocalRef(env, selAccessible);
1528             return aTab;
1529         }
1530     }
1531     (*env)->DeleteLocalRef(env, selAccessible);
1532     return nil;
1533 }
1534 
1535 - (NSArray *)tabControlsWithEnv:(JNIEnv *)env withTabGroupAxContext:(jobject)axContext withTabCode:(NSInteger)whichTabs allowIgnored:(BOOL)allowIgnored
1536 {
1537     jobjectArray jtabsAndRoles = (jobjectArray)JNFCallStaticObjectMethod(env, jm_getChildrenAndRoles, fAccessible, fComponent, whichTabs, allowIgnored); // AWT_THREADING Safe (AWTRunLoop)



1538     if(jtabsAndRoles == NULL) return nil;
1539 
1540     jsize arrayLen = (*env)->GetArrayLength(env, jtabsAndRoles);
1541     if (arrayLen == 0) {
1542         (*env)->DeleteLocalRef(env, jtabsAndRoles);
1543         return nil;
1544     }
1545     NSMutableArray *tabs = [NSMutableArray arrayWithCapacity:(arrayLen/2)];
1546 
1547     // all of the tabs have the same role, so we can just find out what that is here and use it for all the tabs
1548     jobject jtabJavaRole = (*env)->GetObjectArrayElement(env, jtabsAndRoles, 1); // the array entries alternate between tab/role, starting with tab. so the first role is entry 1.
1549     if (jtabJavaRole == NULL) {
1550         (*env)->DeleteLocalRef(env, jtabsAndRoles);
1551         return nil;
1552     }
1553     jobject jkey = JNFGetObjectField(env, jtabJavaRole, sjf_key);
1554     NSString *tabJavaRole = JNFJavaToNSString(env, jkey);



1555     (*env)->DeleteLocalRef(env, jkey);
1556 
1557     NSInteger i;
1558     NSUInteger tabIndex = (whichTabs >= 0) ? whichTabs : 0; // if we're getting one particular child, make sure to set its index correctly
1559     for(i = 0; i < arrayLen; i+=2) {
1560         jobject jtab = (*env)->GetObjectArrayElement(env, jtabsAndRoles, i);
1561         JavaComponentAccessibility *tab = [[[TabGroupControlAccessibility alloc] initWithParent:self withEnv:env withAccessible:jtab withIndex:tabIndex withTabGroup:axContext withView:[self view] withJavaRole:tabJavaRole] autorelease];
1562         (*env)->DeleteLocalRef(env, jtab);
1563         [tabs addObject:tab];
1564         tabIndex++;
1565     }
1566     (*env)->DeleteLocalRef(env, jtabsAndRoles);
1567     return tabs;
1568 }
1569 
1570 - (NSArray *)contentsWithEnv:(JNIEnv *)env withTabGroupAxContext:(jobject)axContext withTabCode:(NSInteger)whichTabs allowIgnored:(BOOL)allowIgnored
1571 {
1572     // Contents are the children of the selected tab.
1573     id currentTab = [self currentTabWithEnv:env withAxContext:axContext];
1574     if (currentTab == nil) return nil;
1575 
1576     NSArray *contents = [JavaComponentAccessibility childrenOfParent:currentTab withEnv:env withChildrenCode:whichTabs allowIgnored:allowIgnored];
1577     if ([contents count] <= 0) return nil;
1578     return contents;
1579 }
1580 
1581 - (id) accessibilityTabsAttribute
1582 {
1583     JNIEnv *env = [ThreadUtilities getJNIEnv];
1584     jobject axContext = [self axContextWithEnv:env];
1585     id tabs = [self tabControlsWithEnv:env withTabGroupAxContext:axContext withTabCode:JAVA_AX_ALL_CHILDREN allowIgnored:NO];
1586     (*env)->DeleteLocalRef(env, axContext);
1587     return tabs;
1588 }
1589 
1590 - (BOOL)accessibilityIsTabsAttributeSettable
1591 {
1592     return NO; //cmcnote: not sure.
1593 }
1594 
1595 - (NSInteger)numTabs
1596 {
1597     if (_numTabs == -1) {
1598         _numTabs = [[self accessibilityTabsAttribute] count];
1599     }
1600     return _numTabs;
1601 }
1602 
1603 - (NSArray *) accessibilityContentsAttribute
1604 {
1605     JNIEnv *env = [ThreadUtilities getJNIEnv];
1606     jobject axContext = [self axContextWithEnv:env];
1607     NSArray* cont = [self contentsWithEnv:env withTabGroupAxContext:axContext withTabCode:JAVA_AX_ALL_CHILDREN allowIgnored:NO];
1608     (*env)->DeleteLocalRef(env, axContext);
1609     return cont;
1610 }
1611 
1612 - (BOOL)accessibilityIsContentsAttributeSettable
1613 {
1614     return NO;
1615 }
1616 
1617 // axValue is the currently selected tab
1618 -(id) accessibilityValueAttribute
1619 {
1620     JNIEnv *env = [ThreadUtilities getJNIEnv];
1621     jobject axContext = [self axContextWithEnv:env];
1622     id val = [self currentTabWithEnv:env withAxContext:axContext];
1623     (*env)->DeleteLocalRef(env, axContext);
1624     return val;
1625 }
1626 
1627 - (BOOL)accessibilityIsValueAttributeSettable
1628 {
1629     return YES;
1630 }
1631 
1632 - (void)accessibilitySetValueAttribute:(id)value //cmcnote: not certain this is ever actually called. investigate.
1633 {
1634     // set the current tab
1635     NSNumber *number = (NSNumber *)value;
1636     if (![number boolValue]) return;
1637 
1638     JNIEnv *env = [ThreadUtilities getJNIEnv];
1639     jobject axContext = [self axContextWithEnv:env];
1640     setAxContextSelection(env, axContext, fIndex, fComponent);
1641     (*env)->DeleteLocalRef(env, axContext);
1642 }
1643 
1644 - (NSArray *)accessibilityChildrenAttribute
1645 {
1646     //children = AXTabs + AXContents
1647     NSArray *tabs = [self accessibilityTabsAttribute];
1648     NSArray *contents = [self accessibilityContentsAttribute];
1649 
1650     NSMutableArray *children = [NSMutableArray arrayWithCapacity:[tabs count] + [contents count]];
1651     [children addObjectsFromArray:tabs];
1652     [children addObjectsFromArray:contents];
1653 
1654     return (NSArray *)children;
1655 }
1656 
1657 // Without this optimization accessibilityChildrenAttribute is called in order to get the entire array of children.
1658 // See similar optimization in JavaComponentAccessibility. We have to extend the base implementation here, since
1659 // children of tabs are AXTabs + AXContents
1660 - (NSArray *)accessibilityArrayAttributeValues:(NSString *)attribute index:(NSUInteger)index maxCount:(NSUInteger)maxCount {
1661     NSArray *result = nil;
1662     if ( (maxCount == 1) && [attribute isEqualToString:NSAccessibilityChildrenAttribute]) {
1663         // Children codes for ALL, SELECTED, VISIBLE are <0. If the code is >=0, we treat it as an index to a single child
1664         JNIEnv *env = [ThreadUtilities getJNIEnv];
1665         jobject axContext = [self axContextWithEnv:env];
1666 
1667         //children = AXTabs + AXContents
1668         NSArray *children = [self tabControlsWithEnv:env withTabGroupAxContext:axContext withTabCode:index allowIgnored:NO]; // first look at the tabs
1669         if ([children count] > 0) {
1670             result = children;
1671          } else {
1672             children= [self contentsWithEnv:env withTabGroupAxContext:axContext withTabCode:(index-[self numTabs]) allowIgnored:NO];
1673             if ([children count] > 0) {
1674                 result = children;
1675             }
1676         }
1677         (*env)->DeleteLocalRef(env, axContext);
1678     } else {
1679         result = [super accessibilityArrayAttributeValues:attribute index:index maxCount:maxCount];
1680     }
1681     return result;
1682 }
1683 
1684 @end
1685 
1686 
1687 static BOOL ObjectEquals(JNIEnv *env, jobject a, jobject b, jobject component);
1688 
1689 @implementation TabGroupControlAccessibility
1690 
1691 - (id)initWithParent:(NSObject *)parent withEnv:(JNIEnv *)env withAccessible:(jobject)accessible withIndex:(jint)index withTabGroup:(jobject)tabGroup withView:(NSView *)view withJavaRole:(NSString *)javaRole
1692 {
1693     self = [super initWithParent:parent withEnv:env withAccessible:accessible withIndex:index withView:view withJavaRole:javaRole];
1694     if (self) {
1695         if (tabGroup != NULL) {
1696             fTabGroupAxContext = JNFNewWeakGlobalRef(env, tabGroup);

1697         } else {
1698             fTabGroupAxContext = NULL;
1699         }
1700     }
1701     return self;
1702 }
1703 
1704 - (void)dealloc
1705 {
1706     JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
1707 
1708     if (fTabGroupAxContext != NULL) {
1709         JNFDeleteWeakGlobalRef(env, fTabGroupAxContext);
1710         fTabGroupAxContext = NULL;
1711     }
1712 
1713     [super dealloc];
1714 }
1715 
1716 - (id)accessibilityValueAttribute
1717 {
1718     JNIEnv *env = [ThreadUtilities getJNIEnv];
1719     jobject axContext = [self axContextWithEnv:env];
1720     jobject selAccessible = getAxContextSelection(env, [self tabGroup], fIndex, fComponent);
1721 
1722     // Returns the current selection of the page tab list
1723     id val = [NSNumber numberWithBool:ObjectEquals(env, axContext, selAccessible, fComponent)];
1724 
1725     (*env)->DeleteLocalRef(env, selAccessible);
1726     (*env)->DeleteLocalRef(env, axContext);
1727     return val;
1728 }
1729 
1730 - (void)getActionsWithEnv:(JNIEnv *)env
1731 {
1732     TabGroupAction *action = [[TabGroupAction alloc] initWithEnv:env withTabGroup:[self tabGroup] withIndex:fIndex withComponent:fComponent];
1733     [fActions setObject:action forKey:NSAccessibilityPressAction];
1734     [action release];
1735 }
1736 
1737 - (jobject)tabGroup
1738 {
1739     if (fTabGroupAxContext == NULL) {
1740         JNIEnv* env = [ThreadUtilities getJNIEnv];
1741         jobject tabGroupAxContext = [(JavaComponentAccessibility *)[self parent] axContextWithEnv:env];
1742         fTabGroupAxContext = JNFNewWeakGlobalRef(env, tabGroupAxContext);

1743         (*env)->DeleteLocalRef(env, tabGroupAxContext);
1744     }
1745     return fTabGroupAxContext;
1746 }
1747 
1748 @end
1749 
1750 
1751 @implementation ScrollAreaAccessibility
1752 
1753 - (NSArray *)initializeAttributeNamesWithEnv:(JNIEnv *)env
1754 {
1755     NSMutableArray *names = (NSMutableArray *)[super initializeAttributeNamesWithEnv:env];
1756 
1757     [names addObject:NSAccessibilityHorizontalScrollBarAttribute];
1758     [names addObject:NSAccessibilityVerticalScrollBarAttribute];
1759     [names addObject:NSAccessibilityContentsAttribute];
1760 
1761     return names;
1762 }
1763 
1764 - (id)accessibilityHorizontalScrollBarAttribute
1765 {
1766     JNIEnv *env = [ThreadUtilities getJNIEnv];
1767 
1768     NSArray *children = [JavaComponentAccessibility childrenOfParent:self withEnv:env withChildrenCode:JAVA_AX_ALL_CHILDREN allowIgnored:YES];
1769     if ([children count] <= 0) return nil;
1770 
1771     // The scroll bars are in the children.
1772     JavaComponentAccessibility *aElement;
1773     NSEnumerator *enumerator = [children objectEnumerator];
1774     while ((aElement = (JavaComponentAccessibility *)[enumerator nextObject])) {
1775         if ([[aElement accessibilityRoleAttribute] isEqualToString:NSAccessibilityScrollBarRole]) {
1776             jobject elementAxContext = [aElement axContextWithEnv:env];
1777             if (isHorizontal(env, elementAxContext, fComponent)) {
1778                 (*env)->DeleteLocalRef(env, elementAxContext);
1779                 return aElement;
1780             }
1781             (*env)->DeleteLocalRef(env, elementAxContext);
1782         }
1783     }
1784 
1785     return nil;
1786 }
1787 
1788 - (BOOL)accessibilityIsHorizontalScrollBarAttributeSettable
1789 {
1790     return NO;
1791 }
1792 
1793 - (id)accessibilityVerticalScrollBarAttribute
1794 {
1795     JNIEnv *env = [ThreadUtilities getJNIEnv];
1796 
1797     NSArray *children = [JavaComponentAccessibility childrenOfParent:self withEnv:env withChildrenCode:JAVA_AX_ALL_CHILDREN allowIgnored:YES];
1798     if ([children count] <= 0) return nil;
1799 
1800     // The scroll bars are in the children.
1801     NSEnumerator *enumerator = [children objectEnumerator];
1802     JavaComponentAccessibility *aElement;
1803     while ((aElement = (JavaComponentAccessibility *)[enumerator nextObject])) {
1804         if ([[aElement accessibilityRoleAttribute] isEqualToString:NSAccessibilityScrollBarRole]) {
1805             jobject elementAxContext = [aElement axContextWithEnv:env];
1806             if (isVertical(env, elementAxContext, fComponent)) {
1807                 (*env)->DeleteLocalRef(env, elementAxContext);
1808                 return aElement;
1809             }
1810             (*env)->DeleteLocalRef(env, elementAxContext);
1811         }
1812     }
1813 
1814     return nil;
1815 }
1816 
1817 - (BOOL)accessibilityIsVerticalScrollBarAttributeSettable
1818 {
1819     return NO;
1820 }
1821 
1822 - (NSArray *)accessibilityContentsAttribute
1823 {
1824     JNIEnv *env = [ThreadUtilities getJNIEnv];
1825     NSArray *children = [JavaComponentAccessibility childrenOfParent:self withEnv:env withChildrenCode:JAVA_AX_ALL_CHILDREN allowIgnored:YES];
1826 
1827     if ([children count] <= 0) return nil;
1828     NSArray *contents = [NSMutableArray arrayWithCapacity:[children count]];
1829 
1830     // The scroll bars are in the children. children less the scroll bars is the contents
1831     NSEnumerator *enumerator = [children objectEnumerator];
1832     JavaComponentAccessibility *aElement;
1833     while ((aElement = (JavaComponentAccessibility *)[enumerator nextObject])) {
1834         if (![[aElement accessibilityRoleAttribute] isEqualToString:NSAccessibilityScrollBarRole]) {
1835             // no scroll bars in contents
1836             [(NSMutableArray *)contents addObject:aElement];
1837         }
1838     }
1839 
1840     return contents;
1841 }
1842 
1843 - (BOOL)accessibilityIsContentsAttributeSettable
1844 {
1845     return NO;
1846 }
1847 
1848 @end
1849 
1850 /*
1851  * Returns Object.equals for the two items
1852  * This may use LWCToolkit.invokeAndWait(); don't call while holding fLock
1853  * and try to pass a component so the event happens on the correct thread.
1854  */
1855 static JNF_CLASS_CACHE(sjc_Object, "java/lang/Object");
1856 static BOOL ObjectEquals(JNIEnv *env, jobject a, jobject b, jobject component)
1857 {
1858     static JNF_MEMBER_CACHE(jm_equals, sjc_Object, "equals", "(Ljava/lang/Object;)Z");

1859 
1860     if ((a == NULL) && (b == NULL)) return YES;
1861     if ((a == NULL) || (b == NULL)) return NO;
1862 
1863     if (pthread_main_np() != 0) {
1864         // If we are on the AppKit thread
1865         static JNF_CLASS_CACHE(sjc_LWCToolkit, "sun/lwawt/macosx/LWCToolkit");
1866         static JNF_STATIC_MEMBER_CACHE(jm_doEquals, sjc_LWCToolkit, "doEquals", "(Ljava/lang/Object;Ljava/lang/Object;Ljava/awt/Component;)Z");
1867         return JNFCallStaticBooleanMethod(env, jm_doEquals, a, b, component); // AWT_THREADING Safe (AWTRunLoopMode)


1868     }
1869 
1870     return JNFCallBooleanMethod(env, a, jm_equals, b); // AWT_THREADING Safe (!appKit)


1871 }
--- EOF ---