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/awt/XDevice.hpp>
  27 #include <com/sun/star/awt/XWindowPeer.hpp>
  28 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  29 #include <cppuhelper/supportsservice.hxx>
  30 #include <unotools/accessiblestatesethelper.hxx>
  31 #include <unotools/accessiblerelationsethelper.hxx>
  32 #include <i18nlangtag/languagetag.hxx>
  33 #include <vcl/svapp.hxx>
  34 #include <vcl/settings.hxx>
  35 #include <toolkit/awt/vclxfont.hxx>
  36 #include <toolkit/helper/convert.hxx>
  37
  38
  39 namespace accessibility
  40 {
  41
  42
  43     using namespace ::com::sun::star;
  44     using namespace ::com::sun::star::uno;
  45     using namespace ::com::sun::star::lang;
  46     using namespace ::com::sun::star::accessibility;
  47     using namespace ::comphelper;
  48
  49
  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             return;
 119
 120         if ( m_pTabBar->IsEnabled() )
 121         {
 122             rStateSet.AddState( AccessibleStateType::ENABLED );
 123             rStateSet.AddState( AccessibleStateType::SENSITIVE );
 124         }
 125
 126         rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 127
 128         if ( m_pTabBar->HasFocus() )
 129             rStateSet.AddState( AccessibleStateType::FOCUSED );
 130
 131         rStateSet.AddState( AccessibleStateType::VISIBLE );
 132
 133         if ( m_pTabBar->IsVisible() )
 134             rStateSet.AddState( AccessibleStateType::SHOWING );
 135
 136         if ( m_pTabBar->GetStyle() & WB_SIZEABLE )
 137             rStateSet.AddState( AccessibleStateType::RESIZABLE );
 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 (const 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 "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         return new utl::AccessibleRelationSetHelper;
 340     }
 341
 342
 343     Reference< XAccessibleStateSet > AccessibleTabBar::getAccessibleStateSet(  )
 344     {
 345         OExternalLockGuard aGuard( this );
 346
 347         rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper;
 348
 349         if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 350         {
 351             FillAccessibleStateSet( *pStateSetHelper );
 352         }
 353         else
 354         {
 355             pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 356         }
 357
 358         return pStateSetHelper;
 359     }
 360
 361
 362     Locale AccessibleTabBar::getLocale(  )
 363     {
 364         OExternalLockGuard aGuard( this );
 365
 366         return Application::GetSettings().GetLanguageTag().getLocale();
 367     }
 368
 369
 370     // XAccessibleComponent
 371
 372
 373     Reference< XAccessible > AccessibleTabBar::getAccessibleAtPoint( const awt::Point& rPoint )
 374     {
 375         OExternalLockGuard aGuard( this );
 376
 377         Reference< XAccessible > xChild;
 378         for ( size_t i = 0; i < m_aAccessibleChildren.size(); ++i )
 379         {
 380             Reference< XAccessible > xAcc = getAccessibleChild( i );
 381             if ( xAcc.is() )
 382             {
 383                 Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 384                 if ( xComp.is() )
 385                 {
 386                     tools::Rectangle aRect = VCLRectangle( xComp->getBounds() );
 387                     Point aPos = VCLPoint( rPoint );
 388                     if ( aRect.Contains( aPos ) )
 389                     {
 390                         xChild = xAcc;
 391                         break;
 392                     }
 393                 }
 394             }
 395         }
 396
 397         return xChild;
 398     }
 399
 400
 401     void AccessibleTabBar::grabFocus(  )
 402     {
 403         OExternalLockGuard aGuard( this );
 404
 405         if ( m_pTabBar )
 406             m_pTabBar->GrabFocus();
 407     }
 408
 409
 410     sal_Int32 AccessibleTabBar::getForeground(  )
 411     {
 412         OExternalLockGuard aGuard( this );
 413
 414         Color nColor;
 415         if ( m_pTabBar )
 416         {
 417             if ( m_pTabBar->IsControlForeground() )
 418                 nColor = m_pTabBar->GetControlForeground();
 419             else
 420             {
 421                 vcl::Font aFont;
 422                 if ( m_pTabBar->IsControlFont() )
 423                     aFont = m_pTabBar->GetControlFont();
 424                 else
 425                     aFont = m_pTabBar->GetFont();
 426                 nColor = aFont.GetColor();
 427             }
 428         }
 429
 430         return sal_Int32(nColor);
 431     }
 432
 433
 434     sal_Int32 AccessibleTabBar::getBackground(  )
 435     {
 436         OExternalLockGuard aGuard( this );
 437
 438         Color nColor;
 439         if ( m_pTabBar )
 440         {
 441             if ( m_pTabBar->IsControlBackground() )
 442                 nColor = m_pTabBar->GetControlBackground();
 443             else
 444                 nColor = m_pTabBar->GetBackground().GetColor();
 445         }
 446
 447         return sal_Int32(nColor);
 448     }
 449
 450
 451     // XAccessibleExtendedComponent
 452
 453
 454     Reference< awt::XFont > AccessibleTabBar::getFont(  )
 455     {
 456         OExternalLockGuard aGuard( this );
 457
 458         Reference< awt::XFont > xFont;
 459         if ( m_pTabBar )
 460         {
 461             Reference< awt::XDevice > xDev( m_pTabBar->GetComponentInterface(), UNO_QUERY );
 462             if ( xDev.is() )
 463             {
 464                 vcl::Font aFont;
 465                 if ( m_pTabBar->IsControlFont() )
 466                     aFont = m_pTabBar->GetControlFont();
 467                 else
 468                     aFont = m_pTabBar->GetFont();
 469                 rtl::Reference<VCLXFont> pVCLXFont = new VCLXFont;
 470                 pVCLXFont->Init( *xDev, aFont );
 471                 xFont = pVCLXFont;
 472             }
 473         }
 474
 475         return xFont;
 476     }
 477
 478
 479     OUString AccessibleTabBar::getTitledBorderText(  )
 480     {
 481         OExternalLockGuard aGuard( this );
 482
 483         OUString sText;
 484         if ( m_pTabBar )
 485             sText = m_pTabBar->GetText();
 486
 487         return sText;
 488     }
 489
 490
 491     OUString AccessibleTabBar::getToolTipText(  )
 492     {
 493         OExternalLockGuard aGuard( this );
 494
 495         OUString sText;
 496         if ( m_pTabBar )
 497             sText = m_pTabBar->GetQuickHelpText();
 498
 499         return sText;
 500     }
 501
 502
 503 }   // namespace accessibility
 504
 505
 506 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */