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