4510 private boolean _foundVisibleChild;
4511
4512 private int getVisibleChildrenCount(AccessibleContext ac) {
4513 debugString("getVisibleChildrenCount");
4514 if (ac == null) {
4515 return -1;
4516 }
4517 _visibleChildrenCount = 0;
4518 _getVisibleChildrenCount(ac);
4519 debugString(" _visibleChildrenCount = "+_visibleChildrenCount);
4520 return _visibleChildrenCount;
4521 }
4522
4523 /*
4524 * Recursively descends AccessibleContext and gets the number
4525 * of visible children
4526 */
4527 private void _getVisibleChildrenCount(final AccessibleContext ac) {
4528 if (ac == null)
4529 return;
4530 int numChildren = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4531 @Override
4532 public Integer call() throws Exception {
4533 return ac.getAccessibleChildrenCount();
4534 }
4535 }, ac);
4536 for (int i = 0; i < numChildren; i++) {
4537 final int idx = i;
4538 final AccessibleContext ac2 = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
4539 @Override
4540 public AccessibleContext call() throws Exception {
4541 Accessible a = ac.getAccessibleChild(idx);
4542 if (a != null)
4543 return a.getAccessibleContext();
4544 else
4545 return null;
4546 }
4547 }, ac);
4548 if ( ac2 == null ||
4549 (!InvocationUtils.invokeAndWait(new Callable<Boolean>() {
4551 public Boolean call() throws Exception {
4552 return ac2.getAccessibleStateSet().contains(AccessibleState.SHOWING);
4553 }
4554 }, ac))
4555 ) {
4556 continue;
4557 }
4558 _visibleChildrenCount++;
4559
4560 if (InvocationUtils.invokeAndWait(new Callable<Integer>() {
4561 @Override
4562 public Integer call() throws Exception {
4563 return ac2.getAccessibleChildrenCount();
4564 }
4565 }, ac) > 0 ) {
4566 _getVisibleChildrenCount(ac2);
4567 }
4568 }
4569 }
4570
4571 /**
4572 * Gets the visible child of an AccessibleContext at the
4573 * specified index
4574 *
4575 * Bug ID 4944762- getVisibleChildren for list-like components needed
4576 */
4577 private AccessibleContext getVisibleChild(AccessibleContext ac, int index) {
4578 debugString("getVisibleChild: index = "+index);
4579 if (ac == null) {
4580 return null;
4581 }
4582 _visibleChild = null;
4583 _currentVisibleIndex = 0;
4584 _foundVisibleChild = false;
4585 _getVisibleChild(ac, index);
4586
4587 if (_visibleChild != null) {
4588 debugString( " getVisibleChild: found child = " +
4589 InvocationUtils.invokeAndWait(new Callable<String>() {
4590 @Override
4591 public String call() throws Exception {
4592 return AccessBridge.this._visibleChild.getAccessibleName();
4593 }
4594 }, ac) );
4595 }
4596 return _visibleChild;
4597 }
4598
4599 /*
4600 * Recursively searchs AccessibleContext and finds the visible component
4601 * at the specified index
4602 */
4603 private void _getVisibleChild(final AccessibleContext ac, final int index) {
4604 if (_visibleChild != null) {
4605 return;
4606 }
4607
4608 int numChildren = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4609 @Override
4610 public Integer call() throws Exception {
4611 return ac.getAccessibleChildrenCount();
4612 }
4613 }, ac);
4614 for (int i = 0; i < numChildren; i++) {
4615 final int idx=i;
4616 final AccessibleContext ac2=InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
4617 @Override
4618 public AccessibleContext call() throws Exception {
4619 Accessible a = ac.getAccessibleChild(idx);
4620 if (a == null)
4621 return null;
4622 else
4623 return a.getAccessibleContext();
4624 }
4625 }, ac);
4626 if (ac2 == null ||
4627 (!InvocationUtils.invokeAndWait(new Callable<Boolean>() {
6996 } else {
6997 tree.expandPath(path);
6998 }
6999 return true;
7000 } else if (ac != null) {
7001 AccessibleAction aa = ac.getAccessibleAction();
7002 if (aa != null) {
7003 return aa.doAccessibleAction(i - 1);
7004 }
7005 }
7006 return false;
7007 }
7008
7009 } // inner class AccessibleJTreeNode
7010
7011 /**
7012 * A helper class to perform {@code Callable} objects on the event dispatch thread appropriate
7013 * for the provided {@code AccessibleContext}.
7014 */
7015 private static class InvocationUtils {
7016
7017 /**
7018 * Invokes a {@code Callable} in the {@code AppContext} of the given {@code Accessible}
7019 * and waits for it to finish blocking the caller thread.
7020 *
7021 * @param callable the {@code Callable} to invoke
7022 * @param accessible the {@code Accessible} which would be used to find the right context
7023 * for the task execution
7024 * @param <T> type parameter for the result value
7025 *
7026 * @return the result of the {@code Callable} execution
7027 */
7028 public static <T> T invokeAndWait(final Callable<T> callable,
7029 final Accessible accessible) {
7030 if (accessible instanceof Component) {
7031 return invokeAndWait(callable, (Component)accessible);
7032 }
7033 if (accessible instanceof AccessibleContext) {
7034 // This case also covers the Translator
7035 return invokeAndWait(callable, (AccessibleContext)accessible);
|
4510 private boolean _foundVisibleChild;
4511
4512 private int getVisibleChildrenCount(AccessibleContext ac) {
4513 debugString("getVisibleChildrenCount");
4514 if (ac == null) {
4515 return -1;
4516 }
4517 _visibleChildrenCount = 0;
4518 _getVisibleChildrenCount(ac);
4519 debugString(" _visibleChildrenCount = "+_visibleChildrenCount);
4520 return _visibleChildrenCount;
4521 }
4522
4523 /*
4524 * Recursively descends AccessibleContext and gets the number
4525 * of visible children
4526 */
4527 private void _getVisibleChildrenCount(final AccessibleContext ac) {
4528 if (ac == null)
4529 return;
4530 if(ac instanceof AccessibleExtendedTable) {
4531 _getVisibleChildrenCount((AccessibleExtendedTable)ac);
4532 return;
4533 }
4534 int numChildren = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4535 @Override
4536 public Integer call() throws Exception {
4537 return ac.getAccessibleChildrenCount();
4538 }
4539 }, ac);
4540 for (int i = 0; i < numChildren; i++) {
4541 final int idx = i;
4542 final AccessibleContext ac2 = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
4543 @Override
4544 public AccessibleContext call() throws Exception {
4545 Accessible a = ac.getAccessibleChild(idx);
4546 if (a != null)
4547 return a.getAccessibleContext();
4548 else
4549 return null;
4550 }
4551 }, ac);
4552 if ( ac2 == null ||
4553 (!InvocationUtils.invokeAndWait(new Callable<Boolean>() {
4555 public Boolean call() throws Exception {
4556 return ac2.getAccessibleStateSet().contains(AccessibleState.SHOWING);
4557 }
4558 }, ac))
4559 ) {
4560 continue;
4561 }
4562 _visibleChildrenCount++;
4563
4564 if (InvocationUtils.invokeAndWait(new Callable<Integer>() {
4565 @Override
4566 public Integer call() throws Exception {
4567 return ac2.getAccessibleChildrenCount();
4568 }
4569 }, ac) > 0 ) {
4570 _getVisibleChildrenCount(ac2);
4571 }
4572 }
4573 }
4574
4575 /*
4576 * Recursively descends AccessibleContext and gets the number
4577 * of visible children. Stops search if get to invisible part of table.
4578 */
4579 private void _getVisibleChildrenCount(final AccessibleExtendedTable acTable) {
4580 if (acTable == null)
4581 return;
4582 int lastVisibleRow = -1;
4583 int lastVisibleColumn = -1;
4584 boolean foundVisible = false;
4585 int rowCount = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4586 @Override
4587 public Integer call() throws Exception {
4588 return acTable.getAccessibleRowCount();
4589 }
4590 }, acTable);
4591 int columnCount = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4592 @Override
4593 public Integer call() throws Exception {
4594 return acTable.getAccessibleColumnCount();
4595 }
4596 }, acTable);
4597 for (int rowIdx = 0; rowIdx < rowCount; rowIdx++) {
4598 for (int columnIdx = 0; columnIdx < columnCount; columnIdx++) {
4599 if (lastVisibleRow != -1 && rowIdx > lastVisibleRow) {
4600 continue;
4601 }
4602 if (lastVisibleColumn != -1 && columnIdx > lastVisibleColumn) {
4603 continue;
4604 }
4605 int finalRowIdx = rowIdx;
4606 int finalColumnIdx = columnIdx;
4607 final AccessibleContext ac2 = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
4608 @Override
4609 public AccessibleContext call() throws Exception {
4610 Accessible a = acTable.getAccessibleAt(finalRowIdx, finalColumnIdx);
4611 if (a == null)
4612 return null;
4613 else
4614 return a.getAccessibleContext();
4615 }
4616 }, acTable);
4617 if (ac2 == null ||
4618 (!InvocationUtils.invokeAndWait(new Callable<Boolean>() {
4619 @Override
4620 public Boolean call() throws Exception {
4621 return ac2.getAccessibleStateSet().contains(AccessibleState.SHOWING);
4622 }
4623 }, acTable))
4624 ) {
4625 if (foundVisible) {
4626 if (columnIdx != 0 && lastVisibleColumn == -1) {
4627 //the same row, so we found the last visible column
4628 lastVisibleColumn = columnIdx - 1;
4629 } else if (columnIdx == 0 && lastVisibleRow == -1) {
4630 lastVisibleRow = rowIdx - 1;
4631 }
4632 }
4633 continue;
4634 }
4635
4636 foundVisible = true;
4637
4638 _visibleChildrenCount++;
4639
4640 if (InvocationUtils.invokeAndWait(new Callable<Integer>() {
4641 @Override
4642 public Integer call() throws Exception {
4643 return ac2.getAccessibleChildrenCount();
4644 }
4645 }, acTable) > 0) {
4646 _getVisibleChildrenCount(ac2);
4647 }
4648 }
4649 }
4650 }
4651
4652 /**
4653 * Gets the visible child of an AccessibleContext at the
4654 * specified index
4655 *
4656 * Bug ID 4944762- getVisibleChildren for list-like components needed
4657 */
4658 private AccessibleContext getVisibleChild(AccessibleContext ac, int index) {
4659 debugString("getVisibleChild: index = "+index);
4660 if (ac == null) {
4661 return null;
4662 }
4663 _visibleChild = null;
4664 _currentVisibleIndex = 0;
4665 _foundVisibleChild = false;
4666 _getVisibleChild(ac, index);
4667
4668 if (_visibleChild != null) {
4669 debugString( " getVisibleChild: found child = " +
4670 InvocationUtils.invokeAndWait(new Callable<String>() {
4671 @Override
4672 public String call() throws Exception {
4673 return AccessBridge.this._visibleChild.getAccessibleName();
4674 }
4675 }, ac) );
4676 }
4677 return _visibleChild;
4678 }
4679
4680 private void _getVisibleChild(final AccessibleExtendedTable acTable, final int index) {
4681 if (_visibleChild != null) {
4682 return;
4683 }
4684 int lastVisibleRow = -1;
4685 int lastVisibleColumn = -1;
4686 boolean foundVisible = false;
4687 int rowCount = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4688 @Override
4689 public Integer call() throws Exception {
4690 return acTable.getAccessibleRowCount();
4691 }
4692 }, acTable);
4693 int columnCount = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4694 @Override
4695 public Integer call() throws Exception {
4696 return acTable.getAccessibleColumnCount();
4697 }
4698 }, acTable);
4699 for (int rowIdx = 0; rowIdx < rowCount; rowIdx++) {
4700 for (int columnIdx = 0; columnIdx < columnCount; columnIdx++) {
4701 if (lastVisibleRow != -1 && rowIdx > lastVisibleRow) {
4702 continue;
4703 }
4704 if (lastVisibleColumn != -1 && columnIdx > lastVisibleColumn) {
4705 continue;
4706 }
4707 int finalRowIdx = rowIdx;
4708 int finalColumnIdx = columnIdx;
4709 final AccessibleContext ac2 = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
4710 @Override
4711 public AccessibleContext call() throws Exception {
4712 Accessible a = acTable.getAccessibleAt(finalRowIdx, finalColumnIdx);
4713 if (a == null)
4714 return null;
4715 else
4716 return a.getAccessibleContext();
4717 }
4718 }, acTable);
4719 if (ac2 == null ||
4720 (!InvocationUtils.invokeAndWait(new Callable<Boolean>() {
4721 @Override
4722 public Boolean call() throws Exception {
4723 return ac2.getAccessibleStateSet().contains(AccessibleState.SHOWING);
4724 }
4725 }, acTable))) {
4726 if (foundVisible) {
4727 if (columnIdx != 0 && lastVisibleColumn == -1) {
4728 //the same row, so we found the last visible column
4729 lastVisibleColumn = columnIdx - 1;
4730 } else if (columnIdx == 0 && lastVisibleRow == -1) {
4731 lastVisibleRow = rowIdx - 1;
4732 }
4733 }
4734 continue;
4735 }
4736 foundVisible = true;
4737
4738 if (!_foundVisibleChild && _currentVisibleIndex == index) {
4739 _visibleChild = ac2;
4740 _foundVisibleChild = true;
4741 return;
4742 }
4743 _currentVisibleIndex++;
4744
4745 if (InvocationUtils.invokeAndWait(new Callable<Integer>() {
4746 @Override
4747 public Integer call() throws Exception {
4748 return ac2.getAccessibleChildrenCount();
4749 }
4750 }, acTable) > 0) {
4751 _getVisibleChild(ac2, index);
4752 }
4753 }
4754 }
4755 }
4756 /*
4757 * Recursively searchs AccessibleContext and finds the visible component
4758 * at the specified index
4759 */
4760 private void _getVisibleChild(final AccessibleContext ac, final int index) {
4761 if (_visibleChild != null) {
4762 return;
4763 }
4764 if(ac instanceof AccessibleExtendedTable) {
4765 _getVisibleChildrenCount((AccessibleExtendedTable)ac);
4766 return;
4767 }
4768 int numChildren = InvocationUtils.invokeAndWait(new Callable<Integer>() {
4769 @Override
4770 public Integer call() throws Exception {
4771 return ac.getAccessibleChildrenCount();
4772 }
4773 }, ac);
4774 for (int i = 0; i < numChildren; i++) {
4775 final int idx=i;
4776 final AccessibleContext ac2=InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {
4777 @Override
4778 public AccessibleContext call() throws Exception {
4779 Accessible a = ac.getAccessibleChild(idx);
4780 if (a == null)
4781 return null;
4782 else
4783 return a.getAccessibleContext();
4784 }
4785 }, ac);
4786 if (ac2 == null ||
4787 (!InvocationUtils.invokeAndWait(new Callable<Boolean>() {
7156 } else {
7157 tree.expandPath(path);
7158 }
7159 return true;
7160 } else if (ac != null) {
7161 AccessibleAction aa = ac.getAccessibleAction();
7162 if (aa != null) {
7163 return aa.doAccessibleAction(i - 1);
7164 }
7165 }
7166 return false;
7167 }
7168
7169 } // inner class AccessibleJTreeNode
7170
7171 /**
7172 * A helper class to perform {@code Callable} objects on the event dispatch thread appropriate
7173 * for the provided {@code AccessibleContext}.
7174 */
7175 private static class InvocationUtils {
7176
7177 /**
7178 * Invokes a {@code Callable} in the {@code AppContext} of the given {@code Accessible}
7179 * and waits for it to finish blocking the caller thread.
7180 *
7181 * @param callable the {@code Callable} to invoke
7182 * @param accessibleTable the {@code AccessibleExtendedTable} which would be used to find the right context
7183 * for the task execution
7184 * @param <T> type parameter for the result value
7185 *
7186 * @return the result of the {@code Callable} execution
7187 */
7188 public static <T> T invokeAndWait(final Callable<T> callable,
7189 final AccessibleExtendedTable accessibleTable) {
7190 if (accessibleTable instanceof AccessibleContext) {
7191 return invokeAndWait(callable, (AccessibleContext)accessibleTable);
7192 }
7193 throw new RuntimeException("Unmapped AccessibleContext used to dispatch event: " + accessibleTable);
7194 }
7195
7196 /**
7197 * Invokes a {@code Callable} in the {@code AppContext} of the given {@code Accessible}
7198 * and waits for it to finish blocking the caller thread.
7199 *
7200 * @param callable the {@code Callable} to invoke
7201 * @param accessible the {@code Accessible} which would be used to find the right context
7202 * for the task execution
7203 * @param <T> type parameter for the result value
7204 *
7205 * @return the result of the {@code Callable} execution
7206 */
7207 public static <T> T invokeAndWait(final Callable<T> callable,
7208 final Accessible accessible) {
7209 if (accessible instanceof Component) {
7210 return invokeAndWait(callable, (Component)accessible);
7211 }
7212 if (accessible instanceof AccessibleContext) {
7213 // This case also covers the Translator
7214 return invokeAndWait(callable, (AccessibleContext)accessible);
|