accessibility/source/extended/accessibletabbar.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: accessibletabbar.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/extended/accessibletabbar.hxx>
  34 #include <svtools/tabbar.hxx>
  35 #include <accessibility/extended/accessibletabbarpagelist.hxx>
  36 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  37 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  38 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  39 #include <unotools/accessiblestatesethelper.hxx>
  40 #include <unotools/accessiblerelationsethelper.hxx>
  41 #include <vcl/svapp.hxx>
  42 #include <toolkit/awt/vclxfont.hxx>
  43 #include <toolkit/helper/convert.hxx>
  44
  45 #include <vector>
  46
  47
  48 //.........................................................................
  49 namespace accessibility
  50 {
  51 //.........................................................................
  52
  53     using namespace ::com::sun::star;
  54     using namespace ::com::sun::star::uno;
  55     using namespace ::com::sun::star::lang;
  56     using namespace ::com::sun::star::accessibility;
  57     using namespace ::comphelper;
  58
  59     DBG_NAME( AccessibleTabBar )
  60
  61     //  ----------------------------------------------------
  62     //  class AccessibleTabBar
  63     //  ----------------------------------------------------
  64
  65     AccessibleTabBar::AccessibleTabBar( TabBar* pTabBar )
  66         :AccessibleTabBarBase( pTabBar )
  67     {
  68         DBG_CTOR( AccessibleTabBar, NULL );
  69
  70         if ( m_pTabBar )
  71             m_aAccessibleChildren.assign( m_pTabBar->GetAccessibleChildWindowCount() + 1, Reference< XAccessible >() );
  72     }
  73
  74     // -----------------------------------------------------------------------------
  75
  76     AccessibleTabBar::~AccessibleTabBar()
  77     {
  78         DBG_DTOR( AccessibleTabBar, NULL );
  79     }
  80
  81     // -----------------------------------------------------------------------------
  82
  83     void AccessibleTabBar::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
  84     {
  85         Any aOldValue, aNewValue;
  86
  87         switch ( rVclWindowEvent.GetId() )
  88         {
  89             case VCLEVENT_WINDOW_ENABLED:
  90             {
  91                 aNewValue <<= AccessibleStateType::SENSITIVE;
  92                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
  93                 aNewValue <<= AccessibleStateType::ENABLED;
  94                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
  95             }
  96             break;
  97             case VCLEVENT_WINDOW_DISABLED:
  98             {
  99                 aOldValue <<= AccessibleStateType::ENABLED;
 100                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 101                 aOldValue <<= AccessibleStateType::SENSITIVE;
 102                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 103             }
 104             break;
 105             case VCLEVENT_WINDOW_GETFOCUS:
 106             {
 107                 aNewValue <<= AccessibleStateType::FOCUSED;
 108                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 109             }
 110             break;
 111             case VCLEVENT_WINDOW_LOSEFOCUS:
 112             {
 113                 aOldValue <<= AccessibleStateType::FOCUSED;
 114                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 115             }
 116             break;
 117             case VCLEVENT_WINDOW_SHOW:
 118             {
 119                 aNewValue <<= AccessibleStateType::SHOWING;
 120                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 121             }
 122             break;
 123             case VCLEVENT_WINDOW_HIDE:
 124             {
 125                 aOldValue <<= AccessibleStateType::SHOWING;
 126                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 127             }
 128             break;
 129             default:
 130             {
 131                 AccessibleTabBarBase::ProcessWindowEvent( rVclWindowEvent );
 132             }
 133             break;
 134         }
 135     }
 136
 137     // -----------------------------------------------------------------------------
 138
 139     void AccessibleTabBar::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 140     {
 141         if ( m_pTabBar )
 142         {
 143             if ( m_pTabBar->IsEnabled() )
 144             {
 145                 rStateSet.AddState( AccessibleStateType::ENABLED );
 146                 rStateSet.AddState( AccessibleStateType::SENSITIVE );
 147             }
 148
 149             rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 150
 151             if ( m_pTabBar->HasFocus() )
 152                 rStateSet.AddState( AccessibleStateType::FOCUSED );
 153
 154             rStateSet.AddState( AccessibleStateType::VISIBLE );
 155
 156             if ( m_pTabBar->IsVisible() )
 157                 rStateSet.AddState( AccessibleStateType::SHOWING );
 158
 159             if ( m_pTabBar->GetStyle() & WB_SIZEABLE )
 160                 rStateSet.AddState( AccessibleStateType::RESIZABLE );
 161         }
 162     }
 163
 164     // -----------------------------------------------------------------------------
 165     // OCommonAccessibleComponent
 166     // -----------------------------------------------------------------------------
 167
 168     awt::Rectangle AccessibleTabBar::implGetBounds() throw (RuntimeException)
 169     {
 170         awt::Rectangle aBounds;
 171         if ( m_pTabBar )
 172             aBounds = AWTRectangle( Rectangle( m_pTabBar->GetPosPixel(), m_pTabBar->GetSizePixel() ) );
 173
 174         return aBounds;
 175     }
 176
 177     // -----------------------------------------------------------------------------
 178     // XInterface
 179     // -----------------------------------------------------------------------------
 180
 181     IMPLEMENT_FORWARD_XINTERFACE2( AccessibleTabBar, AccessibleExtendedComponentHelper_BASE, AccessibleTabBar_BASE )
 182
 183     // -----------------------------------------------------------------------------
 184     // XTypeProvider
 185     // -----------------------------------------------------------------------------
 186
 187     IMPLEMENT_FORWARD_XTYPEPROVIDER2( AccessibleTabBar, AccessibleExtendedComponentHelper_BASE, AccessibleTabBar_BASE )
 188
 189     // -----------------------------------------------------------------------------
 190     // XComponent
 191     // -----------------------------------------------------------------------------
 192
 193     void AccessibleTabBar::disposing()
 194     {
 195         AccessibleTabBarBase::disposing();
 196
 197         // dispose all children
 198         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 199         {
 200             Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
 201             if ( xComponent.is() )
 202                 xComponent->dispose();
 203         }
 204         m_aAccessibleChildren.clear();
 205     }
 206
 207     // -----------------------------------------------------------------------------
 208     // XServiceInfo
 209     // -----------------------------------------------------------------------------
 210
 211     ::rtl::OUString AccessibleTabBar::getImplementationName() throw (RuntimeException)
 212     {
 213         return ::rtl::OUString::createFromAscii( "com.sun.star.comp.svtools.AccessibleTabBar" );
 214     }
 215
 216     // -----------------------------------------------------------------------------
 217
 218     sal_Bool AccessibleTabBar::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException)
 219     {
 220         Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() );
 221         const ::rtl::OUString* pNames = aNames.getConstArray();
 222         const ::rtl::OUString* pEnd = pNames + aNames.getLength();
 223         for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
 224             ;
 225
 226         return pNames != pEnd;
 227     }
 228
 229     // -----------------------------------------------------------------------------
 230
 231     Sequence< ::rtl::OUString > AccessibleTabBar::getSupportedServiceNames() throw (RuntimeException)
 232     {
 233         Sequence< ::rtl::OUString > aNames(1);
 234         aNames[0] = ::rtl::OUString::createFromAscii( "com.sun.star.awt.AccessibleTabBar" );
 235         return aNames;
 236     }
 237
 238     // -----------------------------------------------------------------------------
 239     // XAccessible
 240     // -----------------------------------------------------------------------------
 241
 242     Reference< XAccessibleContext > AccessibleTabBar::getAccessibleContext(  ) throw (RuntimeException)
 243     {
 244         OExternalLockGuard aGuard( this );
 245
 246         return this;
 247     }
 248
 249     // -----------------------------------------------------------------------------
 250     // XAccessibleContext
 251     // -----------------------------------------------------------------------------
 252
 253     sal_Int32 AccessibleTabBar::getAccessibleChildCount() throw (RuntimeException)
 254     {
 255         OExternalLockGuard aGuard( this );
 256
 257         return m_aAccessibleChildren.size();
 258     }
 259
 260     // -----------------------------------------------------------------------------
 261
 262     Reference< XAccessible > AccessibleTabBar::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 263     {
 264         OExternalLockGuard aGuard( this );
 265
 266         if ( i < 0 || i >= getAccessibleChildCount() )
 267             throw IndexOutOfBoundsException();
 268
 269         Reference< XAccessible > xChild = m_aAccessibleChildren[i];
 270         if ( !xChild.is() )
 271         {
 272             if ( m_pTabBar )
 273             {
 274                 sal_Int32 nCount = m_pTabBar->GetAccessibleChildWindowCount();
 275
 276                 if ( i < nCount )
 277                 {
 278                     Window* pChild = m_pTabBar->GetAccessibleChildWindow( (USHORT)i );
 279                     if ( pChild )
 280                         xChild = pChild->GetAccessible();
 281                 }
 282                 else if ( i == nCount )
 283                 {
 284                     xChild = new AccessibleTabBarPageList( m_pTabBar, i );
 285                 }
 286
 287                 // insert into child list
 288                 m_aAccessibleChildren[i] = xChild;
 289             }
 290         }
 291
 292         return xChild;
 293     }
 294
 295     // -----------------------------------------------------------------------------
 296
 297     Reference< XAccessible > AccessibleTabBar::getAccessibleParent(  ) throw (RuntimeException)
 298     {
 299         OExternalLockGuard aGuard( this );
 300
 301         Reference< XAccessible > xParent;
 302         if ( m_pTabBar )
 303         {
 304             Window* pParent = m_pTabBar->GetAccessibleParentWindow();
 305             if ( pParent )
 306                 xParent = pParent->GetAccessible();
 307         }
 308
 309         return xParent;
 310     }
 311
 312     // -----------------------------------------------------------------------------
 313
 314     sal_Int32 AccessibleTabBar::getAccessibleIndexInParent(  ) throw (RuntimeException)
 315     {
 316         OExternalLockGuard aGuard( this );
 317
 318         sal_Int32 nIndexInParent = -1;
 319         if ( m_pTabBar )
 320         {
 321             Window* pParent = m_pTabBar->GetAccessibleParentWindow();
 322             if ( pParent )
 323             {
 324                 for ( USHORT i = 0, nCount = pParent->GetAccessibleChildWindowCount(); i < nCount; ++i )
 325                 {
 326                     Window* pChild = pParent->GetAccessibleChildWindow( i );
 327                     if ( pChild == static_cast< Window* >( m_pTabBar ) )
 328                     {
 329                         nIndexInParent = i;
 330                         break;
 331                     }
 332                 }
 333             }
 334         }
 335
 336         return nIndexInParent;
 337     }
 338
 339     // -----------------------------------------------------------------------------
 340
 341     sal_Int16 AccessibleTabBar::getAccessibleRole(  ) throw (RuntimeException)
 342     {
 343         OExternalLockGuard aGuard( this );
 344
 345         return AccessibleRole::PANEL;
 346     }
 347
 348     // -----------------------------------------------------------------------------
 349
 350     ::rtl::OUString AccessibleTabBar::getAccessibleDescription( ) throw (RuntimeException)
 351     {
 352         OExternalLockGuard aGuard( this );
 353
 354         ::rtl::OUString sDescription;
 355         if ( m_pTabBar )
 356             sDescription = m_pTabBar->GetAccessibleDescription();
 357
 358         return sDescription;
 359     }
 360
 361     // -----------------------------------------------------------------------------
 362
 363     ::rtl::OUString AccessibleTabBar::getAccessibleName(  ) throw (RuntimeException)
 364     {
 365         OExternalLockGuard aGuard( this );
 366
 367         ::rtl::OUString sName;
 368         if ( m_pTabBar )
 369             sName = m_pTabBar->GetAccessibleName();
 370
 371         return sName;
 372     }
 373
 374     // -----------------------------------------------------------------------------
 375
 376     Reference< XAccessibleRelationSet > AccessibleTabBar::getAccessibleRelationSet(  ) throw (RuntimeException)
 377     {
 378         OExternalLockGuard aGuard( this );
 379
 380         utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 381         Reference< XAccessibleRelationSet > xSet = pRelationSetHelper;
 382         return xSet;
 383     }
 384
 385     // -----------------------------------------------------------------------------
 386
 387     Reference< XAccessibleStateSet > AccessibleTabBar::getAccessibleStateSet(  ) throw (RuntimeException)
 388     {
 389         OExternalLockGuard aGuard( this );
 390
 391         utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 392         Reference< XAccessibleStateSet > xSet = pStateSetHelper;
 393
 394         if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 395         {
 396             FillAccessibleStateSet( *pStateSetHelper );
 397         }
 398         else
 399         {
 400             pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 401         }
 402
 403         return xSet;
 404     }
 405
 406     // -----------------------------------------------------------------------------
 407
 408     Locale AccessibleTabBar::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException)
 409     {
 410         OExternalLockGuard aGuard( this );
 411
 412         return Application::GetSettings().GetLocale();
 413     }
 414
 415     // -----------------------------------------------------------------------------
 416     // XAccessibleComponent
 417     // -----------------------------------------------------------------------------
 418
 419     Reference< XAccessible > AccessibleTabBar::getAccessibleAtPoint( const awt::Point& rPoint ) throw (RuntimeException)
 420     {
 421         OExternalLockGuard aGuard( this );
 422
 423         Reference< XAccessible > xChild;
 424         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 425         {
 426             Reference< XAccessible > xAcc = getAccessibleChild( i );
 427             if ( xAcc.is() )
 428             {
 429                 Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 430                 if ( xComp.is() )
 431                 {
 432                     Rectangle aRect = VCLRectangle( xComp->getBounds() );
 433                     Point aPos = VCLPoint( rPoint );
 434                     if ( aRect.IsInside( aPos ) )
 435                     {
 436                         xChild = xAcc;
 437                         break;
 438                     }
 439                 }
 440             }
 441         }
 442
 443         return xChild;
 444     }
 445
 446     // -----------------------------------------------------------------------------
 447
 448     void AccessibleTabBar::grabFocus(  ) throw (RuntimeException)
 449     {
 450         OExternalLockGuard aGuard( this );
 451
 452         if ( m_pTabBar )
 453             m_pTabBar->GrabFocus();
 454     }
 455
 456     // -----------------------------------------------------------------------------
 457
 458     sal_Int32 AccessibleTabBar::getForeground(  ) throw (RuntimeException)
 459     {
 460         OExternalLockGuard aGuard( this );
 461
 462         sal_Int32 nColor = 0;
 463         if ( m_pTabBar )
 464         {
 465             if ( m_pTabBar->IsControlForeground() )
 466                 nColor = m_pTabBar->GetControlForeground().GetColor();
 467             else
 468             {
 469                 Font aFont;
 470                 if ( m_pTabBar->IsControlFont() )
 471                     aFont = m_pTabBar->GetControlFont();
 472                 else
 473                     aFont = m_pTabBar->GetFont();
 474                 nColor = aFont.GetColor().GetColor();
 475             }
 476         }
 477
 478         return nColor;
 479     }
 480
 481     // -----------------------------------------------------------------------------
 482
 483     sal_Int32 AccessibleTabBar::getBackground(  ) throw (RuntimeException)
 484     {
 485         OExternalLockGuard aGuard( this );
 486
 487         sal_Int32 nColor = 0;
 488         if ( m_pTabBar )
 489         {
 490             if ( m_pTabBar->IsControlBackground() )
 491                 nColor = m_pTabBar->GetControlBackground().GetColor();
 492             else
 493                 nColor = m_pTabBar->GetBackground().GetColor().GetColor();
 494         }
 495
 496         return nColor;
 497     }
 498
 499     // -----------------------------------------------------------------------------
 500     // XAccessibleExtendedComponent
 501     // -----------------------------------------------------------------------------
 502
 503     Reference< awt::XFont > AccessibleTabBar::getFont(  ) throw (RuntimeException)
 504     {
 505         OExternalLockGuard aGuard( this );
 506
 507         Reference< awt::XFont > xFont;
 508         if ( m_pTabBar )
 509         {
 510             Reference< awt::XDevice > xDev( m_pTabBar->GetComponentInterface(), UNO_QUERY );
 511             if ( xDev.is() )
 512             {
 513                 Font aFont;
 514                 if ( m_pTabBar->IsControlFont() )
 515                     aFont = m_pTabBar->GetControlFont();
 516                 else
 517                     aFont = m_pTabBar->GetFont();
 518                 VCLXFont* pVCLXFont = new VCLXFont;
 519                 pVCLXFont->Init( *xDev.get(), aFont );
 520                 xFont = pVCLXFont;
 521             }
 522         }
 523
 524         return xFont;
 525     }
 526
 527     // -----------------------------------------------------------------------------
 528
 529     ::rtl::OUString AccessibleTabBar::getTitledBorderText(  ) throw (RuntimeException)
 530     {
 531         OExternalLockGuard aGuard( this );
 532
 533         ::rtl::OUString sText;
 534         if ( m_pTabBar )
 535             sText = m_pTabBar->GetText();
 536
 537         return sText;
 538     }
 539
 540     // -----------------------------------------------------------------------------
 541
 542     ::rtl::OUString AccessibleTabBar::getToolTipText(  ) throw (RuntimeException)
 543     {
 544         OExternalLockGuard aGuard( this );
 545
 546         ::rtl::OUString sText;
 547         if ( m_pTabBar )
 548             sText = m_pTabBar->GetQuickHelpText();
 549
 550         return sText;
 551     }
 552
 553     // -----------------------------------------------------------------------------
 554
 555 //.........................................................................
 556 }       // namespace accessibility
 557 //.........................................................................