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