LCOV - code coverage report
Current view: top level - accessibility/source/standard - vclxaccessibleedit.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 235 0.0 %
Date: 2014-04-14 Functions: 0 45 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             : #include <accessibility/standard/vclxaccessibleedit.hxx>
      21             : 
      22             : #include <toolkit/awt/vclxwindows.hxx>
      23             : #include <toolkit/helper/convert.hxx>
      24             : #include <accessibility/helper/accresmgr.hxx>
      25             : #include <accessibility/helper/accessiblestrings.hrc>
      26             : 
      27             : #include <unotools/accessiblestatesethelper.hxx>
      28             : #include <unotools/accessiblerelationsethelper.hxx>
      29             : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
      30             : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
      31             : #include <com/sun/star/accessibility/AccessibleRole.hpp>
      32             : #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
      33             : #include <cppuhelper/typeprovider.hxx>
      34             : #include <comphelper/sequence.hxx>
      35             : #include <comphelper/string.hxx>
      36             : #include <vcl/svapp.hxx>
      37             : #include <vcl/window.hxx>
      38             : #include <vcl/edit.hxx>
      39             : #include <sot/exchange.hxx>
      40             : #include <sot/formats.hxx>
      41             : 
      42             : #include <algorithm>
      43             : 
      44             : using namespace ::com::sun::star;
      45             : using namespace ::com::sun::star::uno;
      46             : using namespace ::com::sun::star::lang;
      47             : using namespace ::com::sun::star::beans;
      48             : using namespace ::com::sun::star::accessibility;
      49             : using namespace ::comphelper;
      50             : 
      51             : 
      52             : 
      53             : // VCLXAccessibleEdit
      54             : 
      55             : 
      56           0 : VCLXAccessibleEdit::VCLXAccessibleEdit( VCLXWindow* pVCLWindow )
      57           0 :     :VCLXAccessibleTextComponent( pVCLWindow )
      58             : {
      59           0 :     m_nSelectionStart = getSelectionStart();
      60           0 :     m_nCaretPosition = getCaretPosition();
      61           0 : }
      62             : 
      63             : 
      64             : 
      65           0 : VCLXAccessibleEdit::~VCLXAccessibleEdit()
      66             : {
      67           0 : }
      68             : 
      69             : 
      70             : 
      71           0 : void VCLXAccessibleEdit::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
      72             : {
      73           0 :     switch ( rVclWindowEvent.GetId() )
      74             :     {
      75             :         case VCLEVENT_EDIT_MODIFY:
      76             :         {
      77           0 :             SetText( implGetText() );
      78             :         }
      79           0 :         break;
      80             :         case VCLEVENT_EDIT_CARETCHANGED:
      81             :         {
      82           0 :             sal_Int32 nOldCaretPosition = m_nCaretPosition;
      83           0 :             m_nCaretPosition = getCaretPosition();
      84             : 
      85           0 :             Window* pWindow = GetWindow();
      86           0 :             if (pWindow && pWindow->HasChildPathFocus())
      87             :             {
      88           0 :                 if (m_nCaretPosition != nOldCaretPosition)
      89             :                 {
      90           0 :                     Any aOldValue, aNewValue;
      91           0 :                     aOldValue <<= nOldCaretPosition;
      92           0 :                     aNewValue <<= m_nCaretPosition;
      93           0 :                     NotifyAccessibleEvent( AccessibleEventId::CARET_CHANGED, aOldValue, aNewValue );
      94             :                 }
      95             :             }
      96             :         }
      97           0 :         break;
      98             :         case VCLEVENT_EDIT_SELECTIONCHANGED:
      99             :         {
     100           0 :             Window* pWindow = GetWindow();
     101           0 :             if (pWindow && pWindow->HasChildPathFocus())
     102             :             {
     103           0 :                 NotifyAccessibleEvent( AccessibleEventId::TEXT_SELECTION_CHANGED, Any(), Any() );
     104             :             }
     105             :         }
     106           0 :         break;
     107             :         default:
     108           0 :             VCLXAccessibleTextComponent::ProcessWindowEvent( rVclWindowEvent );
     109             :    }
     110           0 : }
     111             : 
     112             : 
     113             : 
     114           0 : void VCLXAccessibleEdit::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
     115             : {
     116           0 :     VCLXAccessibleTextComponent::FillAccessibleStateSet( rStateSet );
     117             : 
     118           0 :     VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() );
     119           0 :     if ( pVCLXEdit )
     120             :     {
     121           0 :         rStateSet.AddState( AccessibleStateType::FOCUSABLE );
     122           0 :         rStateSet.AddState( AccessibleStateType::SINGLE_LINE );
     123           0 :         if ( pVCLXEdit->isEditable() )
     124           0 :             rStateSet.AddState( AccessibleStateType::EDITABLE );
     125             :     }
     126           0 : }
     127             : 
     128             : 
     129             : // OCommonAccessibleText
     130             : 
     131             : 
     132           0 : OUString VCLXAccessibleEdit::implGetText()
     133             : {
     134           0 :     OUString aText;
     135             : 
     136           0 :     Edit* pEdit = static_cast< Edit* >( GetWindow() );
     137           0 :     if ( pEdit )
     138             :     {
     139           0 :         aText = OutputDevice::GetNonMnemonicString( pEdit->GetText() );
     140             : 
     141           0 :         if ( getAccessibleRole() == AccessibleRole::PASSWORD_TEXT )
     142             :         {
     143           0 :             sal_Unicode cEchoChar = pEdit->GetEchoChar();
     144           0 :             if ( !cEchoChar )
     145           0 :                 cEchoChar = '*';
     146           0 :             OUStringBuffer sTmp;
     147           0 :             aText = comphelper::string::padToLength(sTmp, aText.getLength(),
     148           0 :                 cEchoChar).makeStringAndClear();
     149             :         }
     150             :     }
     151             : 
     152           0 :     return aText;
     153             : }
     154             : 
     155             : 
     156             : 
     157           0 : void VCLXAccessibleEdit::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
     158             : {
     159           0 :     awt::Selection aSelection;
     160           0 :     VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() );
     161           0 :     if ( pVCLXEdit )
     162           0 :         aSelection = pVCLXEdit->getSelection();
     163             : 
     164           0 :     nStartIndex = aSelection.Min;
     165           0 :     nEndIndex = aSelection.Max;
     166           0 : }
     167             : 
     168             : 
     169             : // XInterface
     170             : 
     171             : 
     172           0 : IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleEdit, VCLXAccessibleTextComponent, VCLXAccessibleEdit_BASE )
     173             : 
     174             : 
     175             : // XTypeProvider
     176             : 
     177             : 
     178           0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleEdit, VCLXAccessibleTextComponent, VCLXAccessibleEdit_BASE )
     179             : 
     180             : 
     181             : // XServiceInfo
     182             : 
     183             : 
     184           0 : OUString VCLXAccessibleEdit::getImplementationName() throw (RuntimeException, std::exception)
     185             : {
     186           0 :     return OUString( "com.sun.star.comp.toolkit.AccessibleEdit" );
     187             : }
     188             : 
     189             : 
     190             : 
     191           0 : Sequence< OUString > VCLXAccessibleEdit::getSupportedServiceNames() throw (RuntimeException, std::exception)
     192             : {
     193           0 :     Sequence< OUString > aNames(1);
     194           0 :     aNames[0] = "com.sun.star.awt.AccessibleEdit";
     195           0 :     return aNames;
     196             : }
     197             : 
     198             : 
     199             : // XAccessibleContext
     200             : 
     201             : 
     202           0 : sal_Int32 VCLXAccessibleEdit::getAccessibleChildCount() throw (RuntimeException, std::exception)
     203             : {
     204           0 :     OExternalLockGuard aGuard( this );
     205             : 
     206           0 :     return 0;
     207             : }
     208             : 
     209             : 
     210             : 
     211           0 : Reference< XAccessible > VCLXAccessibleEdit::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     212             : {
     213           0 :     OExternalLockGuard aGuard( this );
     214             : 
     215           0 :     if ( i < 0 || i >= getAccessibleChildCount() )
     216           0 :         throw IndexOutOfBoundsException();
     217             : 
     218           0 :     return Reference< XAccessible >();
     219             : }
     220             : 
     221             : 
     222             : 
     223           0 : sal_Int16 VCLXAccessibleEdit::getAccessibleRole(  ) throw (RuntimeException, std::exception)
     224             : {
     225           0 :     OExternalLockGuard aGuard( this );
     226             : 
     227             :     sal_Int16 nRole;
     228           0 :     Edit* pEdit = static_cast< Edit* >( GetWindow() );
     229           0 :     if ( pEdit && ( ( pEdit->GetStyle() & WB_PASSWORD ) || pEdit->GetEchoChar() ) )
     230           0 :         nRole = AccessibleRole::PASSWORD_TEXT;
     231             :     else
     232           0 :         nRole = AccessibleRole::TEXT;
     233             : 
     234           0 :     return nRole;
     235             : }
     236             : 
     237             : 
     238             : // XAccessibleAction
     239             : 
     240             : 
     241           0 : sal_Int32 VCLXAccessibleEdit::getAccessibleActionCount( ) throw (RuntimeException, std::exception)
     242             : {
     243           0 :     OExternalLockGuard aGuard( this );
     244             : 
     245             :     // There is one action: activate
     246           0 :     return 1;
     247             : }
     248             : 
     249             : 
     250             : 
     251           0 : sal_Bool VCLXAccessibleEdit::doAccessibleAction ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     252             : {
     253           0 :     OExternalLockGuard aGuard( this );
     254             : 
     255           0 :     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
     256           0 :         throw IndexOutOfBoundsException();
     257             : 
     258           0 :     sal_Bool bDoAction = sal_False;
     259           0 :     Window* pWindow = GetWindow();
     260           0 :     if ( pWindow )
     261             :     {
     262           0 :         pWindow->GrabFocus();
     263           0 :         bDoAction = sal_True;
     264             :     }
     265             : 
     266           0 :     return bDoAction;
     267             : }
     268             : 
     269             : 
     270             : 
     271           0 : OUString VCLXAccessibleEdit::getAccessibleActionDescription ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     272             : {
     273           0 :     OExternalLockGuard aGuard( this );
     274             : 
     275           0 :     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
     276           0 :         throw IndexOutOfBoundsException();
     277             : 
     278           0 :     static const OUString sAction( "activate" );
     279           0 :     return sAction;
     280             : }
     281             : 
     282             : 
     283             : 
     284           0 : Reference< XAccessibleKeyBinding > VCLXAccessibleEdit::getAccessibleActionKeyBinding( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     285             : {
     286           0 :     OExternalLockGuard aGuard( this );
     287             : 
     288           0 :     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
     289           0 :         throw IndexOutOfBoundsException();
     290             : 
     291           0 :     return Reference< XAccessibleKeyBinding >();
     292             : }
     293             : 
     294             : 
     295             : // XAccessibleText
     296             : 
     297             : 
     298           0 : sal_Int32 VCLXAccessibleEdit::getCaretPosition(  ) throw (RuntimeException, std::exception)
     299             : {
     300           0 :     return getSelectionEnd();
     301             : }
     302             : 
     303             : 
     304             : 
     305           0 : sal_Bool VCLXAccessibleEdit::setCaretPosition( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     306             : {
     307           0 :     return setSelection( nIndex, nIndex );
     308             : }
     309             : 
     310             : 
     311             : 
     312           0 : sal_Unicode VCLXAccessibleEdit::getCharacter( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     313             : {
     314           0 :     OExternalLockGuard aGuard( this );
     315             : 
     316           0 :     return VCLXAccessibleTextComponent::getCharacter( nIndex );
     317             : }
     318             : 
     319             : 
     320             : 
     321           0 : Sequence< PropertyValue > VCLXAccessibleEdit::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& aRequestedAttributes ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     322             : {
     323           0 :     OExternalLockGuard aGuard( this );
     324             : 
     325           0 :     return VCLXAccessibleTextComponent::getCharacterAttributes( nIndex, aRequestedAttributes );
     326             : }
     327             : 
     328             : 
     329             : 
     330           0 : awt::Rectangle VCLXAccessibleEdit::getCharacterBounds( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     331             : {
     332           0 :     OExternalLockGuard aGuard( this );
     333             : 
     334           0 :     awt::Rectangle aBounds( 0, 0, 0, 0 );
     335           0 :     sal_Int32 nLength = implGetText().getLength();
     336             : 
     337           0 :     if ( !implIsValidRange( nIndex, nIndex, nLength ) )
     338           0 :         throw IndexOutOfBoundsException();
     339             : 
     340           0 :     Control* pControl = static_cast< Control* >( GetWindow() );
     341           0 :     if ( pControl )
     342             :     {
     343           0 :         if ( nIndex == nLength )
     344             :         {
     345             :             // #108914# calculate virtual bounding rectangle
     346           0 :             for ( sal_Int32 i = 0; i < nLength; ++i )
     347             :             {
     348           0 :                 Rectangle aRect = pControl->GetCharacterBounds( i );
     349           0 :                 sal_Int32 nHeight = aRect.GetHeight();
     350           0 :                 if ( aBounds.Height < nHeight )
     351             :                 {
     352           0 :                     aBounds.Y = aRect.Top();
     353           0 :                     aBounds.Height = nHeight;
     354             :                 }
     355           0 :                 if ( i == nLength - 1 )
     356             :                 {
     357           0 :                     aBounds.X = aRect.Right() + 1;
     358           0 :                     aBounds.Width = 1;
     359             :                 }
     360             :             }
     361             :         }
     362             :         else
     363             :         {
     364           0 :             aBounds = AWTRectangle( pControl->GetCharacterBounds( nIndex ) );
     365             :         }
     366             :     }
     367             : 
     368           0 :     return aBounds;
     369             : }
     370             : 
     371             : 
     372             : 
     373           0 : sal_Int32 VCLXAccessibleEdit::getCharacterCount(  ) throw (RuntimeException, std::exception)
     374             : {
     375           0 :     OExternalLockGuard aGuard( this );
     376             : 
     377           0 :     return VCLXAccessibleTextComponent::getCharacterCount();
     378             : }
     379             : 
     380             : 
     381             : 
     382           0 : sal_Int32 VCLXAccessibleEdit::getIndexAtPoint( const awt::Point& aPoint ) throw (RuntimeException, std::exception)
     383             : {
     384           0 :     OExternalLockGuard aGuard( this );
     385             : 
     386           0 :     return VCLXAccessibleTextComponent::getIndexAtPoint( aPoint );
     387             : }
     388             : 
     389             : 
     390             : 
     391           0 : OUString VCLXAccessibleEdit::getSelectedText(  ) throw (RuntimeException, std::exception)
     392             : {
     393           0 :     OExternalLockGuard aGuard( this );
     394             : 
     395           0 :     return VCLXAccessibleTextComponent::getSelectedText();
     396             : }
     397             : 
     398             : 
     399             : 
     400           0 : sal_Int32 VCLXAccessibleEdit::getSelectionStart(  ) throw (RuntimeException, std::exception)
     401             : {
     402           0 :     OExternalLockGuard aGuard( this );
     403             : 
     404           0 :     return VCLXAccessibleTextComponent::getSelectionStart();
     405             : }
     406             : 
     407             : 
     408             : 
     409           0 : sal_Int32 VCLXAccessibleEdit::getSelectionEnd(  ) throw (RuntimeException, std::exception)
     410             : {
     411           0 :     OExternalLockGuard aGuard( this );
     412             : 
     413           0 :     return VCLXAccessibleTextComponent::getSelectionEnd();
     414             : }
     415             : 
     416             : 
     417             : 
     418           0 : sal_Bool VCLXAccessibleEdit::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     419             : {
     420           0 :     OExternalLockGuard aGuard( this );
     421             : 
     422           0 :     sal_Bool bReturn = sal_False;
     423           0 :     OUString sText( implGetText() );
     424             : 
     425           0 :     if ( !implIsValidRange( nStartIndex, nEndIndex, sText.getLength() ) )
     426           0 :         throw IndexOutOfBoundsException();
     427             : 
     428           0 :     VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() );
     429           0 :     Edit* pEdit = static_cast< Edit* >( GetWindow() );
     430           0 :     if ( pVCLXEdit && pEdit && pEdit->IsEnabled() )
     431             :     {
     432           0 :         pVCLXEdit->setSelection( awt::Selection( nStartIndex, nEndIndex ) );
     433           0 :         bReturn = sal_True;
     434             :     }
     435             : 
     436           0 :     return bReturn;
     437             : }
     438             : 
     439             : 
     440             : 
     441           0 : OUString VCLXAccessibleEdit::getText(  ) throw (RuntimeException, std::exception)
     442             : {
     443           0 :     OExternalLockGuard aGuard( this );
     444             : 
     445           0 :     return VCLXAccessibleTextComponent::getText();
     446             : }
     447             : 
     448             : 
     449             : 
     450           0 : OUString VCLXAccessibleEdit::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     451             : {
     452           0 :     OExternalLockGuard aGuard( this );
     453             : 
     454           0 :     return VCLXAccessibleTextComponent::getTextRange( nStartIndex, nEndIndex );
     455             : }
     456             : 
     457             : 
     458             : 
     459           0 : ::com::sun::star::accessibility::TextSegment VCLXAccessibleEdit::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException, std::exception)
     460             : {
     461           0 :     OExternalLockGuard aGuard( this );
     462             : 
     463           0 :     return VCLXAccessibleTextComponent::getTextAtIndex( nIndex, aTextType );
     464             : }
     465             : 
     466             : 
     467             : 
     468           0 : ::com::sun::star::accessibility::TextSegment VCLXAccessibleEdit::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException, std::exception)
     469             : {
     470           0 :     OExternalLockGuard aGuard( this );
     471             : 
     472           0 :     return VCLXAccessibleTextComponent::getTextBeforeIndex( nIndex, aTextType );
     473             : }
     474             : 
     475             : 
     476             : 
     477           0 : ::com::sun::star::accessibility::TextSegment VCLXAccessibleEdit::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException, std::exception)
     478             : {
     479           0 :     OExternalLockGuard aGuard( this );
     480             : 
     481           0 :     return VCLXAccessibleTextComponent::getTextBehindIndex( nIndex, aTextType );
     482             : }
     483             : 
     484             : 
     485             : 
     486           0 : sal_Bool VCLXAccessibleEdit::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     487             : {
     488           0 :     OExternalLockGuard aGuard( this );
     489             : 
     490           0 :     return VCLXAccessibleTextComponent::copyText( nStartIndex, nEndIndex );
     491             : }
     492             : 
     493             : 
     494             : // XAccessibleEditableText
     495             : 
     496             : 
     497           0 : sal_Bool VCLXAccessibleEdit::cutText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     498             : {
     499           0 :     OExternalLockGuard aGuard( this );
     500             : 
     501           0 :     return copyText( nStartIndex, nEndIndex ) && deleteText( nStartIndex, nEndIndex );
     502             : }
     503             : 
     504             : 
     505             : 
     506           0 : sal_Bool VCLXAccessibleEdit::pasteText( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     507             : {
     508           0 :     OExternalLockGuard aGuard( this );
     509             : 
     510           0 :     sal_Bool bReturn = sal_False;
     511             : 
     512           0 :     if ( GetWindow() )
     513             :     {
     514           0 :         Reference< datatransfer::clipboard::XClipboard > xClipboard = GetWindow()->GetClipboard();
     515           0 :         if ( xClipboard.is() )
     516             :         {
     517           0 :             const sal_uInt32 nRef = Application::ReleaseSolarMutex();
     518           0 :             Reference< datatransfer::XTransferable > xDataObj = xClipboard->getContents();
     519           0 :             Application::AcquireSolarMutex( nRef );
     520           0 :             if ( xDataObj.is() )
     521             :             {
     522           0 :                 datatransfer::DataFlavor aFlavor;
     523           0 :                 SotExchange::GetFormatDataFlavor( SOT_FORMAT_STRING, aFlavor );
     524           0 :                 if ( xDataObj->isDataFlavorSupported( aFlavor ) )
     525             :                 {
     526           0 :                     Any aData = xDataObj->getTransferData( aFlavor );
     527           0 :                     OUString sText;
     528           0 :                     aData >>= sText;
     529           0 :                     bReturn = replaceText( nIndex, nIndex, sText );
     530           0 :                 }
     531           0 :             }
     532           0 :         }
     533             :     }
     534             : 
     535           0 :     return bReturn;
     536             : }
     537             : 
     538             : 
     539             : 
     540           0 : sal_Bool VCLXAccessibleEdit::deleteText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     541             : {
     542           0 :     OExternalLockGuard aGuard( this );
     543             : 
     544           0 :     return replaceText( nStartIndex, nEndIndex, OUString() );
     545             : }
     546             : 
     547             : 
     548             : 
     549           0 : sal_Bool VCLXAccessibleEdit::insertText( const OUString& sText, sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     550             : {
     551           0 :     OExternalLockGuard aGuard( this );
     552             : 
     553           0 :     return replaceText( nIndex, nIndex, sText );
     554             : }
     555             : 
     556             : 
     557             : 
     558           0 : sal_Bool VCLXAccessibleEdit::replaceText( sal_Int32 nStartIndex, sal_Int32 nEndIndex, const OUString& sReplacement ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     559             : {
     560           0 :     OExternalLockGuard aGuard( this );
     561             : 
     562           0 :     sal_Bool bReturn = sal_False;
     563           0 :     OUString sText( implGetText() );
     564             : 
     565           0 :     if ( !implIsValidRange( nStartIndex, nEndIndex, sText.getLength() ) )
     566           0 :         throw IndexOutOfBoundsException();
     567             : 
     568           0 :     sal_Int32 nMinIndex = ::std::min( nStartIndex, nEndIndex );
     569           0 :     sal_Int32 nMaxIndex = ::std::max( nStartIndex, nEndIndex );
     570             : 
     571           0 :     VCLXEdit* pVCLXEdit = static_cast< VCLXEdit* >( GetVCLXWindow() );
     572           0 :     if ( pVCLXEdit && pVCLXEdit->isEditable() )
     573             :     {
     574           0 :         pVCLXEdit->setText( sText.replaceAt( nMinIndex, nMaxIndex - nMinIndex, sReplacement ) );
     575           0 :         sal_Int32 nIndex = nMinIndex + sReplacement.getLength();
     576           0 :         setSelection( nIndex, nIndex );
     577           0 :         bReturn = sal_True;
     578             :     }
     579             : 
     580           0 :     return bReturn;
     581             : }
     582             : 
     583             : 
     584             : 
     585           0 : sal_Bool VCLXAccessibleEdit::setAttributes( sal_Int32 nStartIndex, sal_Int32 nEndIndex, const Sequence<PropertyValue>& ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
     586             : {
     587           0 :     OExternalLockGuard aGuard( this );
     588             : 
     589           0 :     if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
     590           0 :         throw IndexOutOfBoundsException();
     591             : 
     592           0 :     return sal_False;   // attributes cannot be set for an edit
     593             : }
     594             : 
     595             : 
     596             : 
     597           0 : sal_Bool VCLXAccessibleEdit::setText( const OUString& sText ) throw (RuntimeException, std::exception)
     598             : {
     599           0 :     OExternalLockGuard aGuard( this );
     600             : 
     601           0 :     sal_Bool bSuccess = sal_False;
     602             :     try
     603             :     {
     604           0 :         bSuccess = replaceText( 0, implGetText().getLength(), sText );
     605             :     }
     606           0 :     catch( const IndexOutOfBoundsException& )
     607             :     {
     608             :         OSL_FAIL( "VCLXAccessibleText::setText: caught an exception!" );
     609             :     }
     610           0 :     return bSuccess;
     611             : }
     612             : 
     613             : 
     614             : 
     615             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10