LCOV - code coverage report
Current view: top level - svtools/source/control - toolbarmenuacc.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 401 0.0 %
Date: 2014-04-14 Functions: 0 66 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10