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