41
41
import java .util .Set ;
42
42
import java .util .concurrent .Callable ;
43
43
import java .util .Arrays ;
44
+ import java .util .function .Function ;
44
45
45
46
import javax .accessibility .Accessible ;
46
47
import javax .accessibility .AccessibleAction ;
@@ -658,21 +659,29 @@ public boolean[] call() throws Exception {
658
659
@ Native static final int JAVA_AX_SELECTED_CHILDREN = -2 ;
659
660
@ Native static final int JAVA_AX_VISIBLE_CHILDREN = -3 ;
660
661
662
+ private static Object [] getTableRowChildrenAndRoles (Accessible a , Component c , int whichChildren , boolean allowIgnored , int tableRowIndex ) {
663
+ return invokeGetChildrenAndRoles (a , c , whichChildren , allowIgnored , ChildrenOperations .createForTableRow (tableRowIndex ));
664
+ }
665
+
661
666
// Each child takes up two entries in the array: one for itself and one for its role
662
- public static Object [] getChildrenAndRoles (final Accessible a , final Component c , final int whichChildren , final boolean allowIgnored ) {
667
+ private static Object [] getChildrenAndRoles (final Accessible a , final Component c , final int whichChildren , final boolean allowIgnored ) {
668
+ return invokeGetChildrenAndRoles (a , c , whichChildren , allowIgnored , ChildrenOperations .COMMON );
669
+ }
670
+
671
+ private static Object [] invokeGetChildrenAndRoles (Accessible a , Component c , int whichChildren , boolean allowIgnored , ChildrenOperations ops ) {
663
672
if (a == null ) return null ;
664
673
return invokeAndWait (new Callable <Object []>() {
665
674
public Object [] call () throws Exception {
666
- return getChildrenAndRolesImpl (a , c , whichChildren , allowIgnored );
675
+ return getChildrenAndRolesImpl (a , c , whichChildren , allowIgnored , ops );
667
676
}
668
677
}, c );
669
678
}
670
679
671
- private static Object [] getChildrenAndRolesImpl (final Accessible a , final Component c , final int whichChildren , final boolean allowIgnored ) {
680
+ private static Object [] getChildrenAndRolesImpl (Accessible a , Component c , int whichChildren , boolean allowIgnored , ChildrenOperations ops ) {
672
681
if (a == null ) return null ;
673
682
674
683
ArrayList <Object > childrenAndRoles = new ArrayList <Object >();
675
- _addChildren (a , whichChildren , allowIgnored , childrenAndRoles );
684
+ _addChildren (a , whichChildren , allowIgnored , childrenAndRoles , ops );
676
685
677
686
/* In case of fetching a selection, we need to check if
678
687
* the active descendant is at the beginning of the list, or
@@ -743,7 +752,7 @@ public Object[] call() throws Exception {
743
752
while (!parentStack .isEmpty ()) {
744
753
Accessible p = parentStack .get (parentStack .size () - 1 );
745
754
746
- currentLevelChildren .addAll (Arrays .asList (getChildrenAndRolesImpl (p , c , JAVA_AX_ALL_CHILDREN , allowIgnored )));
755
+ currentLevelChildren .addAll (Arrays .asList (getChildrenAndRolesImpl (p , c , JAVA_AX_ALL_CHILDREN , allowIgnored , ChildrenOperations . COMMON )));
747
756
if ((currentLevelChildren .size () == 0 ) || (index >= currentLevelChildren .size ())) {
748
757
if (!parentStack .isEmpty ()) parentStack .remove (parentStack .size () - 1 );
749
758
if (!indexses .isEmpty ()) index = indexses .remove (indexses .size () - 1 );
@@ -855,20 +864,70 @@ private static AccessibleRole getAccessibleRole(Accessible a) {
855
864
return role ;
856
865
}
857
866
867
+ private interface ChildrenOperations {
868
+ boolean isContextValid (AccessibleContext accessibleContext );
869
+ int getChildrenCount (AccessibleContext accessibleContext );
870
+ Accessible getAccessibleChild (AccessibleContext accessibleContext , int childIndex );
871
+
872
+ static ChildrenOperations COMMON = createForCommon ();
873
+
874
+ static ChildrenOperations createForCommon () {
875
+ return new ChildrenOperations () {
876
+ @ Override
877
+ public boolean isContextValid (AccessibleContext accessibleContext ) {
878
+ return accessibleContext != null ;
879
+ }
880
+
881
+ @ Override
882
+ public int getChildrenCount (AccessibleContext accessibleContext ) {
883
+ assert isContextValid (accessibleContext );
884
+ return accessibleContext .getAccessibleChildrenCount ();
885
+ }
886
+
887
+ @ Override
888
+ public Accessible getAccessibleChild (AccessibleContext accessibleContext , int childIndex ) {
889
+ assert isContextValid (accessibleContext );
890
+ return accessibleContext .getAccessibleChild (childIndex );
891
+ }
892
+ };
893
+ }
894
+
895
+ static ChildrenOperations createForTableRow (int tableRowIndex ) {
896
+ return new ChildrenOperations () {
897
+ @ Override
898
+ public boolean isContextValid (AccessibleContext accessibleContext ) {
899
+ return accessibleContext instanceof AccessibleTable ;
900
+ }
901
+
902
+ @ Override
903
+ public int getChildrenCount (AccessibleContext accessibleContext ) {
904
+ assert isContextValid (accessibleContext );
905
+ return ((AccessibleTable )accessibleContext ).getAccessibleColumnCount ();
906
+ }
907
+
908
+ @ Override
909
+ public Accessible getAccessibleChild (AccessibleContext accessibleContext , int childIndex ) {
910
+ assert isContextValid (accessibleContext );
911
+ return ((AccessibleTable )accessibleContext ).getAccessibleAt (tableRowIndex , childIndex );
912
+ }
913
+ };
914
+ }
915
+ }
916
+
858
917
859
918
// Either gets the immediate children of a, or recursively gets all unignored children of a
860
- private static void _addChildren (final Accessible a , final int whichChildren , final boolean allowIgnored , final ArrayList <Object > childrenAndRoles ) {
919
+ private static void _addChildren (Accessible a , int whichChildren , boolean allowIgnored , ArrayList <Object > childrenAndRoles , ChildrenOperations ops ) {
861
920
if (a == null ) return ;
862
921
863
922
final AccessibleContext ac = a .getAccessibleContext ();
864
- if (ac == null ) return ;
923
+ if (! ops . isContextValid ( ac ) ) return ;
865
924
866
- final int numChildren = ac . getAccessibleChildrenCount ( );
925
+ final int numChildren = ops . getChildrenCount ( ac );
867
926
868
927
// each child takes up two entries in the array: itself, and its role
869
928
// so the array holds alternating Accessible and AccessibleRole objects
870
929
for (int i = 0 ; i < numChildren ; i ++) {
871
- final Accessible child = ac .getAccessibleChild (i );
930
+ final Accessible child = ops .getAccessibleChild (ac , i );
872
931
if (child == null ) continue ;
873
932
874
933
final AccessibleContext context = child .getAccessibleContext ();
@@ -890,7 +949,7 @@ private static void _addChildren(final Accessible a, final int whichChildren, fi
890
949
final AccessibleRole role = context .getAccessibleRole ();
891
950
if (role != null && ignoredRoles != null && ignoredRoles .contains (roleKey (role ))) {
892
951
// Get the child's unignored children.
893
- _addChildren (child , whichChildren , false , childrenAndRoles );
952
+ _addChildren (child , whichChildren , false , childrenAndRoles , ChildrenOperations . COMMON );
894
953
} else {
895
954
childrenAndRoles .add (child );
896
955
childrenAndRoles .add (getAccessibleRole (child ));
0 commit comments