accessibility/source/standard/vclxaccessibletabpage.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: vclxaccessibletabpage.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_accessibility.hxx"
  33 #include <accessibility/standard/vclxaccessibletabpage.hxx>
  34 #include <toolkit/helper/externallock.hxx>
  35 #include <toolkit/helper/convert.hxx>
  36 #include <accessibility/helper/characterattributeshelper.hxx>
  37
  38 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  39 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  40 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  41 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
  42 #include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp>
  43
  44 #include <unotools/accessiblestatesethelper.hxx>
  45 #include <unotools/accessiblerelationsethelper.hxx>
  46 #include <vcl/svapp.hxx>
  47 #include <vcl/unohelp2.hxx>
  48 #include <vcl/tabctrl.hxx>
  49 #include <vcl/tabpage.hxx>
  50
  51 #include <memory>
  52
  53
  54 using namespace ::com::sun::star::accessibility;
  55 using namespace ::com::sun::star::uno;
  56 using namespace ::com::sun::star::lang;
  57 using namespace ::com::sun::star::beans;
  58 using namespace ::com::sun::star;
  59 using namespace ::comphelper;
  60
  61
  62 // -----------------------------------------------------------------------------
  63 // class VCLXAccessibleTabPage
  64 // -----------------------------------------------------------------------------
  65
  66 VCLXAccessibleTabPage::VCLXAccessibleTabPage( TabControl* pTabControl, sal_uInt16 nPageId )
  67     :AccessibleTextHelper_BASE( new VCLExternalSolarLock() )
  68     ,m_pTabControl( pTabControl )
  69     ,m_nPageId( nPageId )
  70 {
  71     m_pExternalLock = static_cast< VCLExternalSolarLock* >( getExternalLock() );
  72     m_bFocused  = IsFocused();
  73     m_bSelected = IsSelected();
  74     m_sPageText = GetPageText();
  75 }
  76
  77 // -----------------------------------------------------------------------------
  78
  79 VCLXAccessibleTabPage::~VCLXAccessibleTabPage()
  80 {
  81     delete m_pExternalLock;
  82     m_pExternalLock = NULL;
  83 }
  84
  85 // -----------------------------------------------------------------------------
  86
  87 bool VCLXAccessibleTabPage::IsFocused()
  88 {
  89     bool bFocused = false;
  90
  91     if ( m_pTabControl && m_pTabControl->HasFocus() && m_pTabControl->GetCurPageId() == m_nPageId )
  92         bFocused = true;
  93
  94     return bFocused;
  95 }
  96
  97 // -----------------------------------------------------------------------------
  98
  99 bool VCLXAccessibleTabPage::IsSelected()
 100 {
 101     bool bSelected = false;
 102
 103     if ( m_pTabControl && m_pTabControl->GetCurPageId() == m_nPageId )
 104         bSelected = true;
 105
 106     return bSelected;
 107 }
 108
 109 // -----------------------------------------------------------------------------
 110
 111 void VCLXAccessibleTabPage::SetFocused( bool bFocused )
 112 {
 113     if ( m_bFocused != bFocused )
 114     {
 115         Any aOldValue, aNewValue;
 116         if ( m_bFocused )
 117             aOldValue <<= AccessibleStateType::FOCUSED;
 118         else
 119             aNewValue <<= AccessibleStateType::FOCUSED;
 120         m_bFocused = bFocused;
 121         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 122     }
 123 }
 124
 125 // -----------------------------------------------------------------------------
 126
 127 void VCLXAccessibleTabPage::SetSelected( bool bSelected )
 128 {
 129     if ( m_bSelected != bSelected )
 130     {
 131         Any aOldValue, aNewValue;
 132         if ( m_bSelected )
 133             aOldValue <<= AccessibleStateType::SELECTED;
 134         else
 135             aNewValue <<= AccessibleStateType::SELECTED;
 136         m_bSelected = bSelected;
 137         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 138     }
 139 }
 140
 141 // -----------------------------------------------------------------------------
 142
 143 void VCLXAccessibleTabPage::SetPageText( const ::rtl::OUString& sPageText )
 144 {
 145     Any aOldValue, aNewValue;
 146     if ( OCommonAccessibleText::implInitTextChangedEvent( m_sPageText, sPageText, aOldValue, aNewValue ) )
 147     {
 148         Any aOldName, aNewName;
 149         aOldName <<= m_sPageText;
 150         aNewName <<= sPageText;
 151         m_sPageText = sPageText;
 152         NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldName, aNewName );
 153         NotifyAccessibleEvent( AccessibleEventId::TEXT_CHANGED, aOldValue, aNewValue );
 154     }
 155 }
 156
 157 // -----------------------------------------------------------------------------
 158
 159 ::rtl::OUString VCLXAccessibleTabPage::GetPageText()
 160 {
 161     ::rtl::OUString sText;
 162     if ( m_pTabControl )
 163         sText = OutputDevice::GetNonMnemonicString( m_pTabControl->GetPageText( m_nPageId ) );
 164
 165     return sText;
 166 }
 167
 168 // -----------------------------------------------------------------------------
 169
 170 void VCLXAccessibleTabPage::Update( bool bNew )
 171 {
 172     if ( m_pTabControl )
 173     {
 174         TabPage* pTabPage = m_pTabControl->GetTabPage( m_nPageId );
 175         if ( pTabPage )
 176         {
 177             Reference< XAccessible > xChild( pTabPage->GetAccessible( bNew ) );
 178             if ( xChild.is() )
 179             {
 180                 Any aOldValue, aNewValue;
 181                 if ( bNew )
 182                     aNewValue <<= xChild;
 183                 else
 184                     aOldValue <<= xChild;
 185                 NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 186             }
 187         }
 188     }
 189 }
 190
 191 // -----------------------------------------------------------------------------
 192
 193 void VCLXAccessibleTabPage::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 194 {
 195     rStateSet.AddState( AccessibleStateType::ENABLED );
 196     rStateSet.AddState( AccessibleStateType::SENSITIVE );
 197
 198     rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 199
 200     if ( IsFocused() )
 201         rStateSet.AddState( AccessibleStateType::FOCUSED );
 202
 203     rStateSet.AddState( AccessibleStateType::VISIBLE );
 204
 205     rStateSet.AddState( AccessibleStateType::SHOWING );
 206
 207     rStateSet.AddState( AccessibleStateType::SELECTABLE );
 208
 209     if ( IsSelected() )
 210         rStateSet.AddState( AccessibleStateType::SELECTED );
 211 }
 212
 213 // -----------------------------------------------------------------------------
 214 // OCommonAccessibleComponent
 215 // -----------------------------------------------------------------------------
 216
 217 awt::Rectangle VCLXAccessibleTabPage::implGetBounds() throw (RuntimeException)
 218 {
 219     awt::Rectangle aBounds( 0, 0, 0, 0 );
 220
 221     if ( m_pTabControl )
 222         aBounds = AWTRectangle( m_pTabControl->GetTabBounds( m_nPageId ) );
 223
 224     return aBounds;
 225 }
 226
 227 // -----------------------------------------------------------------------------
 228 // OCommonAccessibleText
 229 // -----------------------------------------------------------------------------
 230
 231 ::rtl::OUString VCLXAccessibleTabPage::implGetText()
 232 {
 233     return GetPageText();
 234 }
 235
 236 // -----------------------------------------------------------------------------
 237
 238 lang::Locale VCLXAccessibleTabPage::implGetLocale()
 239 {
 240     return Application::GetSettings().GetLocale();
 241 }
 242
 243 // -----------------------------------------------------------------------------
 244
 245 void VCLXAccessibleTabPage::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 246 {
 247     nStartIndex = 0;
 248     nEndIndex = 0;
 249 }
 250
 251 // -----------------------------------------------------------------------------
 252 // XInterface
 253 // -----------------------------------------------------------------------------
 254
 255 IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleTabPage, AccessibleTextHelper_BASE, VCLXAccessibleTabPage_BASE )
 256
 257 // -----------------------------------------------------------------------------
 258 // XTypeProvider
 259 // -----------------------------------------------------------------------------
 260
 261 IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleTabPage, AccessibleTextHelper_BASE, VCLXAccessibleTabPage_BASE )
 262
 263 // -----------------------------------------------------------------------------
 264 // XComponent
 265 // -----------------------------------------------------------------------------
 266
 267 void VCLXAccessibleTabPage::disposing()
 268 {
 269     AccessibleTextHelper_BASE::disposing();
 270
 271     m_pTabControl = NULL;
 272     m_sPageText = ::rtl::OUString();
 273 }
 274
 275 // -----------------------------------------------------------------------------
 276 // XServiceInfo
 277 // -----------------------------------------------------------------------------
 278
 279 ::rtl::OUString VCLXAccessibleTabPage::getImplementationName() throw (RuntimeException)
 280 {
 281     return ::rtl::OUString::createFromAscii( "com.sun.star.comp.toolkit.AccessibleTabPage" );
 282 }
 283
 284 // -----------------------------------------------------------------------------
 285
 286 sal_Bool VCLXAccessibleTabPage::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException)
 287 {
 288     Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() );
 289     const ::rtl::OUString* pNames = aNames.getConstArray();
 290     const ::rtl::OUString* pEnd = pNames + aNames.getLength();
 291     for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
 292         ;
 293
 294     return pNames != pEnd;
 295 }
 296
 297 // -----------------------------------------------------------------------------
 298
 299 Sequence< ::rtl::OUString > VCLXAccessibleTabPage::getSupportedServiceNames() throw (RuntimeException)
 300 {
 301     Sequence< ::rtl::OUString > aNames(1);
 302     aNames[0] = ::rtl::OUString::createFromAscii( "com.sun.star.awt.AccessibleTabPage" );
 303     return aNames;
 304 }
 305
 306 // -----------------------------------------------------------------------------
 307 // XAccessible
 308 // -----------------------------------------------------------------------------
 309
 310 Reference< XAccessibleContext > VCLXAccessibleTabPage::getAccessibleContext(  ) throw (RuntimeException)
 311 {
 312     OExternalLockGuard aGuard( this );
 313
 314     return this;
 315 }
 316
 317 // -----------------------------------------------------------------------------
 318 // XAccessibleContext
 319 // -----------------------------------------------------------------------------
 320
 321 sal_Int32 VCLXAccessibleTabPage::getAccessibleChildCount() throw (RuntimeException)
 322 {
 323     OExternalLockGuard aGuard( this );
 324
 325     sal_Int32 nCount = 0;
 326     if ( m_pTabControl )
 327     {
 328         TabPage* pTabPage = m_pTabControl->GetTabPage( m_nPageId );
 329         if ( pTabPage && pTabPage->IsVisible() )
 330             nCount = 1;
 331     }
 332
 333     return nCount;
 334 }
 335
 336 // -----------------------------------------------------------------------------
 337
 338 Reference< XAccessible > VCLXAccessibleTabPage::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 339 {
 340     OExternalLockGuard aGuard( this );
 341
 342     if ( i < 0 || i >= getAccessibleChildCount() )
 343         throw IndexOutOfBoundsException();
 344
 345     Reference< XAccessible > xChild;
 346     if ( m_pTabControl )
 347     {
 348         TabPage* pTabPage = m_pTabControl->GetTabPage( m_nPageId );
 349         if ( pTabPage && pTabPage->IsVisible() )
 350             xChild = pTabPage->GetAccessible();
 351     }
 352
 353     return xChild;
 354 }
 355
 356 // -----------------------------------------------------------------------------
 357
 358 Reference< XAccessible > VCLXAccessibleTabPage::getAccessibleParent(  ) throw (RuntimeException)
 359 {
 360     OExternalLockGuard aGuard( this );
 361
 362     Reference< XAccessible > xParent;
 363     if ( m_pTabControl )
 364         xParent = m_pTabControl->GetAccessible();
 365
 366     return xParent;
 367 }
 368
 369 // -----------------------------------------------------------------------------
 370
 371 sal_Int32 VCLXAccessibleTabPage::getAccessibleIndexInParent(  ) throw (RuntimeException)
 372 {
 373     OExternalLockGuard aGuard( this );
 374
 375     sal_Int32 nIndexInParent = -1;
 376     if ( m_pTabControl )
 377         nIndexInParent = m_pTabControl->GetPagePos( m_nPageId );
 378
 379     return nIndexInParent;
 380 }
 381
 382 // -----------------------------------------------------------------------------
 383
 384 sal_Int16 VCLXAccessibleTabPage::getAccessibleRole(  ) throw (RuntimeException)
 385 {
 386     OExternalLockGuard aGuard( this );
 387
 388     return AccessibleRole::PAGE_TAB;
 389 }
 390
 391 // -----------------------------------------------------------------------------
 392
 393 ::rtl::OUString VCLXAccessibleTabPage::getAccessibleDescription(        ) throw (RuntimeException)
 394 {
 395     OExternalLockGuard aGuard( this );
 396
 397     ::rtl::OUString sDescription;
 398     if ( m_pTabControl )
 399         sDescription = m_pTabControl->GetHelpText( m_nPageId );
 400
 401     return sDescription;
 402 }
 403
 404 // -----------------------------------------------------------------------------
 405
 406 ::rtl::OUString VCLXAccessibleTabPage::getAccessibleName(  ) throw (RuntimeException)
 407 {
 408     OExternalLockGuard aGuard( this );
 409
 410     return GetPageText();
 411 }
 412
 413 // -----------------------------------------------------------------------------
 414
 415 Reference< XAccessibleRelationSet > VCLXAccessibleTabPage::getAccessibleRelationSet(  ) throw (RuntimeException)
 416 {
 417     OExternalLockGuard aGuard( this );
 418
 419     utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 420     Reference< XAccessibleRelationSet > xSet = pRelationSetHelper;
 421     return xSet;
 422 }
 423
 424 // -----------------------------------------------------------------------------
 425
 426 Reference< XAccessibleStateSet > VCLXAccessibleTabPage::getAccessibleStateSet(  ) throw (RuntimeException)
 427 {
 428     OExternalLockGuard aGuard( this );
 429
 430     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 431     Reference< XAccessibleStateSet > xSet = pStateSetHelper;
 432
 433     if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 434     {
 435         FillAccessibleStateSet( *pStateSetHelper );
 436     }
 437     else
 438     {
 439         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 440     }
 441
 442     return xSet;
 443 }
 444
 445 // -----------------------------------------------------------------------------
 446
 447 Locale VCLXAccessibleTabPage::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException)
 448 {
 449     OExternalLockGuard aGuard( this );
 450
 451     return Application::GetSettings().GetLocale();
 452 }
 453
 454 // -----------------------------------------------------------------------------
 455 // XAccessibleComponent
 456 // -----------------------------------------------------------------------------
 457
 458 Reference< XAccessible > VCLXAccessibleTabPage::getAccessibleAtPoint( const awt::Point& rPoint ) throw (RuntimeException)
 459 {
 460     OExternalLockGuard aGuard( this );
 461
 462     Reference< XAccessible > xChild;
 463     for ( sal_uInt32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
 464     {
 465         Reference< XAccessible > xAcc = getAccessibleChild( i );
 466         if ( xAcc.is() )
 467         {
 468             Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 469             if ( xComp.is() )
 470             {
 471                 Rectangle aRect = VCLRectangle( xComp->getBounds() );
 472                 Point aPos = VCLPoint( rPoint );
 473                 if ( aRect.IsInside( aPos ) )
 474                 {
 475                     xChild = xAcc;
 476                     break;
 477                 }
 478             }
 479         }
 480     }
 481
 482     return xChild;
 483 }
 484
 485 // -----------------------------------------------------------------------------
 486
 487 void VCLXAccessibleTabPage::grabFocus(  ) throw (RuntimeException)
 488 {
 489     OExternalLockGuard aGuard( this );
 490
 491     if ( m_pTabControl )
 492     {
 493         m_pTabControl->SelectTabPage( m_nPageId );
 494         m_pTabControl->GrabFocus();
 495     }
 496 }
 497
 498 // -----------------------------------------------------------------------------
 499
 500 sal_Int32 VCLXAccessibleTabPage::getForeground( ) throw (RuntimeException)
 501 {
 502     OExternalLockGuard aGuard( this );
 503
 504     sal_Int32 nColor = 0;
 505     Reference< XAccessible > xParent = getAccessibleParent();
 506     if ( xParent.is() )
 507     {
 508         Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 509         if ( xParentComp.is() )
 510             nColor = xParentComp->getForeground();
 511     }
 512
 513     return nColor;
 514 }
 515
 516 // -----------------------------------------------------------------------------
 517
 518 sal_Int32 VCLXAccessibleTabPage::getBackground(  ) throw (RuntimeException)
 519 {
 520     OExternalLockGuard aGuard( this );
 521
 522     sal_Int32 nColor = 0;
 523     Reference< XAccessible > xParent = getAccessibleParent();
 524     if ( xParent.is() )
 525     {
 526         Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 527         if ( xParentComp.is() )
 528             nColor = xParentComp->getBackground();
 529     }
 530
 531     return nColor;
 532 }
 533
 534 // -----------------------------------------------------------------------------
 535 // XAccessibleExtendedComponent
 536 // -----------------------------------------------------------------------------
 537
 538 Reference< awt::XFont > VCLXAccessibleTabPage::getFont(  ) throw (RuntimeException)
 539 {
 540     OExternalLockGuard aGuard( this );
 541
 542     Reference< awt::XFont > xFont;
 543     Reference< XAccessible > xParent = getAccessibleParent();
 544     if ( xParent.is() )
 545     {
 546         Reference< XAccessibleExtendedComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 547         if ( xParentComp.is() )
 548             xFont = xParentComp->getFont();
 549     }
 550
 551     return xFont;
 552 }
 553
 554 // -----------------------------------------------------------------------------
 555
 556 ::rtl::OUString VCLXAccessibleTabPage::getTitledBorderText(  ) throw (RuntimeException)
 557 {
 558     OExternalLockGuard aGuard( this );
 559
 560     return ::rtl::OUString();
 561 }
 562
 563 // -----------------------------------------------------------------------------
 564
 565 ::rtl::OUString VCLXAccessibleTabPage::getToolTipText(  ) throw (RuntimeException)
 566 {
 567     OExternalLockGuard aGuard( this );
 568
 569     return ::rtl::OUString();
 570 }
 571
 572 // -----------------------------------------------------------------------------
 573 // XAccessibleText
 574 // -----------------------------------------------------------------------------
 575
 576 sal_Int32 VCLXAccessibleTabPage::getCaretPosition() throw (RuntimeException)
 577 {
 578     OExternalLockGuard aGuard( this );
 579
 580     return -1;
 581 }
 582
 583 // -----------------------------------------------------------------------------
 584
 585 sal_Bool VCLXAccessibleTabPage::setCaretPosition( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 586 {
 587     OExternalLockGuard aGuard( this );
 588
 589     if ( !implIsValidRange( nIndex, nIndex, implGetText().getLength() ) )
 590         throw IndexOutOfBoundsException();
 591
 592     return sal_False;
 593 }
 594
 595 // -----------------------------------------------------------------------------
 596
 597 Sequence< PropertyValue > VCLXAccessibleTabPage::getCharacterAttributes( sal_Int32 nIndex, const Sequence< ::rtl::OUString >& aRequestedAttributes ) throw (IndexOutOfBoundsException, RuntimeException)
 598 {
 599     OExternalLockGuard aGuard( this );
 600
 601     Sequence< PropertyValue > aValues;
 602     ::rtl::OUString sText( implGetText() );
 603
 604     if ( !implIsValidIndex( nIndex, sText.getLength() ) )
 605         throw IndexOutOfBoundsException();
 606
 607     if ( m_pTabControl )
 608     {
 609         Font aFont = m_pTabControl->GetFont();
 610         sal_Int32 nBackColor = getBackground();
 611         sal_Int32 nColor = getForeground();
 612         ::std::auto_ptr< CharacterAttributesHelper > pHelper( new CharacterAttributesHelper( aFont, nBackColor, nColor ) );
 613         aValues = pHelper->GetCharacterAttributes( aRequestedAttributes );
 614     }
 615
 616     return aValues;
 617 }
 618
 619 // -----------------------------------------------------------------------------
 620
 621 awt::Rectangle VCLXAccessibleTabPage::getCharacterBounds( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 622 {
 623     OExternalLockGuard aGuard( this );
 624
 625     if ( !implIsValidIndex( nIndex, implGetText().getLength() ) )
 626         throw IndexOutOfBoundsException();
 627
 628     awt::Rectangle aBounds( 0, 0, 0, 0 );
 629     if ( m_pTabControl )
 630     {
 631         Rectangle aPageRect = m_pTabControl->GetTabBounds( m_nPageId );
 632         Rectangle aCharRect = m_pTabControl->GetCharacterBounds( m_nPageId, nIndex );
 633         aCharRect.Move( -aPageRect.Left(), -aPageRect.Top() );
 634         aBounds = AWTRectangle( aCharRect );
 635     }
 636
 637     return aBounds;
 638 }
 639
 640 // -----------------------------------------------------------------------------
 641
 642 sal_Int32 VCLXAccessibleTabPage::getIndexAtPoint( const awt::Point& aPoint ) throw (RuntimeException)
 643 {
 644     OExternalLockGuard aGuard( this );
 645
 646     sal_Int32 nIndex = -1;
 647     if ( m_pTabControl )
 648     {
 649         sal_uInt16 nPageId = 0;
 650         Rectangle aPageRect = m_pTabControl->GetTabBounds( m_nPageId );
 651         Point aPnt( VCLPoint( aPoint ) );
 652         aPnt += aPageRect.TopLeft();
 653         sal_Int32 nI = m_pTabControl->GetIndexForPoint( aPnt, nPageId );
 654         if ( nI != -1 && m_nPageId == nPageId )
 655             nIndex = nI;
 656     }
 657
 658     return nIndex;
 659 }
 660
 661 // -----------------------------------------------------------------------------
 662
 663 sal_Bool VCLXAccessibleTabPage::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 664 {
 665     OExternalLockGuard aGuard( this );
 666
 667     if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
 668         throw IndexOutOfBoundsException();
 669
 670     return sal_False;
 671 }
 672
 673 // -----------------------------------------------------------------------------
 674
 675 sal_Bool VCLXAccessibleTabPage::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 676 {
 677     OExternalLockGuard aGuard( this );
 678
 679     sal_Bool bReturn = sal_False;
 680
 681     if ( m_pTabControl )
 682     {
 683         Reference< datatransfer::clipboard::XClipboard > xClipboard = m_pTabControl->GetClipboard();
 684         if ( xClipboard.is() )
 685         {
 686             ::rtl::OUString sText( getTextRange( nStartIndex, nEndIndex ) );
 687
 688             ::vcl::unohelper::TextDataObject* pDataObj = new ::vcl::unohelper::TextDataObject( sText );
 689             const sal_uInt32 nRef = Application::ReleaseSolarMutex();
 690             xClipboard->setContents( pDataObj, NULL );
 691
 692             Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY );
 693             if( xFlushableClipboard.is() )
 694                 xFlushableClipboard->flushClipboard();
 695
 696             Application::AcquireSolarMutex( nRef );
 697
 698             bReturn = sal_True;
 699         }
 700     }
 701
 702     return bReturn;
 703 }
 704
 705 // -----------------------------------------------------------------------------