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