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