sd/source/ui/accessibility/AccessibleTreeNode.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: AccessibleTreeNode.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "AccessibleTreeNode.hxx"
  35
  36 #include "taskpane/TaskPaneTreeNode.hxx"
  37 #include "taskpane/ControlContainer.hxx"
  38
  39 #include "sdresid.hxx"
  40 #include "accessibility.hrc"
  41 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  42 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  43 #include <comphelper/accessibleeventnotifier.hxx>
  44
  45 #include <vcl/svapp.hxx>
  46 #include <vcl/window.hxx>
  47 #include <svtools/colorcfg.hxx>
  48
  49 using ::rtl::OUString;
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::uno;
  52 using namespace ::com::sun::star::accessibility;
  53 using namespace ::sd::toolpanel;
  54
  55 namespace accessibility {
  56
  57
  58
  59 //===== AccessibleTreeNode =============================================
  60
  61 AccessibleTreeNode::AccessibleTreeNode(
  62     ::sd::toolpanel::TreeNode& rNode,
  63     const OUString& rsName,
  64     const OUString& rsDescription,
  65     sal_Int16 eRole)
  66     : AccessibleTreeNodeBase(MutexOwner::maMutex),
  67       mxParent(NULL),
  68       mrTreeNode(rNode),
  69       mrStateSet(new ::utl::AccessibleStateSetHelper()),
  70       msName(rsName),
  71       msDescription(rsDescription),
  72       meRole(eRole),
  73       mnClientId(0)
  74 {
  75     ::Window* pWindow = mrTreeNode.GetWindow();
  76     if (pWindow != NULL)
  77     {
  78         ::Window* pParentWindow = pWindow->GetAccessibleParentWindow();
  79         if (pParentWindow != NULL && pParentWindow != pWindow)
  80             mxParent = pParentWindow->GetAccessible();
  81     }
  82     CommonConstructor();
  83 }
  84
  85
  86
  87
  88 AccessibleTreeNode::AccessibleTreeNode(
  89     const Reference<XAccessible>& rxParent,
  90     ::sd::toolpanel::TreeNode& rNode,
  91     const OUString& rsName,
  92     const OUString& rsDescription,
  93     const sal_Int16 eRole)
  94     : AccessibleTreeNodeBase(MutexOwner::maMutex),
  95       mxParent(rxParent),
  96       mrTreeNode(rNode),
  97       mrStateSet(new ::utl::AccessibleStateSetHelper()),
  98       msName(rsName),
  99       msDescription(rsDescription),
 100       meRole(eRole),
 101       mnClientId(0)
 102 {
 103     CommonConstructor();
 104 }
 105
 106
 107
 108
 109 void AccessibleTreeNode::CommonConstructor (void)
 110 {
 111     UpdateStateSet();
 112
 113     Link aStateChangeLink (LINK(this,AccessibleTreeNode,StateChangeListener));
 114     mrTreeNode.AddStateChangeListener(aStateChangeLink);
 115
 116     if (mrTreeNode.GetWindow() != NULL)
 117     {
 118         Link aWindowEventLink (LINK(this,AccessibleTreeNode,WindowEventListener));
 119         mrTreeNode.GetWindow()->AddEventListener(aWindowEventLink);
 120     }
 121 }
 122
 123
 124
 125
 126 AccessibleTreeNode::~AccessibleTreeNode (void)
 127 {
 128     OSL_ASSERT(IsDisposed());
 129 }
 130
 131
 132
 133
 134 void AccessibleTreeNode::FireAccessibleEvent (
 135     short nEventId,
 136     const uno::Any& rOldValue,
 137     const uno::Any& rNewValue )
 138 {
 139     if (mnClientId != 0)
 140     {
 141         AccessibleEventObject aEventObject;
 142
 143         aEventObject.Source = Reference<XWeak>(this);
 144         aEventObject.EventId = nEventId;
 145         aEventObject.NewValue = rNewValue;
 146         aEventObject.OldValue = rOldValue;
 147
 148         comphelper::AccessibleEventNotifier::addEvent (mnClientId, aEventObject);
 149     }
 150 }
 151
 152
 153
 154
 155 void SAL_CALL AccessibleTreeNode::disposing (void)
 156 {
 157     // We are still listening to the tree node and its window.  Both
 158     // probably are by now more or less dead and we must not call them to
 159     // unregister.
 160
 161     comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( mnClientId, *this );
 162     mnClientId = 0;
 163 }
 164
 165
 166
 167
 168 //=====  XAccessible  =========================================================
 169
 170 Reference<XAccessibleContext > SAL_CALL
 171     AccessibleTreeNode::getAccessibleContext (void)
 172     throw (uno::RuntimeException)
 173 {
 174     ThrowIfDisposed ();
 175     return this;
 176 }
 177
 178
 179
 180
 181 //=====  XAccessibleContext  ==================================================
 182
 183 sal_Int32 SAL_CALL AccessibleTreeNode::getAccessibleChildCount (void)
 184     throw (RuntimeException)
 185 {
 186     ThrowIfDisposed();
 187     const vos::OGuard aSolarGuard (Application::GetSolarMutex());
 188     return mrTreeNode.GetControlContainer().GetControlCount();
 189 }
 190
 191
 192
 193
 194 Reference<XAccessible > SAL_CALL
 195     AccessibleTreeNode::getAccessibleChild (sal_Int32 nIndex)
 196     throw (lang::IndexOutOfBoundsException, RuntimeException)
 197 {
 198     ThrowIfDisposed();
 199     const vos::OGuard aSolarGuard (Application::GetSolarMutex());
 200
 201     if (nIndex<0 || (sal_uInt32)nIndex>=mrTreeNode.GetControlContainer().GetControlCount())
 202         throw lang::IndexOutOfBoundsException();
 203
 204     Reference<XAccessible> xChild;
 205
 206     ::sd::toolpanel::TreeNode* pNode = mrTreeNode.GetControlContainer().GetControl(nIndex);
 207     if (pNode != NULL)
 208         xChild = pNode->GetAccessibleObject();
 209
 210     return xChild;
 211 }
 212
 213
 214
 215
 216 Reference<XAccessible > SAL_CALL AccessibleTreeNode::getAccessibleParent (void)
 217     throw (uno::RuntimeException)
 218 {
 219     ThrowIfDisposed();
 220     const vos::OGuard aSolarGuard (Application::GetSolarMutex());
 221     return mxParent;
 222 }
 223
 224
 225
 226
 227 sal_Int32 SAL_CALL AccessibleTreeNode::getAccessibleIndexInParent (void)
 228     throw (uno::RuntimeException)
 229 {
 230     OSL_ASSERT(getAccessibleParent().is());
 231     ThrowIfDisposed();
 232     const vos::OGuard aSolarGuard (Application::GetSolarMutex());
 233     sal_Int32 nIndexInParent(-1);
 234
 235
 236     Reference<XAccessibleContext> xParentContext (getAccessibleParent()->getAccessibleContext());
 237     if (xParentContext.is())
 238     {
 239         sal_Int32 nChildCount (xParentContext->getAccessibleChildCount());
 240         for (sal_Int32 i=0; i<nChildCount; ++i)
 241             if (xParentContext->getAccessibleChild(i).get()
 242                     == static_cast<XAccessible*>(this))
 243             {
 244                 nIndexInParent = i;
 245                 break;
 246             }
 247     }
 248
 249     return nIndexInParent;
 250 }
 251
 252
 253
 254
 255 sal_Int16 SAL_CALL AccessibleTreeNode::getAccessibleRole (void)
 256     throw (uno::RuntimeException)
 257 {
 258     ThrowIfDisposed();
 259     return meRole;
 260 }
 261
 262
 263
 264
 265 ::rtl::OUString SAL_CALL AccessibleTreeNode::getAccessibleDescription (void)
 266     throw (uno::RuntimeException)
 267 {
 268     ThrowIfDisposed();
 269     return msDescription;
 270 }
 271
 272
 273
 274
 275 ::rtl::OUString SAL_CALL AccessibleTreeNode::getAccessibleName (void)
 276     throw (uno::RuntimeException)
 277 {
 278     ThrowIfDisposed();
 279     return msName;
 280 }
 281
 282
 283
 284
 285 Reference<XAccessibleRelationSet> SAL_CALL
 286     AccessibleTreeNode::getAccessibleRelationSet (void)
 287     throw (uno::RuntimeException)
 288 {
 289     ThrowIfDisposed();
 290     return Reference<XAccessibleRelationSet>();
 291 }
 292
 293
 294
 295
 296 Reference<XAccessibleStateSet > SAL_CALL
 297     AccessibleTreeNode::getAccessibleStateSet (void)
 298     throw (uno::RuntimeException)
 299 {
 300     ThrowIfDisposed();
 301     const vos::OGuard aSolarGuard (Application::GetSolarMutex());
 302     return mrStateSet.get();
 303 }
 304
 305
 306
 307
 308 void AccessibleTreeNode::UpdateStateSet (void)
 309 {
 310     if (mrTreeNode.IsExpandable())
 311     {
 312         UpdateState(AccessibleStateType::EXPANDABLE, true);
 313         UpdateState(AccessibleStateType::EXPANDED, mrTreeNode.IsExpanded());
 314     }
 315
 316     UpdateState(AccessibleStateType::FOCUSABLE, true);
 317
 318     ::Window* pWindow = mrTreeNode.GetWindow();
 319     if (pWindow != NULL)
 320     {
 321         UpdateState(AccessibleStateType::ENABLED, pWindow->IsEnabled());
 322         UpdateState(AccessibleStateType::FOCUSED, pWindow->HasFocus());
 323         UpdateState(AccessibleStateType::VISIBLE, pWindow->IsVisible());
 324         UpdateState(AccessibleStateType::SHOWING, pWindow->IsReallyVisible());
 325     }
 326 }
 327
 328
 329
 330
 331 void AccessibleTreeNode::UpdateState(
 332     sal_Int16 aState,
 333     bool bValue)
 334 {
 335     if ((mrStateSet->contains(aState)!=sal_False) != bValue)
 336     {
 337         if (bValue)
 338         {
 339             mrStateSet->AddState(aState);
 340             FireAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(),Any(aState));
 341         }
 342         else
 343         {
 344             mrStateSet->RemoveState(aState);
 345             FireAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(aState),Any());
 346         }
 347     }
 348 }
 349
 350
 351
 352
 353 lang::Locale SAL_CALL AccessibleTreeNode::getLocale (void)
 354     throw (IllegalAccessibleComponentStateException,
 355         RuntimeException)
 356 {
 357     ThrowIfDisposed ();
 358     Reference<XAccessibleContext> xParentContext;
 359     Reference<XAccessible> xParent (getAccessibleParent());
 360     if (xParent.is())
 361         xParentContext = xParent->getAccessibleContext();
 362
 363     if (xParentContext.is())
 364         return xParentContext->getLocale();
 365     else
 366         // Strange, no parent!  Anyway, return the default locale.
 367         return Application::GetSettings().GetLocale();
 368 }
 369
 370
 371
 372
 373 void SAL_CALL AccessibleTreeNode::addEventListener(
 374     const Reference<XAccessibleEventListener >& rxListener)
 375     throw (RuntimeException)
 376 {
 377     if (rxListener.is())
 378     {
 379         const osl::MutexGuard aGuard(maMutex);
 380
 381         if (IsDisposed())
 382         {
 383             uno::Reference<uno::XInterface> x ((lang::XComponent *)this, uno::UNO_QUERY);
 384             rxListener->disposing (lang::EventObject (x));
 385         }
 386         else
 387         {
 388             if ( ! mnClientId)
 389                 mnClientId = comphelper::AccessibleEventNotifier::registerClient();
 390             comphelper::AccessibleEventNotifier::addEventListener(mnClientId, rxListener);
 391         }
 392     }
 393 }
 394
 395
 396
 397
 398 void SAL_CALL AccessibleTreeNode::removeEventListener(
 399     const Reference<XAccessibleEventListener >& rxListener)
 400     throw (RuntimeException)
 401 {
 402     ThrowIfDisposed();
 403     if (rxListener.is())
 404     {
 405         const osl::MutexGuard aGuard(maMutex);
 406
 407         sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( mnClientId, rxListener );
 408         if ( !nListenerCount )
 409         {
 410             // no listeners anymore
 411             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 412             // and at least to us not firing any events anymore, in case somebody calls
 413             // NotifyAccessibleEvent, again
 414             comphelper::AccessibleEventNotifier::revokeClient( mnClientId );
 415             mnClientId = 0;
 416         }
 417     }
 418 }
 419
 420
 421
 422
 423 //===== XAccessibleComponent ==================================================
 424
 425 sal_Bool SAL_CALL AccessibleTreeNode::containsPoint (const awt::Point& aPoint)
 426     throw (RuntimeException)
 427 {
 428     ThrowIfDisposed();
 429     const awt::Rectangle aBBox (getBounds());
 430     return (aPoint.X >= 0)
 431         && (aPoint.X < aBBox.Width)
 432         && (aPoint.Y >= 0)
 433         && (aPoint.Y < aBBox.Height);
 434 }
 435
 436
 437
 438
 439 Reference<XAccessible> SAL_CALL
 440     AccessibleTreeNode::getAccessibleAtPoint (const awt::Point& aPoint)
 441     throw (RuntimeException)
 442 {
 443     ThrowIfDisposed();
 444     Reference<XAccessible> xChildAtPoint;
 445     const vos::OGuard aSolarGuard (Application::GetSolarMutex());
 446
 447     sal_Int32 nChildCount = getAccessibleChildCount();
 448     for (sal_Int32 nIndex=0; nIndex<nChildCount; ++nIndex)
 449     {
 450         Reference<XAccessibleComponent> xChildComponent(
 451             getAccessibleChild(nIndex), UNO_QUERY);
 452         if (xChildComponent.is())
 453         {
 454             awt::Point aChildPoint(aPoint);
 455             awt::Point aChildOrigin(xChildComponent->getLocation());
 456             aChildPoint.X -= aChildOrigin.X;
 457             aChildPoint.Y -= aChildOrigin.Y;
 458             if (xChildComponent->containsPoint(aChildPoint))
 459             {
 460                 xChildAtPoint = getAccessibleChild(nIndex);
 461                 break;
 462             }
 463         }
 464     }
 465
 466     return xChildAtPoint;
 467 }
 468
 469
 470
 471
 472 awt::Rectangle SAL_CALL AccessibleTreeNode::getBounds (void)
 473     throw (RuntimeException)
 474 {
 475     ThrowIfDisposed ();
 476
 477     awt::Rectangle aBBox;
 478
 479     ::Window* pWindow = mrTreeNode.GetWindow();
 480     if (pWindow != NULL)
 481     {
 482         Point aPosition;
 483         if (mxParent.is())
 484         {
 485             aPosition = pWindow->OutputToAbsoluteScreenPixel(Point(0,0));
 486             Reference<XAccessibleComponent> xParentComponent (
 487                 mxParent->getAccessibleContext(), UNO_QUERY);
 488             if (xParentComponent.is())
 489             {
 490                 awt::Point aParentPosition (xParentComponent->getLocationOnScreen());
 491                 aPosition.X() -= aParentPosition.X;
 492                 aPosition.Y() -= aParentPosition.Y;
 493             }
 494         }
 495         else
 496             aPosition = pWindow->GetPosPixel();
 497         aBBox.X = aPosition.X();
 498         aBBox.Y = aPosition.Y();
 499
 500         Size aSize (pWindow->GetSizePixel());
 501         aBBox.Width = aSize.Width();
 502         aBBox.Height = aSize.Height();
 503     }
 504
 505     return aBBox;
 506 }
 507
 508
 509
 510
 511 awt::Point SAL_CALL AccessibleTreeNode::getLocation (void)
 512     throw (uno::RuntimeException)
 513 {
 514     ThrowIfDisposed();
 515     const awt::Rectangle aBBox (getBounds());
 516     return awt::Point(aBBox.X,aBBox.Y);
 517 }
 518
 519
 520
 521
 522 /** Calculate the location on screen from the parent's location on screen
 523     and our own relative location.
 524 */
 525 awt::Point SAL_CALL AccessibleTreeNode::getLocationOnScreen()
 526     throw (uno::RuntimeException)
 527 {
 528     ThrowIfDisposed();
 529     const vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 530     awt::Point aLocationOnScreen;
 531
 532     ::Window* pWindow = mrTreeNode.GetWindow();
 533     if (pWindow != NULL)
 534     {
 535         Point aPoint (pWindow->OutputToAbsoluteScreenPixel(Point(0,0)));
 536         aLocationOnScreen.X = aPoint.X();
 537         aLocationOnScreen.Y = aPoint.Y();
 538     }
 539
 540     return aLocationOnScreen;
 541 }
 542
 543
 544
 545
 546 awt::Size SAL_CALL AccessibleTreeNode::getSize (void)
 547     throw (uno::RuntimeException)
 548 {
 549     ThrowIfDisposed();
 550     const awt::Rectangle aBBox (getBounds());
 551     return awt::Size(aBBox.Width,aBBox.Height);
 552 }
 553
 554
 555
 556
 557 void SAL_CALL AccessibleTreeNode::grabFocus (void)
 558     throw (uno::RuntimeException)
 559 {
 560     ThrowIfDisposed();
 561     const vos::OGuard aSolarGuard (Application::GetSolarMutex());
 562
 563     if (mrTreeNode.GetWindow() != NULL)
 564         mrTreeNode.GetWindow()->GrabFocus();
 565 }
 566
 567
 568
 569
 570 sal_Int32 SAL_CALL AccessibleTreeNode::getForeground (void)
 571     throw (RuntimeException)
 572 {
 573     ThrowIfDisposed();
 574     svtools::ColorConfig aColorConfig;
 575     UINT32 nColor = aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor;
 576     return static_cast<sal_Int32>(nColor);
 577 }
 578
 579
 580
 581
 582 sal_Int32 SAL_CALL AccessibleTreeNode::getBackground (void)
 583     throw (RuntimeException)
 584 {
 585     ThrowIfDisposed();
 586     UINT32 nColor = Application::GetSettings().GetStyleSettings().GetWindowColor().GetColor();
 587     return static_cast<sal_Int32>(nColor);
 588 }
 589
 590
 591
 592
 593 //=====  XServiceInfo  ========================================================
 594
 595 ::rtl::OUString SAL_CALL
 596        AccessibleTreeNode::getImplementationName (void)
 597     throw (::com::sun::star::uno::RuntimeException)
 598 {
 599     return OUString(RTL_CONSTASCII_USTRINGPARAM("AccessibleTreeNode"));
 600 }
 601
 602
 603
 604
 605 sal_Bool SAL_CALL
 606      AccessibleTreeNode::supportsService (const OUString& sServiceName)
 607     throw (::com::sun::star::uno::RuntimeException)
 608 {
 609     ThrowIfDisposed ();
 610
 611     //  Iterate over all supported service names and return true if on of them
 612     //  matches the given name.
 613     uno::Sequence< ::rtl::OUString> aSupportedServices (
 614         getSupportedServiceNames ());
 615     for (int i=0; i<aSupportedServices.getLength(); i++)
 616         if (sServiceName == aSupportedServices[i])
 617             return sal_True;
 618     return sal_False;
 619 }
 620
 621
 622
 623
 624 uno::Sequence< ::rtl::OUString> SAL_CALL
 625        AccessibleTreeNode::getSupportedServiceNames (void)
 626     throw (::com::sun::star::uno::RuntimeException)
 627 {
 628     ThrowIfDisposed ();
 629     static const OUString sServiceNames[2] = {
 630         OUString(RTL_CONSTASCII_USTRINGPARAM(
 631             "com.sun.star.accessibility.Accessible")),
 632         OUString(RTL_CONSTASCII_USTRINGPARAM(
 633             "com.sun.star.accessibility.AccessibleContext")),
 634     };
 635     return uno::Sequence<OUString> (sServiceNames, 2);
 636 }
 637
 638
 639
 640
 641 void AccessibleTreeNode::ThrowIfDisposed (void)
 642     throw (lang::DisposedException)
 643 {
 644     if (rBHelper.bDisposed || rBHelper.bInDispose)
 645     {
 646         OSL_TRACE ("Calling disposed object. Throwing exception:");
 647         throw lang::DisposedException (
 648             OUString(RTL_CONSTASCII_USTRINGPARAM("object has been already disposed")),
 649             static_cast<uno::XWeak*>(this));
 650     }
 651 }
 652
 653
 654
 655 sal_Bool AccessibleTreeNode::IsDisposed (void)
 656 {
 657     return (rBHelper.bDisposed || rBHelper.bInDispose);
 658 }
 659
 660
 661
 662
 663 IMPL_LINK(AccessibleTreeNode, StateChangeListener, TreeNodeStateChangeEvent*, pEvent)
 664 {
 665     OSL_ASSERT(pEvent!=NULL);
 666     OSL_ASSERT(&pEvent->mrSource==&mrTreeNode);
 667
 668     switch(pEvent->meEventId)
 669     {
 670         case EID_CHILD_ADDED:
 671             if (pEvent->mpChild != NULL)
 672                 FireAccessibleEvent(AccessibleEventId::CHILD,
 673                     Any(),
 674                     Any(pEvent->mpChild->GetAccessibleObject()));
 675             else
 676                 FireAccessibleEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN,Any(),Any());
 677             break;
 678
 679         case EID_ALL_CHILDREN_REMOVED:
 680             FireAccessibleEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN,Any(),Any());
 681             break;
 682
 683         case EID_EXPANSION_STATE_CHANGED:
 684         case EID_FOCUSED_STATE_CHANGED:
 685         case EID_SHOWING_STATE_CHANGED:
 686             UpdateStateSet();
 687             break;
 688     }
 689     return 1;
 690 }
 691
 692
 693
 694
 695 IMPL_LINK(AccessibleTreeNode, WindowEventListener, VclWindowEvent*, pEvent)
 696 {
 697     switch (pEvent->GetId())
 698     {
 699         case VCLEVENT_WINDOW_HIDE:
 700             // This event may be sent while the window is destroyed so do
 701             // not call UpdateStateSet() which calls back to the window but
 702             // just set the two states VISIBLE and SHOWING to false.
 703             UpdateState(AccessibleStateType::VISIBLE, false);
 704             UpdateState(AccessibleStateType::SHOWING, false);
 705             break;
 706
 707         case VCLEVENT_WINDOW_SHOW:
 708         case VCLEVENT_WINDOW_DATACHANGED:
 709             UpdateStateSet();
 710             break;
 711
 712         case VCLEVENT_WINDOW_MOVE:
 713         case VCLEVENT_WINDOW_RESIZE:
 714             FireAccessibleEvent(AccessibleEventId::BOUNDRECT_CHANGED,Any(),Any());
 715             break;
 716
 717         case VCLEVENT_WINDOW_GETFOCUS:
 718         case VCLEVENT_WINDOW_LOSEFOCUS:
 719             UpdateStateSet();
 720     }
 721     return 1;
 722 }
 723
 724 } // end of namespace ::accessibility