LCOV - code coverage report
Current view: top level - accessibility/source/standard - vclxaccessiblestatusbaritem.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 127 246 51.6 %
Date: 2014-11-03 Functions: 25 50 50.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             : #include <accessibility/standard/vclxaccessiblestatusbaritem.hxx>
      21             : #include <toolkit/helper/externallock.hxx>
      22             : #include <toolkit/helper/convert.hxx>
      23             : #include <accessibility/helper/characterattributeshelper.hxx>
      24             : 
      25             : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
      26             : #include <com/sun/star/accessibility/AccessibleRole.hpp>
      27             : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
      28             : #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
      29             : #include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp>
      30             : #include <cppuhelper/supportsservice.hxx>
      31             : #include <unotools/accessiblestatesethelper.hxx>
      32             : #include <unotools/accessiblerelationsethelper.hxx>
      33             : #include <vcl/svapp.hxx>
      34             : #include <vcl/unohelp2.hxx>
      35             : #include <vcl/status.hxx>
      36             : #include <vcl/controllayout.hxx>
      37             : #include <vcl/settings.hxx>
      38             : 
      39             : using namespace ::com::sun::star::accessibility;
      40             : using namespace ::com::sun::star::uno;
      41             : using namespace ::com::sun::star::lang;
      42             : using namespace ::com::sun::star::beans;
      43             : using namespace ::com::sun::star;
      44             : using namespace ::comphelper;
      45             : 
      46             : 
      47             : 
      48             : // class VCLXAccessibleStatusBarItem
      49             : 
      50             : 
      51           4 : VCLXAccessibleStatusBarItem::VCLXAccessibleStatusBarItem( StatusBar* pStatusBar, sal_uInt16 nItemId )
      52             :     :AccessibleTextHelper_BASE( new VCLExternalSolarLock() )
      53             :     ,m_pStatusBar( pStatusBar )
      54           4 :     ,m_nItemId( nItemId )
      55             : {
      56           4 :     m_pExternalLock = static_cast< VCLExternalSolarLock* >( getExternalLock() );
      57             : 
      58           4 :     m_sItemName = GetItemName();
      59           4 :     m_sItemText = GetItemText();
      60           4 :     m_bShowing  = IsShowing();
      61           4 : }
      62             : 
      63             : 
      64             : 
      65          12 : VCLXAccessibleStatusBarItem::~VCLXAccessibleStatusBarItem()
      66             : {
      67           4 :     delete m_pExternalLock;
      68           4 :     m_pExternalLock = NULL;
      69           8 : }
      70             : 
      71             : 
      72             : 
      73           4 : bool VCLXAccessibleStatusBarItem::IsShowing()
      74             : {
      75           4 :     bool bShowing = false;
      76             : 
      77           4 :     if ( m_pStatusBar )
      78           4 :         bShowing = m_pStatusBar->IsItemVisible( m_nItemId );
      79             : 
      80           4 :     return bShowing;
      81             : }
      82             : 
      83             : 
      84             : 
      85           0 : void VCLXAccessibleStatusBarItem::SetShowing( bool bShowing )
      86             : {
      87           0 :     if ( m_bShowing != bShowing )
      88             :     {
      89           0 :         Any aOldValue, aNewValue;
      90           0 :         if ( m_bShowing )
      91           0 :             aOldValue <<= AccessibleStateType::SHOWING;
      92             :         else
      93           0 :             aNewValue <<= AccessibleStateType::SHOWING;
      94           0 :         m_bShowing = bShowing;
      95           0 :         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
      96             :     }
      97           0 : }
      98             : 
      99             : 
     100             : 
     101           0 : void VCLXAccessibleStatusBarItem::SetItemName( const OUString& sItemName )
     102             : {
     103           0 :     if ( !m_sItemName.equals( sItemName ) )
     104             :     {
     105           0 :         Any aOldValue, aNewValue;
     106           0 :         aOldValue <<= m_sItemName;
     107           0 :         aNewValue <<= sItemName;
     108           0 :         m_sItemName = sItemName;
     109           0 :         NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue );
     110             :     }
     111           0 : }
     112             : 
     113             : 
     114             : 
     115           4 : OUString VCLXAccessibleStatusBarItem::GetItemName()
     116             : {
     117           4 :     OUString sName;
     118           4 :     if ( m_pStatusBar )
     119           4 :         sName = m_pStatusBar->GetAccessibleName( m_nItemId );
     120             : 
     121           4 :     return sName;
     122             : }
     123             : 
     124             : 
     125             : 
     126           0 : void VCLXAccessibleStatusBarItem::SetItemText( const OUString& sItemText )
     127             : {
     128           0 :     Any aOldValue, aNewValue;
     129           0 :     if ( implInitTextChangedEvent( m_sItemText, sItemText, aOldValue, aNewValue ) )
     130             :     {
     131           0 :         m_sItemText = sItemText;
     132           0 :         NotifyAccessibleEvent( AccessibleEventId::TEXT_CHANGED, aOldValue, aNewValue );
     133           0 :     }
     134           0 : }
     135             : 
     136             : 
     137             : 
     138         248 : OUString VCLXAccessibleStatusBarItem::GetItemText()
     139             : {
     140         248 :     OUString sText;
     141         496 :     ::vcl::ControlLayoutData aLayoutData;
     142         248 :     if ( m_pStatusBar )
     143             :     {
     144         248 :         Rectangle aItemRect = m_pStatusBar->GetItemRect( m_nItemId );
     145         248 :         m_pStatusBar->RecordLayoutData( &aLayoutData, aItemRect );
     146         248 :         sText = aLayoutData.m_aDisplayText;
     147             :     }
     148             : 
     149         496 :     return sText;
     150             : }
     151             : 
     152             : 
     153             : 
     154           0 : void VCLXAccessibleStatusBarItem::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
     155             : {
     156           0 :     rStateSet.AddState( AccessibleStateType::ENABLED );
     157           0 :     rStateSet.AddState( AccessibleStateType::SENSITIVE );
     158             : 
     159           0 :     rStateSet.AddState( AccessibleStateType::VISIBLE );
     160             : 
     161           0 :     if ( IsShowing() )
     162           0 :         rStateSet.AddState( AccessibleStateType::SHOWING );
     163           0 : }
     164             : 
     165             : 
     166             : // OCommonAccessibleComponent
     167             : 
     168             : 
     169           2 : awt::Rectangle VCLXAccessibleStatusBarItem::implGetBounds() throw (RuntimeException)
     170             : {
     171           2 :     awt::Rectangle aBounds( 0, 0, 0, 0 );
     172             : 
     173           2 :     if ( m_pStatusBar )
     174           2 :         aBounds = AWTRectangle( m_pStatusBar->GetItemRect( m_nItemId ) );
     175             : 
     176           2 :     return aBounds;
     177             : }
     178             : 
     179             : 
     180             : // OCommonAccessibleText
     181             : 
     182             : 
     183         242 : OUString VCLXAccessibleStatusBarItem::implGetText()
     184             : {
     185         242 :     return GetItemText();
     186             : }
     187             : 
     188             : 
     189             : 
     190           0 : lang::Locale VCLXAccessibleStatusBarItem::implGetLocale()
     191             : {
     192           0 :     return Application::GetSettings().GetLanguageTag().getLocale();
     193             : }
     194             : 
     195             : 
     196             : 
     197           0 : void VCLXAccessibleStatusBarItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
     198             : {
     199           0 :     nStartIndex = 0;
     200           0 :     nEndIndex = 0;
     201           0 : }
     202             : 
     203             : 
     204             : // XInterface
     205             : 
     206             : 
     207         192 : IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleStatusBarItem, AccessibleTextHelper_BASE, VCLXAccessibleStatusBarItem_BASE )
     208             : 
     209             : 
     210             : // XTypeProvider
     211             : 
     212             : 
     213           0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleStatusBarItem, AccessibleTextHelper_BASE, VCLXAccessibleStatusBarItem_BASE )
     214             : 
     215             : 
     216             : // XComponent
     217             : 
     218             : 
     219           4 : void VCLXAccessibleStatusBarItem::disposing()
     220             : {
     221           4 :     AccessibleTextHelper_BASE::disposing();
     222             : 
     223           4 :     m_pStatusBar = NULL;
     224           4 :     m_sItemName = OUString();
     225           4 :     m_sItemText = OUString();
     226           4 : }
     227             : 
     228             : 
     229             : // XServiceInfo
     230             : 
     231             : 
     232           2 : OUString VCLXAccessibleStatusBarItem::getImplementationName() throw (RuntimeException, std::exception)
     233             : {
     234           2 :     return OUString( "com.sun.star.comp.toolkit.AccessibleStatusBarItem" );
     235             : }
     236             : 
     237             : 
     238             : 
     239           0 : sal_Bool VCLXAccessibleStatusBarItem::supportsService( const OUString& rServiceName ) throw (RuntimeException, std::exception)
     240             : {
     241           0 :     return cppu::supportsService(this, rServiceName);
     242             : }
     243             : 
     244             : 
     245             : 
     246           0 : Sequence< OUString > VCLXAccessibleStatusBarItem::getSupportedServiceNames() throw (RuntimeException, std::exception)
     247             : {
     248           0 :     Sequence< OUString > aNames(1);
     249           0 :     aNames[0] = "com.sun.star.awt.AccessibleStatusBarItem";
     250           0 :     return aNames;
     251             : }
     252             : 
     253             : 
     254             : // XAccessible
     255             : 
     256             : 
     257           0 : Reference< XAccessibleContext > VCLXAccessibleStatusBarItem::getAccessibleContext(  ) throw (RuntimeException, std::exception)
     258             : {
     259           0 :     OExternalLockGuard aGuard( this );
     260             : 
     261           0 :     return this;
     262             : }
     263             : 
     264             : 
     265             : // XAccessibleContext
     266             : 
     267             : 
     268           0 : sal_Int32 VCLXAccessibleStatusBarItem::getAccessibleChildCount() throw (RuntimeException, std::exception)
     269             : {
     270           0 :     OExternalLockGuard aGuard( this );
     271             : 
     272           0 :     return 0;
     273             : }
     274             : 
     275             : 
     276             : 
     277           0 : Reference< XAccessible > VCLXAccessibleStatusBarItem::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     278             : {
     279           0 :     OExternalLockGuard aGuard( this );
     280             : 
     281           0 :     if ( i < 0 || i >= getAccessibleChildCount() )
     282           0 :         throw IndexOutOfBoundsException();
     283             : 
     284           0 :     return Reference< XAccessible >();
     285             : }
     286             : 
     287             : 
     288             : 
     289           6 : Reference< XAccessible > VCLXAccessibleStatusBarItem::getAccessibleParent(  ) throw (RuntimeException, std::exception)
     290             : {
     291           6 :     OExternalLockGuard aGuard( this );
     292             : 
     293           6 :     Reference< XAccessible > xParent;
     294           6 :     if ( m_pStatusBar )
     295           6 :         xParent = m_pStatusBar->GetAccessible();
     296             : 
     297           6 :     return xParent;
     298             : }
     299             : 
     300             : 
     301             : 
     302           0 : sal_Int32 VCLXAccessibleStatusBarItem::getAccessibleIndexInParent(  ) throw (RuntimeException, std::exception)
     303             : {
     304           0 :     OExternalLockGuard aGuard( this );
     305             : 
     306           0 :     sal_Int32 nIndexInParent = -1;
     307           0 :     if ( m_pStatusBar )
     308           0 :         nIndexInParent = m_pStatusBar->GetItemPos( m_nItemId );
     309             : 
     310           0 :     return nIndexInParent;
     311             : }
     312             : 
     313             : 
     314             : 
     315           0 : sal_Int16 VCLXAccessibleStatusBarItem::getAccessibleRole(  ) throw (RuntimeException, std::exception)
     316             : {
     317           0 :     OExternalLockGuard aGuard( this );
     318             : 
     319           0 :     return AccessibleRole::LABEL;
     320             : }
     321             : 
     322             : 
     323             : 
     324           0 : OUString VCLXAccessibleStatusBarItem::getAccessibleDescription(  ) throw (RuntimeException, std::exception)
     325             : {
     326           0 :     OExternalLockGuard aGuard( this );
     327             : 
     328           0 :     OUString sDescription;
     329           0 :     if ( m_pStatusBar )
     330           0 :         sDescription = m_pStatusBar->GetHelpText( m_nItemId );
     331             : 
     332           0 :     return sDescription;
     333             : }
     334             : 
     335             : 
     336             : 
     337           0 : OUString VCLXAccessibleStatusBarItem::getAccessibleName(  ) throw (RuntimeException, std::exception)
     338             : {
     339           0 :     OExternalLockGuard aGuard( this );
     340             : 
     341           0 :     return GetItemName();
     342             : }
     343             : 
     344             : 
     345             : 
     346           0 : Reference< XAccessibleRelationSet > VCLXAccessibleStatusBarItem::getAccessibleRelationSet(  ) throw (RuntimeException, std::exception)
     347             : {
     348           0 :     OExternalLockGuard aGuard( this );
     349             : 
     350           0 :     utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
     351           0 :     Reference< XAccessibleRelationSet > xSet = pRelationSetHelper;
     352           0 :     return xSet;
     353             : }
     354             : 
     355             : 
     356             : 
     357           0 : Reference< XAccessibleStateSet > VCLXAccessibleStatusBarItem::getAccessibleStateSet(  ) throw (RuntimeException, std::exception)
     358             : {
     359           0 :     OExternalLockGuard aGuard( this );
     360             : 
     361           0 :     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
     362           0 :     Reference< XAccessibleStateSet > xSet = pStateSetHelper;
     363             : 
     364           0 :     if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
     365             :     {
     366           0 :         FillAccessibleStateSet( *pStateSetHelper );
     367             :     }
     368             :     else
     369             :     {
     370           0 :         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
     371             :     }
     372             : 
     373           0 :     return xSet;
     374             : }
     375             : 
     376             : 
     377             : 
     378           0 : Locale VCLXAccessibleStatusBarItem::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException, std::exception)
     379             : {
     380           0 :     OExternalLockGuard aGuard( this );
     381             : 
     382           0 :     return Application::GetSettings().GetLanguageTag().getLocale();
     383             : }
     384             : 
     385             : 
     386             : // XAccessibleComponent
     387             : 
     388             : 
     389           0 : Reference< XAccessible > VCLXAccessibleStatusBarItem::getAccessibleAtPoint( const awt::Point& ) throw (RuntimeException, std::exception)
     390             : {
     391           0 :     OExternalLockGuard aGuard( this );
     392             : 
     393           0 :     return Reference< XAccessible >();
     394             : }
     395             : 
     396             : 
     397             : 
     398           0 : void VCLXAccessibleStatusBarItem::grabFocus(  ) throw (RuntimeException, std::exception)
     399             : {
     400             :     // no focus for status bar items
     401           0 : }
     402             : 
     403             : 
     404             : 
     405           2 : sal_Int32 VCLXAccessibleStatusBarItem::getForeground(   ) throw (RuntimeException, std::exception)
     406             : {
     407           2 :     OExternalLockGuard aGuard( this );
     408             : 
     409           2 :     sal_Int32 nColor = 0;
     410           4 :     Reference< XAccessible > xParent = getAccessibleParent();
     411           2 :     if ( xParent.is() )
     412             :     {
     413           2 :         Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
     414           2 :         if ( xParentComp.is() )
     415           2 :             nColor = xParentComp->getForeground();
     416             :     }
     417             : 
     418           4 :     return nColor;
     419             : }
     420             : 
     421             : 
     422             : 
     423           2 : sal_Int32 VCLXAccessibleStatusBarItem::getBackground(  ) throw (RuntimeException, std::exception)
     424             : {
     425           2 :     OExternalLockGuard aGuard( this );
     426             : 
     427           2 :     sal_Int32 nColor = 0;
     428           4 :     Reference< XAccessible > xParent = getAccessibleParent();
     429           2 :     if ( xParent.is() )
     430             :     {
     431           2 :         Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
     432           2 :         if ( xParentComp.is() )
     433           2 :             nColor = xParentComp->getBackground();
     434             :     }
     435             : 
     436           4 :     return nColor;
     437             : }
     438             : 
     439             : 
     440             : // XAccessibleExtendedComponent
     441             : 
     442             : 
     443           2 : Reference< awt::XFont > VCLXAccessibleStatusBarItem::getFont(  ) throw (RuntimeException, std::exception)
     444             : {
     445           2 :     OExternalLockGuard aGuard( this );
     446             : 
     447           2 :     Reference< awt::XFont > xFont;
     448           4 :     Reference< XAccessible > xParent = getAccessibleParent();
     449           2 :     if ( xParent.is() )
     450             :     {
     451           2 :         Reference< XAccessibleExtendedComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
     452           2 :         if ( xParentComp.is() )
     453           2 :             xFont = xParentComp->getFont();
     454             :     }
     455             : 
     456           4 :     return xFont;
     457             : }
     458             : 
     459             : 
     460             : 
     461           2 : OUString VCLXAccessibleStatusBarItem::getTitledBorderText(  ) throw (RuntimeException, std::exception)
     462             : {
     463           2 :     OExternalLockGuard aGuard( this );
     464             : 
     465           2 :     return GetItemText();
     466             : }
     467             : 
     468             : 
     469             : 
     470           2 : OUString VCLXAccessibleStatusBarItem::getToolTipText(  ) throw (RuntimeException, std::exception)
     471             : {
     472           2 :     OExternalLockGuard aGuard( this );
     473             : 
     474           2 :     return OUString();
     475             : }
     476             : 
     477             : 
     478             : // XAccessibleText
     479             : 
     480             : 
     481           0 : sal_Int32 VCLXAccessibleStatusBarItem::getCaretPosition() throw (RuntimeException, std::exception)
     482             : {
     483           0 :     OExternalLockGuard aGuard( this );
     484             : 
     485           0 :     return -1;
     486             : }
     487             : 
     488             : 
     489             : 
     490           6 : sal_Bool VCLXAccessibleStatusBarItem::setCaretPosition( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     491             : {
     492           6 :     OExternalLockGuard aGuard( this );
     493             : 
     494           6 :     if ( !implIsValidRange( nIndex, nIndex, implGetText().getLength() ) )
     495           4 :         throw IndexOutOfBoundsException();
     496             : 
     497           6 :     return false;
     498             : }
     499             : 
     500             : 
     501             : 
     502           6 : Sequence< PropertyValue > VCLXAccessibleStatusBarItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& aRequestedAttributes ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     503             : {
     504           6 :     OExternalLockGuard aGuard( this );
     505             : 
     506           6 :     Sequence< PropertyValue > aValues;
     507          12 :     OUString sText( implGetText() );
     508             : 
     509           6 :     if ( !implIsValidIndex( nIndex, sText.getLength() ) )
     510           4 :         throw IndexOutOfBoundsException();
     511             : 
     512           2 :     if ( m_pStatusBar )
     513             :     {
     514           2 :         vcl::Font aFont = m_pStatusBar->GetFont();
     515           2 :         sal_Int32 nBackColor = getBackground();
     516           2 :         sal_Int32 nColor = getForeground();
     517           4 :         aValues = CharacterAttributesHelper( aFont, nBackColor, nColor )
     518           4 :             .GetCharacterAttributes( aRequestedAttributes );
     519             :     }
     520             : 
     521           8 :     return aValues;
     522             : }
     523             : 
     524             : 
     525             : 
     526          84 : awt::Rectangle VCLXAccessibleStatusBarItem::getCharacterBounds( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     527             : {
     528          84 :     OExternalLockGuard aGuard( this );
     529             : 
     530          84 :     if ( !implIsValidIndex( nIndex, implGetText().getLength() ) )
     531           4 :         throw IndexOutOfBoundsException();
     532             : 
     533          80 :     awt::Rectangle aBounds( 0, 0, 0, 0 );
     534          80 :     if ( m_pStatusBar )
     535             :     {
     536          80 :         ::vcl::ControlLayoutData aLayoutData;
     537          80 :         Rectangle aItemRect = m_pStatusBar->GetItemRect( m_nItemId );
     538          80 :         m_pStatusBar->RecordLayoutData( &aLayoutData, aItemRect );
     539          80 :         Rectangle aCharRect = aLayoutData.GetCharacterBounds( nIndex );
     540          80 :         aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() );
     541          80 :         aBounds = AWTRectangle( aCharRect );
     542             :     }
     543             : 
     544          84 :     return aBounds;
     545             : }
     546             : 
     547             : 
     548             : 
     549          82 : sal_Int32 VCLXAccessibleStatusBarItem::getIndexAtPoint( const awt::Point& aPoint ) throw (RuntimeException, std::exception)
     550             : {
     551          82 :     OExternalLockGuard aGuard( this );
     552             : 
     553          82 :     sal_Int32 nIndex = -1;
     554          82 :     if ( m_pStatusBar )
     555             :     {
     556          82 :         ::vcl::ControlLayoutData aLayoutData;
     557          82 :         Rectangle aItemRect = m_pStatusBar->GetItemRect( m_nItemId );
     558          82 :         m_pStatusBar->RecordLayoutData( &aLayoutData, aItemRect );
     559          82 :         Point aPnt( VCLPoint( aPoint ) );
     560          82 :         aPnt += aItemRect.TopLeft();
     561          82 :         nIndex = aLayoutData.GetIndexForPoint( aPnt );
     562             :     }
     563             : 
     564          82 :     return nIndex;
     565             : }
     566             : 
     567             : 
     568             : 
     569           0 : sal_Bool VCLXAccessibleStatusBarItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     570             : {
     571           0 :     OExternalLockGuard aGuard( this );
     572             : 
     573           0 :     if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
     574           0 :         throw IndexOutOfBoundsException();
     575             : 
     576           0 :     return false;
     577             : }
     578             : 
     579             : 
     580             : 
     581           0 : sal_Bool VCLXAccessibleStatusBarItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     582             : {
     583           0 :     OExternalLockGuard aGuard( this );
     584             : 
     585           0 :     bool bReturn = false;
     586             : 
     587           0 :     if ( m_pStatusBar )
     588             :     {
     589           0 :         Reference< datatransfer::clipboard::XClipboard > xClipboard = m_pStatusBar->GetClipboard();
     590           0 :         if ( xClipboard.is() )
     591             :         {
     592           0 :             OUString sText( getTextRange( nStartIndex, nEndIndex ) );
     593             : 
     594           0 :             ::vcl::unohelper::TextDataObject* pDataObj = new ::vcl::unohelper::TextDataObject( sText );
     595           0 :             const sal_uInt32 nRef = Application::ReleaseSolarMutex();
     596           0 :             xClipboard->setContents( pDataObj, NULL );
     597             : 
     598           0 :             Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY );
     599           0 :             if( xFlushableClipboard.is() )
     600           0 :                 xFlushableClipboard->flushClipboard();
     601             : 
     602           0 :             Application::AcquireSolarMutex( nRef );
     603             : 
     604           0 :             bReturn = true;
     605           0 :         }
     606             :     }
     607             : 
     608           0 :     return bReturn;
     609          60 : }
     610             : 
     611             : 
     612             : 
     613             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10