1440 }
1441 }, ac);
1442 if (stateSet != null) {
1443 String s = "";
1444 AccessibleState[] states = stateSet.toArray();
1445 if (states != null && states.length > 0) {
1446 s = states[0].toDisplayString(Locale.US);
1447 for (int i = 1; i < states.length; i++) {
1448 s = s + "," + states[i].toDisplayString(Locale.US);
1449 }
1450 }
1451 references.increment(s);
1452 debugString("[INFO]: Returning AccessibleStateSet en_US from Context: " + s);
1453 return s;
1454 }
1455 }
1456 debugString("[ERROR]: getAccessibleStatesStringFromContext; ac = null");
1457 return null;
1458 }
1459
1460 /**
1461 * returns the AccessibleParent from an AccessibleContext
1462 */
1463 private AccessibleContext getAccessibleParentFromContext(final AccessibleContext ac) {
1464 if (ac==null)
1465 return null;
1466 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
1467 @Override
1468 public AccessibleContext call() throws Exception {
1469 Accessible a = ac.getAccessibleParent();
1470 if (a != null) {
1471 AccessibleContext apc = a.getAccessibleContext();
1472 if (apc != null) {
1473 return apc;
1474 }
1475 }
1476 return null;
1477 }
1478 }, ac);
1479 }
1480
1481 /**
1482 * returns the AccessibleIndexInParent from an AccessibleContext
1483 */
1484 private int getAccessibleIndexInParentFromContext(final AccessibleContext ac) {
1485 if (ac==null)
1486 return -1;
1487 return InvocationUtils.invokeAndWait(new Callable<Integer>() {
1488 @Override
1489 public Integer call() throws Exception {
1490 return ac.getAccessibleIndexInParent();
1491 }
1492 }, ac);
1493 }
1494
1495 /**
1496 * returns the AccessibleChild count from an AccessibleContext
1497 */
1498 private int getAccessibleChildrenCountFromContext(final AccessibleContext ac) {
1499 if (ac==null)
1500 return -1;
1501 return InvocationUtils.invokeAndWait(new Callable<Integer>() {
1502 @Override
1503 public Integer call() throws Exception {
1504 return ac.getAccessibleChildrenCount();
1505 }
1506 }, ac);
1507 }
1508
1509 /**
1510 * returns the AccessibleChild Context from an AccessibleContext
1511 */
1512 private AccessibleContext getAccessibleChildFromContext(final AccessibleContext ac, final int index) {
1513
1514 if (ac == null) {
1515 return null;
1516 }
1517
1518 final JTable table = InvocationUtils.invokeAndWait(new Callable<JTable>() {
1519 @Override
1520 public JTable call() throws Exception {
1521 // work-around for AccessibleJTable.getCurrentAccessibleContext returning
1522 // wrong renderer component when cell contains more than one component
1523 Accessible parent = ac.getAccessibleParent();
1524 if (parent != null) {
1525 int indexInParent = ac.getAccessibleIndexInParent();
1526 Accessible child =
1527 parent.getAccessibleContext().getAccessibleChild(indexInParent);
1528 if (child instanceof JTable) {
1529 return (JTable) child;
1530 }
1531 }
1532 return null;
1533 }
1534 }, ac);
1535
1536 if (table == null) {
1537 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
1538 @Override
1539 public AccessibleContext call() throws Exception {
1540 Accessible a = ac.getAccessibleChild(index);
1541 if (a != null) {
1542 return a.getAccessibleContext();
1543 }
1544 return null;
1545 }
1546 }, ac);
1547 }
1548
1549 final AccessibleTable at = getAccessibleTableFromContext(ac);
1550
1551 final int row = getAccessibleTableRow(at, index);
1552 final int column = getAccessibleTableColumn(at, index);
1553
1554 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
1555 @Override
1556 public AccessibleContext call() throws Exception {
1557 TableCellRenderer renderer = table.getCellRenderer(row, column);
1558 if (renderer == null) {
1559 Class<?> columnClass = table.getColumnClass(column);
1560 renderer = table.getDefaultRenderer(columnClass);
3500 }
3501 return null;
3502 }
3503 }, ac);
3504 }
3505
3506 /*
3507 * returns the number of targets in a relation in the AccessibleContext's
3508 * AccessibleRelationSet
3509 */
3510 private int getAccessibleRelationTargetCount(final AccessibleContext ac, final int i) {
3511 return InvocationUtils.invokeAndWait(new Callable<Integer>() {
3512 @Override
3513 public Integer call() throws Exception {
3514 if (ac != null) {
3515 AccessibleRelationSet ars = ac.getAccessibleRelationSet();
3516 if (ars != null) {
3517 AccessibleRelation[] relations = ars.toArray();
3518 if (relations != null && i >= 0 && i < relations.length) {
3519 Object[] targets = relations[i].getTarget();
3520 return targets.length;
3521 }
3522 }
3523 }
3524 return -1;
3525 }
3526 }, ac);
3527 }
3528
3529 /*
3530 * returns the jth target in the ith relation in the AccessibleContext's
3531 * AccessibleRelationSet
3532 */
3533 private AccessibleContext getAccessibleRelationTarget(final AccessibleContext ac,
3534 final int i, final int j) {
3535 debugString("[INFO]: ***** getAccessibleRelationTarget");
3536 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
3537 @Override
3538 public AccessibleContext call() throws Exception {
3539 if (ac != null) {
3540 AccessibleRelationSet ars = ac.getAccessibleRelationSet();
3541 if (ars != null) {
3542 AccessibleRelation[] relations = ars.toArray();
3543 if (relations != null && i >= 0 && i < relations.length) {
3544 Object[] targets = relations[i].getTarget();
3545 if (targets != null && j >= 0 & j < targets.length) {
3546 Object o = targets[j];
3547 if (o instanceof Accessible) {
3548 return ((Accessible) o).getAccessibleContext();
3549 }
3550 }
3551 }
3552 }
3553 }
3554 return null;
3555 }
3556 }, ac);
3557 }
3558
3559 // ========= AccessibleHypertext =========
3560
3561 private Map<AccessibleHypertext, AccessibleContext> hyperTextContextMap = new WeakHashMap<>();
3562 private Map<AccessibleHyperlink, AccessibleContext> hyperLinkContextMap = new WeakHashMap<>();
3563
3564 /*
3565 * Returns the AccessibleHypertext
3566 */
3567 private AccessibleHypertext getAccessibleHypertext(final AccessibleContext ac) {
3568 debugString("[INFO]: getAccessibleHyperlink");
3569 if (ac==null)
3570 return null;
3571 AccessibleHypertext hypertext = InvocationUtils.invokeAndWait(new Callable<AccessibleHypertext>() {
3572 @Override
3573 public AccessibleHypertext call() throws Exception {
3574 AccessibleText at = ac.getAccessibleText();
3575 if (!(at instanceof AccessibleHypertext)) {
3576 return null;
|
1440 }
1441 }, ac);
1442 if (stateSet != null) {
1443 String s = "";
1444 AccessibleState[] states = stateSet.toArray();
1445 if (states != null && states.length > 0) {
1446 s = states[0].toDisplayString(Locale.US);
1447 for (int i = 1; i < states.length; i++) {
1448 s = s + "," + states[i].toDisplayString(Locale.US);
1449 }
1450 }
1451 references.increment(s);
1452 debugString("[INFO]: Returning AccessibleStateSet en_US from Context: " + s);
1453 return s;
1454 }
1455 }
1456 debugString("[ERROR]: getAccessibleStatesStringFromContext; ac = null");
1457 return null;
1458 }
1459
1460 private int get_nonVisibleChildrenCountBeforeIndex(AccessibleContext parentAC, int beforeIndex) {
1461 if (parentAC == null || beforeIndex < 0 || beforeIndex >= parentAC.getAccessibleChildrenCount()) {
1462 return 0;
1463 } else {
1464 int childrenCount = parentAC.getAccessibleChildrenCount();
1465 int nonVisibleChildrenCount = 0;
1466 if (beforeIndex >= childrenCount) {
1467 beforeIndex = childrenCount - 1;
1468 }
1469 for (int i = 0; i <= beforeIndex; i++) {
1470 if (!parentAC.getAccessibleChild(i).getAccessibleContext().getAccessibleStateSet().contains(AccessibleState.SHOWING)) {
1471 nonVisibleChildrenCount++;
1472 }
1473 }
1474 return nonVisibleChildrenCount;
1475 }
1476 }
1477
1478 /**
1479 * returns the AccessibleParent from an AccessibleContext
1480 */
1481 private AccessibleContext getAccessibleParentFromContext(final AccessibleContext ac) {
1482 if (ac==null)
1483 return null;
1484 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
1485 @Override
1486 public AccessibleContext call() throws Exception {
1487 Accessible a = ac.getAccessibleParent();
1488 if (a != null) {
1489 AccessibleContext apc = a.getAccessibleContext();
1490 if (apc != null) {
1491 return apc;
1492 }
1493 }
1494 return null;
1495 }
1496 }, ac);
1497 }
1498
1499 /**
1500 * returns the AccessibleIndexInParent from an AccessibleContext
1501 */
1502 private int getAccessibleIndexInParentFromContext(final AccessibleContext ac) {
1503 if (ac==null)
1504 return -1;
1505 return InvocationUtils.invokeAndWait(new Callable<Integer>() {
1506 @Override
1507 public Integer call() throws Exception {
1508 int indexInParent = ac.getAccessibleIndexInParent();
1509 Accessible parent = ac.getAccessibleParent();
1510 if (parent != null) {
1511 indexInParent -= get_nonVisibleChildrenCountBeforeIndex(parent.getAccessibleContext(), indexInParent);
1512 }
1513 return indexInParent;
1514 }
1515 }, ac);
1516 }
1517
1518 /**
1519 * returns the AccessibleChild count from an AccessibleContext
1520 */
1521 private int getAccessibleChildrenCountFromContext(final AccessibleContext ac) {
1522 if (ac==null)
1523 return -1;
1524 return InvocationUtils.invokeAndWait(new Callable<Integer>() {
1525 @Override
1526 public Integer call() throws Exception {
1527 int childrenCount = ac.getAccessibleChildrenCount();
1528 return childrenCount - get_nonVisibleChildrenCountBeforeIndex(ac, childrenCount);
1529 }
1530 }, ac);
1531 }
1532
1533 /**
1534 * returns the AccessibleChild Context from an AccessibleContext
1535 */
1536 private AccessibleContext getAccessibleChildFromContext(final AccessibleContext ac, final int index) {
1537
1538 if (ac == null) {
1539 return null;
1540 }
1541
1542 final JTable table = InvocationUtils.invokeAndWait(new Callable<JTable>() {
1543 @Override
1544 public JTable call() throws Exception {
1545 // work-around for AccessibleJTable.getCurrentAccessibleContext returning
1546 // wrong renderer component when cell contains more than one component
1547 Accessible parent = ac.getAccessibleParent();
1548 if (parent != null) {
1549 int indexInParent = ac.getAccessibleIndexInParent();
1550 Accessible child =
1551 parent.getAccessibleContext().getAccessibleChild(indexInParent);
1552 if (child instanceof JTable) {
1553 return (JTable) child;
1554 }
1555 }
1556 return null;
1557 }
1558 }, ac);
1559
1560 if (table == null) {
1561 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
1562 @Override
1563 public AccessibleContext call() throws Exception {
1564 int visibleIndex = index + get_nonVisibleChildrenCountBeforeIndex(ac, index);
1565 Accessible a = ac.getAccessibleChild(visibleIndex);
1566 if (a != null) {
1567 return a.getAccessibleContext();
1568 }
1569 return null;
1570 }
1571 }, ac);
1572 }
1573
1574 final AccessibleTable at = getAccessibleTableFromContext(ac);
1575
1576 final int row = getAccessibleTableRow(at, index);
1577 final int column = getAccessibleTableColumn(at, index);
1578
1579 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
1580 @Override
1581 public AccessibleContext call() throws Exception {
1582 TableCellRenderer renderer = table.getCellRenderer(row, column);
1583 if (renderer == null) {
1584 Class<?> columnClass = table.getColumnClass(column);
1585 renderer = table.getDefaultRenderer(columnClass);
3525 }
3526 return null;
3527 }
3528 }, ac);
3529 }
3530
3531 /*
3532 * returns the number of targets in a relation in the AccessibleContext's
3533 * AccessibleRelationSet
3534 */
3535 private int getAccessibleRelationTargetCount(final AccessibleContext ac, final int i) {
3536 return InvocationUtils.invokeAndWait(new Callable<Integer>() {
3537 @Override
3538 public Integer call() throws Exception {
3539 if (ac != null) {
3540 AccessibleRelationSet ars = ac.getAccessibleRelationSet();
3541 if (ars != null) {
3542 AccessibleRelation[] relations = ars.toArray();
3543 if (relations != null && i >= 0 && i < relations.length) {
3544 Object[] targets = relations[i].getTarget();
3545 if (targets != null) {
3546 int nonVisibleTargets = 0;
3547 for (Object target : targets) {
3548 if (target instanceof Accessible) {
3549 AccessibleContext ac = ((Accessible) target).getAccessibleContext();
3550 if (!ac.getAccessibleStateSet().contains(AccessibleState.SHOWING)) {
3551 nonVisibleTargets++;
3552 }
3553 }
3554 }
3555 return targets.length - nonVisibleTargets;
3556 }
3557 }
3558 }
3559 }
3560 return -1;
3561 }
3562 }, ac);
3563 }
3564
3565 /*
3566 * returns the jth target in the ith relation in the AccessibleContext's
3567 * AccessibleRelationSet
3568 */
3569 private AccessibleContext getAccessibleRelationTarget(final AccessibleContext ac,
3570 final int i, final int j) {
3571 debugString("[INFO]: ***** getAccessibleRelationTarget: get target[" + j + "] from relation[" + i + "] ");
3572 return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
3573 @Override
3574 public AccessibleContext call() throws Exception {
3575 if (ac != null) {
3576 AccessibleRelationSet ars = ac.getAccessibleRelationSet();
3577 if (ars != null) {
3578 AccessibleRelation[] relations = ars.toArray();
3579 if (relations != null && i >= 0 && i < relations.length) {
3580 Object[] targets = relations[i].getTarget();
3581 if (targets != null && j >= 0 & j < targets.length) {
3582 Object o = targets[j + get_NonVisibleTargetCountBeforeIndex(targets, j)];
3583 if (o instanceof Accessible) {
3584 return ((Accessible) o).getAccessibleContext();
3585 }
3586 }
3587 }
3588 }
3589 }
3590 return null;
3591 }
3592 }, ac);
3593 }
3594
3595 private int get_NonVisibleTargetCountBeforeIndex(Object[] targets, int indexBefore) {
3596 if (indexBefore == 0 || indexBefore >= targets.length) {
3597 return 0;
3598 }
3599 int nonVisibleTargetsCount = 0;
3600 for (int i = 0 ; i <= indexBefore; i++) {
3601 if (targets[i] instanceof Accessible) {
3602 AccessibleContext ac = ((Accessible) targets[i]).getAccessibleContext();
3603 if (ac != null && !ac.getAccessibleStateSet().contains(AccessibleState.SHOWING)) {
3604 nonVisibleTargetsCount++;
3605 }
3606 }
3607 }
3608 return nonVisibleTargetsCount;
3609 }
3610
3611 // ========= AccessibleHypertext =========
3612
3613 private Map<AccessibleHypertext, AccessibleContext> hyperTextContextMap = new WeakHashMap<>();
3614 private Map<AccessibleHyperlink, AccessibleContext> hyperLinkContextMap = new WeakHashMap<>();
3615
3616 /*
3617 * Returns the AccessibleHypertext
3618 */
3619 private AccessibleHypertext getAccessibleHypertext(final AccessibleContext ac) {
3620 debugString("[INFO]: getAccessibleHyperlink");
3621 if (ac==null)
3622 return null;
3623 AccessibleHypertext hypertext = InvocationUtils.invokeAndWait(new Callable<AccessibleHypertext>() {
3624 @Override
3625 public AccessibleHypertext call() throws Exception {
3626 AccessibleText at = ac.getAccessibleText();
3627 if (!(at instanceof AccessibleHypertext)) {
3628 return null;
|