accessibility/source/standard/vclxaccessibletabpage.cxx

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