svtools/source/control/toolbarmenuacc.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  22 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  23 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  24
  25 #include <unotools/accessiblestatesethelper.hxx>
  26
  27 #include <vcl/svapp.hxx>
  28
  29 #include "svtools/toolbarmenu.hxx"
  30
  31 #include "toolbarmenuimp.hxx"
  32
  33
  34 using namespace ::com::sun::star;
  35 using namespace ::com::sun::star::uno;
  36 using namespace ::com::sun::star::lang;
  37 using namespace ::com::sun::star::accessibility;
  38
  39 namespace svtools {
  40
  41 // ------------------
  42 // - ToolbarMenuAcc -
  43 // ------------------
  44
  45 ToolbarMenuAcc::ToolbarMenuAcc( ToolbarMenu_Impl& rParent )
  46 : ToolbarMenuAccComponentBase(m_aMutex)
  47 , mpParent( &rParent )
  48 , mbIsFocused(false)
  49 {
  50     mpParent->mrMenu.AddEventListener( LINK( this, ToolbarMenuAcc, WindowEventListener ) );
  51 }
  52
  53 // -----------------------------------------------------------------------------
  54
  55 ToolbarMenuAcc::~ToolbarMenuAcc()
  56 {
  57     if( mpParent )
  58         mpParent->mrMenu.RemoveEventListener( LINK( this, ToolbarMenuAcc, WindowEventListener ) );
  59 }
  60
  61 // -----------------------------------------------------------------------
  62
  63 IMPL_LINK( ToolbarMenuAcc, WindowEventListener, VclSimpleEvent*, pEvent )
  64 {
  65     DBG_ASSERT( pEvent && pEvent->ISA( VclWindowEvent ), "Unknown WindowEvent!" );
  66
  67     /* Ignore VCLEVENT_WINDOW_ENDPOPUPMODE, because the UNO accessibility wrapper
  68      * might have been destroyed by the previous VCLEventListener (if no AT tool
  69      * is running), e.g. sub-toolbars in impress.
  70      */
  71     if ( mpParent && pEvent && pEvent->ISA( VclWindowEvent ) && (pEvent->GetId() != VCLEVENT_WINDOW_ENDPOPUPMODE) )
  72     {
  73         DBG_ASSERT( ((VclWindowEvent*)pEvent)->GetWindow(), "Window???" );
  74         if( !((VclWindowEvent*)pEvent)->GetWindow()->IsAccessibilityEventsSuppressed() || ( pEvent->GetId() == VCLEVENT_OBJECT_DYING ) )
  75         {
  76             ProcessWindowEvent( *(VclWindowEvent*)pEvent );
  77         }
  78     }
  79     return 0;
  80 }
  81
  82 // -----------------------------------------------------------------------
  83
  84 void ToolbarMenuAcc::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
  85 {
  86     switch ( rVclWindowEvent.GetId() )
  87     {
  88         case VCLEVENT_OBJECT_DYING:
  89         {
  90             mpParent->mrMenu.RemoveEventListener( LINK( this, ToolbarMenuAcc, WindowEventListener ) );
  91             mpParent = 0;
  92         }
  93         break;
  94
  95         case VCLEVENT_WINDOW_GETFOCUS:
  96         {
  97             if( !mbIsFocused )
  98             {
  99                 mpParent->notifyHighlightedEntry();
 100                 mbIsFocused = true;
 101             }
 102         }
 103         break;
 104         case VCLEVENT_WINDOW_LOSEFOCUS:
 105         {
 106             if( mbIsFocused )
 107             {
 108                 mbIsFocused = false;
 109             }
 110         }
 111         break;
 112         default:
 113         {
 114         }
 115         break;
 116     }
 117 }
 118
 119 // -----------------------------------------------------------------------
 120
 121 void ToolbarMenuAcc::FireAccessibleEvent( short nEventId, const Any& rOldValue, const Any& rNewValue )
 122 {
 123     if( nEventId )
 124     {
 125         EventListenerVector                  aTmpListeners( mxEventListeners );
 126         AccessibleEventObject aEvtObject;
 127
 128         aEvtObject.EventId = nEventId;
 129         aEvtObject.Source = static_cast<XWeak*>(this);
 130         aEvtObject.NewValue = rNewValue;
 131         aEvtObject.OldValue = rOldValue;
 132
 133         for (EventListenerVector::const_iterator aIter( aTmpListeners.begin() ), aEnd( aTmpListeners.end() );
 134             aIter != aEnd ; ++aIter)
 135         {
 136             try
 137             {
 138                 (*aIter)->notifyEvent( aEvtObject );
 139             }
 140             catch( Exception& )
 141             {
 142             }
 143         }
 144     }
 145 }
 146
 147 // -----------------------------------------------------------------------------
 148
 149 Reference< XAccessibleContext > SAL_CALL ToolbarMenuAcc::getAccessibleContext() throw (RuntimeException)
 150 {
 151     ThrowIfDisposed();
 152     return this;
 153 }
 154
 155 // -----------------------------------------------------------------------------
 156
 157 sal_Int32 SAL_CALL ToolbarMenuAcc::getAccessibleChildCount() throw (RuntimeException)
 158 {
 159     const SolarMutexGuard aSolarGuard;
 160     ThrowIfDisposed();
 161
 162     return mpParent->getAccessibleChildCount();
 163 }
 164
 165 // -----------------------------------------------------------------------------
 166
 167 Reference< XAccessible > SAL_CALL ToolbarMenuAcc::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 168 {
 169     const SolarMutexGuard aSolarGuard;
 170     ThrowIfDisposed();
 171
 172     return mpParent->getAccessibleChild(i);
 173 }
 174
 175 // -----------------------------------------------------------------------------
 176
 177 Reference< XAccessible > SAL_CALL ToolbarMenuAcc::getAccessibleParent() throw (RuntimeException)
 178 {
 179     ThrowIfDisposed();
 180     const SolarMutexGuard aSolarGuard;
 181
 182     Reference< XAccessible > xRet;
 183
 184     Window* pParent = mpParent->mrMenu.GetParent();
 185     if( pParent )
 186         xRet = pParent->GetAccessible();
 187
 188     return xRet;
 189 }
 190
 191 // -----------------------------------------------------------------------------
 192
 193 sal_Int32 SAL_CALL ToolbarMenuAcc::getAccessibleIndexInParent() throw (RuntimeException)
 194 {
 195     const SolarMutexGuard aSolarGuard;
 196     ThrowIfDisposed();
 197
 198     Window* pParent = mpParent->mrMenu.GetParent();
 199     if( pParent )
 200     {
 201         for( sal_uInt16 i = 0, nCount = pParent->GetChildCount(); i < nCount ; i++ )
 202         {
 203             if( pParent->GetChild( i ) == &mpParent->mrMenu )
 204                 return i;
 205         }
 206     }
 207
 208     return 0;
 209 }
 210
 211 // -----------------------------------------------------------------------------
 212
 213 sal_Int16 SAL_CALL ToolbarMenuAcc::getAccessibleRole() throw (RuntimeException)
 214 {
 215     ThrowIfDisposed();
 216     return AccessibleRole::LIST;
 217 }
 218
 219 // -----------------------------------------------------------------------------
 220
 221 OUString SAL_CALL ToolbarMenuAcc::getAccessibleDescription() throw (RuntimeException)
 222 {
 223     ThrowIfDisposed();
 224     return OUString( "ToolbarMenu" );
 225 }
 226
 227 // -----------------------------------------------------------------------------
 228
 229 OUString SAL_CALL ToolbarMenuAcc::getAccessibleName() throw (RuntimeException)
 230 {
 231     ThrowIfDisposed();
 232     const SolarMutexGuard aSolarGuard;
 233     OUString aRet;
 234
 235     if( mpParent )
 236         aRet = mpParent->mrMenu.GetAccessibleName();
 237
 238     if( aRet.isEmpty() )
 239     {
 240         Window* pLabel = mpParent->mrMenu.GetAccessibleRelationLabeledBy();
 241         if( pLabel && pLabel != &mpParent->mrMenu )
 242             aRet = OutputDevice::GetNonMnemonicString( pLabel->GetText() );
 243     }
 244
 245     return aRet;
 246 }
 247
 248 // -----------------------------------------------------------------------------
 249
 250 Reference< XAccessibleRelationSet > SAL_CALL ToolbarMenuAcc::getAccessibleRelationSet() throw (RuntimeException)
 251 {
 252     ThrowIfDisposed();
 253     return Reference< XAccessibleRelationSet >();
 254 }
 255
 256 // -----------------------------------------------------------------------------
 257
 258 Reference< XAccessibleStateSet > SAL_CALL ToolbarMenuAcc::getAccessibleStateSet() throw (RuntimeException)
 259 {
 260     ThrowIfDisposed();
 261     ::utl::AccessibleStateSetHelper* pStateSet = new ::utl::AccessibleStateSetHelper();
 262
 263     // Set some states.
 264     pStateSet->AddState (AccessibleStateType::ENABLED);
 265     pStateSet->AddState (AccessibleStateType::SENSITIVE);
 266     pStateSet->AddState (AccessibleStateType::SHOWING);
 267     pStateSet->AddState (AccessibleStateType::VISIBLE);
 268     pStateSet->AddState (AccessibleStateType::MANAGES_DESCENDANTS);
 269     pStateSet->AddState (AccessibleStateType::FOCUSABLE);
 270     if (mbIsFocused)
 271         pStateSet->AddState (AccessibleStateType::FOCUSED);
 272
 273     return pStateSet;
 274 }
 275
 276 // -----------------------------------------------------------------------------
 277
 278 Locale SAL_CALL ToolbarMenuAcc::getLocale() throw (IllegalAccessibleComponentStateException, RuntimeException)
 279 {
 280     ThrowIfDisposed();
 281     const SolarMutexGuard aSolarGuard;
 282     const OUString aEmptyStr;
 283     Reference< XAccessible > xParent( getAccessibleParent() );
 284     Locale aRet( aEmptyStr, aEmptyStr, aEmptyStr );
 285
 286     if( xParent.is() )
 287     {
 288         Reference< XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 289
 290         if( xParentContext.is() )
 291             aRet = xParentContext->getLocale ();
 292     }
 293
 294     return aRet;
 295 }
 296
 297 // -----------------------------------------------------------------------------
 298
 299 void SAL_CALL ToolbarMenuAcc::addAccessibleEventListener( const Reference< XAccessibleEventListener >& rxListener ) throw (RuntimeException)
 300 {
 301     ThrowIfDisposed();
 302     ::osl::MutexGuard aGuard(m_aMutex);
 303
 304     if( rxListener.is() )
 305     {
 306            EventListenerVector::const_iterator aIter = mxEventListeners.begin();
 307         bool bFound = false;
 308
 309         while( !bFound && ( aIter != mxEventListeners.end() ) )
 310         {
 311             if( *aIter == rxListener )
 312                 bFound = true;
 313             else
 314                 ++aIter;
 315         }
 316
 317         if (!bFound)
 318             mxEventListeners.push_back( rxListener );
 319     }
 320 }
 321
 322 // -----------------------------------------------------------------------------
 323
 324 void SAL_CALL ToolbarMenuAcc::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& rxListener ) throw (RuntimeException)
 325 {
 326     ThrowIfDisposed();
 327     ::osl::MutexGuard aGuard(m_aMutex);
 328
 329     if( rxListener.is() )
 330     {
 331         EventListenerVector::iterator aIter = std::find(mxEventListeners.begin(), mxEventListeners.end(), rxListener);
 332         if (aIter != mxEventListeners.end())
 333             mxEventListeners.erase(aIter);
 334     }
 335 }
 336
 337 // -----------------------------------------------------------------------------
 338
 339 sal_Bool SAL_CALL ToolbarMenuAcc::containsPoint( const awt::Point& aPoint ) throw (RuntimeException)
 340 {
 341     ThrowIfDisposed();
 342     const awt::Rectangle aRect( getBounds() );
 343     const Point aSize( aRect.Width, aRect.Height );
 344     const Point aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
 345
 346     return Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
 347 }
 348
 349 // -----------------------------------------------------------------------------
 350
 351 Reference< XAccessible > SAL_CALL ToolbarMenuAcc::getAccessibleAtPoint( const awt::Point& aPoint ) throw (RuntimeException)
 352 {
 353     const SolarMutexGuard aSolarGuard;
 354     ThrowIfDisposed();
 355
 356     Reference< XAccessible > xRet;
 357
 358     const Point aVclPoint( aPoint.X, aPoint.Y );
 359
 360     const int nEntryCount = mpParent->maEntryVector.size();
 361     for( int nEntry = 0; (nEntry < nEntryCount) && !xRet.is(); nEntry++ )
 362     {
 363         ToolbarMenuEntry* pEntry = mpParent->maEntryVector[nEntry];
 364         if( pEntry && pEntry->maRect.IsInside( aVclPoint ) )
 365         {
 366             if( pEntry->mpControl )
 367             {
 368                 awt::Point aChildPoint( aPoint.X - pEntry->maRect.Left(), aPoint.Y - pEntry->maRect.Top() );
 369                 Reference< XAccessibleComponent > xComp( pEntry->GetAccessible(true), UNO_QUERY_THROW );
 370                 xRet = xComp->getAccessibleAtPoint(aChildPoint);
 371             }
 372             else
 373             {
 374                 xRet = Reference< XAccessible >( pEntry->GetAccessible(true), UNO_QUERY );
 375             }
 376         }
 377     }
 378     return xRet;
 379 }
 380
 381 // -----------------------------------------------------------------------------
 382
 383 awt::Rectangle SAL_CALL ToolbarMenuAcc::getBounds() throw (RuntimeException)
 384 {
 385     ThrowIfDisposed();
 386     const SolarMutexGuard aSolarGuard;
 387     const Point         aOutPos( mpParent->mrMenu.GetPosPixel() );
 388     const Size          aOutSize( mpParent->mrMenu.GetOutputSizePixel() );
 389     awt::Rectangle      aRet;
 390
 391     aRet.X = aOutPos.X();
 392     aRet.Y = aOutPos.Y();
 393     aRet.Width = aOutSize.Width();
 394     aRet.Height = aOutSize.Height();
 395
 396     return aRet;
 397 }
 398
 399 // -----------------------------------------------------------------------------
 400
 401 awt::Point SAL_CALL ToolbarMenuAcc::getLocation() throw (RuntimeException)
 402 {
 403     ThrowIfDisposed();
 404     const SolarMutexGuard aSolarGuard;
 405     const Point aOutPos( mpParent->mrMenu.GetPosPixel() );
 406     return awt::Point( aOutPos.X(), aOutPos.Y() );
 407 }
 408
 409 // -----------------------------------------------------------------------------
 410
 411 awt::Point SAL_CALL ToolbarMenuAcc::getLocationOnScreen()  throw (RuntimeException)
 412 {
 413     ThrowIfDisposed();
 414     const SolarMutexGuard aSolarGuard;
 415     const Point aScreenPos( mpParent->mrMenu.OutputToAbsoluteScreenPixel( Point() ) );
 416     return awt::Point( aScreenPos.X(), aScreenPos.Y() );
 417 }
 418
 419 // -----------------------------------------------------------------------------
 420
 421 awt::Size SAL_CALL ToolbarMenuAcc::getSize() throw (RuntimeException)
 422 {
 423     ThrowIfDisposed();
 424     const SolarMutexGuard aSolarGuard;
 425     const Size aOutSize( mpParent->mrMenu.GetOutputSizePixel() );
 426     return awt::Size( aOutSize.Width(), aOutSize.Height() );
 427 }
 428
 429 // -----------------------------------------------------------------------------
 430
 431 void SAL_CALL ToolbarMenuAcc::grabFocus() throw (RuntimeException)
 432 {
 433     ThrowIfDisposed();
 434     const SolarMutexGuard aSolarGuard;
 435     mpParent->mrMenu.GrabFocus();
 436 }
 437
 438 // -----------------------------------------------------------------------------
 439
 440 Any SAL_CALL ToolbarMenuAcc::getAccessibleKeyBinding() throw (RuntimeException)
 441 {
 442     ThrowIfDisposed();
 443     return Any();
 444 }
 445
 446 // -----------------------------------------------------------------------------
 447
 448 sal_Int32 SAL_CALL ToolbarMenuAcc::getForeground() throw (RuntimeException)
 449 {
 450     ThrowIfDisposed();
 451     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetMenuTextColor().GetColor();
 452     return static_cast<sal_Int32>(nColor);
 453 }
 454
 455 // -----------------------------------------------------------------------------
 456
 457 sal_Int32 SAL_CALL ToolbarMenuAcc::getBackground() throw (RuntimeException)
 458 {
 459     ThrowIfDisposed();
 460     sal_uInt32 nColor = Application::GetSettings().GetStyleSettings().GetMenuColor().GetColor();
 461     return static_cast<sal_Int32>(nColor);
 462 }
 463
 464 // -----------------------------------------------------------------------------
 465
 466 void SAL_CALL ToolbarMenuAcc::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 467 {
 468     const SolarMutexGuard aSolarGuard;
 469     ThrowIfDisposed();
 470
 471     mpParent->selectAccessibleChild( nChildIndex );
 472 }
 473
 474 // -----------------------------------------------------------------------------
 475
 476 sal_Bool SAL_CALL ToolbarMenuAcc::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 477 {
 478     const SolarMutexGuard aSolarGuard;
 479     ThrowIfDisposed();
 480     return mpParent->isAccessibleChildSelected( nChildIndex );
 481 }
 482
 483 // -----------------------------------------------------------------------------
 484
 485 void SAL_CALL ToolbarMenuAcc::clearAccessibleSelection() throw (RuntimeException)
 486 {
 487     const SolarMutexGuard aSolarGuard;
 488     ThrowIfDisposed();
 489     mpParent->clearAccessibleSelection();
 490 }
 491
 492 // -----------------------------------------------------------------------------
 493
 494 void SAL_CALL ToolbarMenuAcc::selectAllAccessibleChildren() throw (RuntimeException)
 495 {
 496     ThrowIfDisposed();
 497     // unsupported due to single selection only
 498 }
 499
 500 // -----------------------------------------------------------------------------
 501
 502 sal_Int32 SAL_CALL ToolbarMenuAcc::getSelectedAccessibleChildCount() throw (RuntimeException)
 503 {
 504     const SolarMutexGuard aSolarGuard;
 505     ThrowIfDisposed();
 506
 507     return mpParent->mnHighlightedEntry != -1 ? 1 : 0;
 508 }
 509
 510 // -----------------------------------------------------------------------------
 511
 512 Reference< XAccessible > SAL_CALL ToolbarMenuAcc::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 513 {
 514     ThrowIfDisposed();
 515     const SolarMutexGuard aSolarGuard;
 516
 517     if( (mpParent->mnHighlightedEntry != -1) && (nSelectedChildIndex == 0) )
 518     {
 519         ToolbarMenuEntry* pEntry = mpParent->maEntryVector[ mpParent->mnHighlightedEntry ];
 520         if( pEntry )
 521         {
 522             if( pEntry->mpControl )
 523             {
 524                 Reference< XAccessibleSelection > xSel( pEntry->GetAccessible(true), UNO_QUERY_THROW );
 525                 return xSel->getSelectedAccessibleChild(0);
 526             }
 527             else
 528                 return Reference< XAccessible >( pEntry->GetAccessible(true), UNO_QUERY );
 529         }
 530     }
 531
 532     throw IndexOutOfBoundsException();
 533 }
 534
 535 // -----------------------------------------------------------------------------
 536
 537 void SAL_CALL ToolbarMenuAcc::deselectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 538 {
 539     ThrowIfDisposed();
 540     const SolarMutexGuard aSolarGuard;
 541     // Because of the single selection we can reset the whole selection when
 542     // the specified child is currently selected.
 543     if (isAccessibleChildSelected(nChildIndex))
 544         mpParent->clearAccessibleSelection();
 545 }
 546
 547 // -----------------------------------------------------------------------------
 548
 549 void SAL_CALL ToolbarMenuAcc::disposing (void)
 550 {
 551     EventListenerVector aListenerListCopy;
 552
 553     {
 554         // Make a copy of the list and clear the original.
 555         const SolarMutexGuard aSolarGuard;
 556         ::osl::MutexGuard aGuard (m_aMutex);
 557         aListenerListCopy = mxEventListeners;
 558         mxEventListeners.clear();
 559
 560         // Reset the pointer to the parent.  It has to be the one who has
 561         // disposed us because he is dying.
 562         mpParent = NULL;
 563     }
 564
 565     // Inform all listeners that this objects is disposing.
 566     EventListenerVector::const_iterator aListenerIterator (aListenerListCopy.begin());
 567     EventObject aEvent (static_cast<XAccessible*>(this));
 568     while(aListenerIterator != aListenerListCopy.end())
 569     {
 570         try
 571         {
 572             (*aListenerIterator)->disposing (aEvent);
 573         }
 574         catch( Exception& )
 575         {
 576             // Ignore exceptions.
 577         }
 578
 579         ++aListenerIterator;
 580     }
 581 }
 582
 583 void ToolbarMenuAcc::ThrowIfDisposed (void) throw (DisposedException)
 584 {
 585     if(rBHelper.bDisposed || rBHelper.bInDispose || !mpParent)
 586     {
 587         throw DisposedException ("object has been already disposed", static_cast<XWeak*>(this));
 588     }
 589 }
 590
 591 // -----------------------
 592 // - ToolbarMenuEntryAcc -
 593 // -----------------------
 594
 595 ToolbarMenuEntryAcc::ToolbarMenuEntryAcc( ToolbarMenuEntry* pParent )
 596 : ToolbarMenuEntryAccBase( m_aMutex )
 597 , mpParent( pParent )
 598 {
 599 }
 600
 601 // -----------------------------------------------------------------------------
 602
 603 ToolbarMenuEntryAcc::~ToolbarMenuEntryAcc()
 604 {
 605 }
 606
 607 // -----------------------------------------------------------------------
 608
 609 void SAL_CALL ToolbarMenuEntryAcc::disposing (void)
 610 {
 611     EventListenerVector aListenerListCopy;
 612
 613     {
 614         // Make a copy of the list and clear the original.
 615         const SolarMutexGuard aSolarGuard;
 616         ::osl::MutexGuard aGuard (m_aMutex);
 617         aListenerListCopy = mxEventListeners;
 618         mxEventListeners.clear();
 619
 620         // Reset the pointer to the parent.  It has to be the one who has
 621         // disposed us because he is dying.
 622         mpParent = NULL;
 623     }
 624
 625     // Inform all listeners that this objects is disposing.
 626     EventListenerVector::const_iterator aListenerIterator (aListenerListCopy.begin());
 627     EventObject aEvent (static_cast<XAccessible*>(this));
 628     while(aListenerIterator != aListenerListCopy.end())
 629     {
 630         try
 631         {
 632             (*aListenerIterator)->disposing (aEvent);
 633         }
 634         catch( Exception& )
 635         {
 636             // Ignore exceptions.
 637         }
 638
 639         ++aListenerIterator;
 640     }
 641 }
 642 // -----------------------------------------------------------------------------
 643
 644 Reference< XAccessibleContext > SAL_CALL ToolbarMenuEntryAcc::getAccessibleContext() throw (RuntimeException)
 645 {
 646     return this;
 647 }
 648
 649 // -----------------------------------------------------------------------------
 650
 651 sal_Int32 SAL_CALL ToolbarMenuEntryAcc::getAccessibleChildCount() throw (RuntimeException)
 652 {
 653     return 0;
 654 }
 655
 656 // -----------------------------------------------------------------------------
 657
 658 Reference< XAccessible > SAL_CALL ToolbarMenuEntryAcc::getAccessibleChild( sal_Int32 ) throw (IndexOutOfBoundsException, RuntimeException)
 659 {
 660     throw IndexOutOfBoundsException();
 661 }
 662
 663 // -----------------------------------------------------------------------------
 664
 665 Reference< XAccessible > SAL_CALL ToolbarMenuEntryAcc::getAccessibleParent() throw (RuntimeException)
 666 {
 667     const SolarMutexGuard aSolarGuard;
 668     Reference< XAccessible > xRet;
 669
 670     if( mpParent )
 671         xRet = mpParent->mrMenu.GetAccessible();
 672
 673     return xRet;
 674 }
 675
 676 // -----------------------------------------------------------------------------
 677
 678 sal_Int32 SAL_CALL ToolbarMenuEntryAcc::getAccessibleIndexInParent() throw (RuntimeException)
 679 {
 680     const SolarMutexGuard aSolarGuard;
 681     // The index defaults to -1 to indicate the child does not belong to its
 682     // parent.
 683     sal_Int32 nIndexInParent = -1;
 684
 685     if( mpParent )
 686     {
 687         Reference< XAccessibleContext > xParent( mpParent->mrMenu.GetAccessible(), UNO_QUERY );
 688
 689         if( xParent.is() )
 690         {
 691             Reference< XAccessible > xThis( this );
 692
 693             const sal_Int32 nCount = xParent->getAccessibleChildCount();
 694             for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
 695             {
 696                 if( xParent->getAccessibleChild(nIndex) == xThis )
 697                 {
 698                     nIndexInParent = nIndex;
 699                     break;
 700                 }
 701             }
 702         }
 703     }
 704
 705     return nIndexInParent;
 706 }
 707
 708 // -----------------------------------------------------------------------------
 709
 710 sal_Int16 SAL_CALL ToolbarMenuEntryAcc::getAccessibleRole() throw (RuntimeException)
 711 {
 712     return AccessibleRole::LIST_ITEM;
 713 }
 714
 715 // -----------------------------------------------------------------------------
 716
 717 OUString SAL_CALL ToolbarMenuEntryAcc::getAccessibleDescription() throw (RuntimeException)
 718 {
 719     return OUString();
 720 }
 721
 722 // -----------------------------------------------------------------------------
 723
 724 OUString SAL_CALL ToolbarMenuEntryAcc::getAccessibleName() throw (RuntimeException)
 725 {
 726     const SolarMutexGuard aSolarGuard;
 727     OUString              aRet;
 728
 729     if( mpParent )
 730     {
 731         aRet = mpParent->maText;
 732
 733         if( aRet.isEmpty() )
 734         {
 735             aRet = "Item ";
 736             aRet += OUString::number( mpParent->mnEntryId );
 737         }
 738     }
 739
 740     return aRet;
 741 }
 742
 743 // -----------------------------------------------------------------------------
 744
 745 Reference< XAccessibleRelationSet > SAL_CALL ToolbarMenuEntryAcc::getAccessibleRelationSet() throw (RuntimeException)
 746 {
 747     return Reference< XAccessibleRelationSet >();
 748 }
 749
 750 // -----------------------------------------------------------------------------
 751
 752 Reference< XAccessibleStateSet > SAL_CALL ToolbarMenuEntryAcc::getAccessibleStateSet() throw (RuntimeException)
 753 {
 754     const SolarMutexGuard aSolarGuard;
 755     ::utl::AccessibleStateSetHelper*    pStateSet = new ::utl::AccessibleStateSetHelper;
 756
 757     if( mpParent )
 758     {
 759         pStateSet->AddState (AccessibleStateType::ENABLED);
 760         pStateSet->AddState (AccessibleStateType::SENSITIVE);
 761         pStateSet->AddState (AccessibleStateType::SHOWING);
 762         pStateSet->AddState (AccessibleStateType::VISIBLE);
 763         pStateSet->AddState (AccessibleStateType::TRANSIENT);
 764         if( mpParent->mnEntryId != TITLE_ID )
 765         {
 766             pStateSet->AddState( AccessibleStateType::SELECTABLE );
 767
 768             // SELECTED
 769             if( mpParent->mrMenu.getHighlightedEntryId() == mpParent->mnEntryId )
 770                 pStateSet->AddState( AccessibleStateType::SELECTED );
 771         }
 772     }
 773
 774     return pStateSet;
 775 }
 776
 777 // -----------------------------------------------------------------------------
 778
 779 Locale SAL_CALL ToolbarMenuEntryAcc::getLocale() throw (IllegalAccessibleComponentStateException, RuntimeException)
 780 {
 781     const OUString aEmptyStr;
 782     Locale aRet( aEmptyStr, aEmptyStr, aEmptyStr );
 783
 784     Reference< XAccessible > xParent( getAccessibleParent() );
 785     if( xParent.is() )
 786     {
 787         Reference< XAccessibleContext > xParentContext( xParent->getAccessibleContext() );
 788
 789         if( xParentContext.is() )
 790             aRet = xParentContext->getLocale();
 791     }
 792
 793     return aRet;
 794 }
 795
 796 // -----------------------------------------------------------------------------
 797
 798 void SAL_CALL ToolbarMenuEntryAcc::addAccessibleEventListener( const Reference< XAccessibleEventListener >& rxListener ) throw (RuntimeException)
 799 {
 800     const ::osl::MutexGuard aGuard( maMutex );
 801
 802     if( rxListener.is() )
 803     {
 804         for (EventListenerVector::const_iterator aIter( mxEventListeners.begin() ), aEnd( mxEventListeners.end() );
 805             aIter != aEnd; ++aIter )
 806         {
 807             if( *aIter == rxListener )
 808                 return;
 809         }
 810         // listener not found so add it
 811         mxEventListeners.push_back( rxListener );
 812     }
 813 }
 814
 815 // -----------------------------------------------------------------------------
 816
 817 void SAL_CALL ToolbarMenuEntryAcc::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& rxListener ) throw (RuntimeException)
 818 {
 819     const ::osl::MutexGuard aGuard( maMutex );
 820
 821     if( rxListener.is() )
 822     {
 823         EventListenerVector::iterator aIter = std::find(mxEventListeners.begin(), mxEventListeners.end(), rxListener);
 824         if (aIter != mxEventListeners.end())
 825             mxEventListeners.erase(aIter);
 826     }
 827 }
 828
 829 // -----------------------------------------------------------------------------
 830
 831 sal_Bool SAL_CALL ToolbarMenuEntryAcc::containsPoint( const awt::Point& aPoint ) throw (RuntimeException)
 832 {
 833     const awt::Rectangle    aRect( getBounds() );
 834     const Point             aSize( aRect.Width, aRect.Height );
 835     const Point             aNullPoint, aTestPoint( aPoint.X, aPoint.Y );
 836
 837     return Rectangle( aNullPoint, aSize ).IsInside( aTestPoint );
 838 }
 839
 840 // -----------------------------------------------------------------------------
 841
 842 Reference< XAccessible > SAL_CALL ToolbarMenuEntryAcc::getAccessibleAtPoint( const awt::Point& ) throw (RuntimeException)
 843 {
 844     Reference< XAccessible > xRet;
 845     return xRet;
 846 }
 847
 848 // -----------------------------------------------------------------------------
 849
 850 awt::Rectangle SAL_CALL ToolbarMenuEntryAcc::getBounds() throw (RuntimeException)
 851 {
 852     const SolarMutexGuard aSolarGuard;
 853     awt::Rectangle      aRet;
 854
 855     if( mpParent )
 856     {
 857         Rectangle   aRect( mpParent->maRect );
 858         Point       aOrigin;
 859         Rectangle   aParentRect( aOrigin, mpParent->mrMenu.GetOutputSizePixel() );
 860
 861         aRect.Intersection( aParentRect );
 862
 863         aRet.X = aRect.Left();
 864         aRet.Y = aRect.Top();
 865         aRet.Width = aRect.GetWidth();
 866         aRet.Height = aRect.GetHeight();
 867     }
 868
 869     return aRet;
 870 }
 871
 872 // -----------------------------------------------------------------------------
 873
 874 awt::Point SAL_CALL ToolbarMenuEntryAcc::getLocation() throw (RuntimeException)
 875 {
 876     const awt::Rectangle aRect( getBounds() );
 877     return awt::Point( aRect.X, aRect.Y );
 878 }
 879
 880 // -----------------------------------------------------------------------------
 881
 882 awt::Point SAL_CALL ToolbarMenuEntryAcc::getLocationOnScreen() throw (RuntimeException)
 883 {
 884     const SolarMutexGuard aSolarGuard;
 885     awt::Point aRet;
 886
 887     if( mpParent )
 888     {
 889         const Point aScreenPos( mpParent->mrMenu.OutputToAbsoluteScreenPixel( mpParent->maRect.TopLeft() ) );
 890
 891         aRet.X = aScreenPos.X();
 892         aRet.Y = aScreenPos.Y();
 893     }
 894
 895     return aRet;
 896 }
 897
 898 // -----------------------------------------------------------------------------
 899
 900 awt::Size SAL_CALL ToolbarMenuEntryAcc::getSize() throw (RuntimeException)
 901 {
 902     const awt::Rectangle aRect( getBounds() );
 903     awt::Size aRet;
 904
 905     aRet.Width = aRect.Width;
 906     aRet.Height = aRect.Height;
 907
 908     return aRet;
 909 }
 910
 911 // -----------------------------------------------------------------------------
 912
 913 void SAL_CALL ToolbarMenuEntryAcc::grabFocus() throw (RuntimeException)
 914 {
 915     // nothing to do
 916 }
 917
 918 // -----------------------------------------------------------------------------
 919
 920 Any SAL_CALL ToolbarMenuEntryAcc::getAccessibleKeyBinding() throw (RuntimeException)
 921 {
 922     return Any();
 923 }
 924
 925 // -----------------------------------------------------------------------------
 926
 927 sal_Int32 SAL_CALL ToolbarMenuEntryAcc::getForeground(  ) throw (RuntimeException)
 928 {
 929     return static_cast<sal_Int32>(Application::GetSettings().GetStyleSettings().GetMenuTextColor().GetColor());
 930 }
 931
 932 // -----------------------------------------------------------------------------
 933
 934 sal_Int32 SAL_CALL ToolbarMenuEntryAcc::getBackground(  )  throw (RuntimeException)
 935 {
 936     return static_cast<sal_Int32>(Application::GetSettings().GetStyleSettings().GetMenuColor().GetColor());
 937 }
 938
 939 }
 940
 941 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */