accessibility/source/standard/vclxaccessibletabcontrol.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/standard/vclxaccessibletabcontrol.hxx>
  21 #include <accessibility/standard/vclxaccessibletabpage.hxx>
  22
  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 <unotools/accessiblestatesethelper.hxx>
  27 #include <vcl/tabctrl.hxx>
  28 #include <vcl/tabpage.hxx>
  29
  30 #include <vector>
  31
  32 using namespace ::com::sun::star;
  33 using namespace ::com::sun::star::uno;
  34 using namespace ::com::sun::star::lang;
  35 using namespace ::com::sun::star::accessibility;
  36 using namespace ::comphelper;
  37
  38
  39 //  ----------------------------------------------------
  40 //  class VCLXAccessibleTabControl
  41 //  ----------------------------------------------------
  42
  43 VCLXAccessibleTabControl::VCLXAccessibleTabControl( VCLXWindow* pVCLXWindow )
  44     :VCLXAccessibleComponent( pVCLXWindow )
  45 {
  46     m_pTabControl = static_cast< TabControl* >( GetWindow() );
  47
  48     if ( m_pTabControl )
  49         m_aAccessibleChildren.assign( m_pTabControl->GetPageCount(), Reference< XAccessible >() );
  50 }
  51
  52 // -----------------------------------------------------------------------------
  53
  54 VCLXAccessibleTabControl::~VCLXAccessibleTabControl()
  55 {
  56 }
  57
  58 // -----------------------------------------------------------------------------
  59
  60 void VCLXAccessibleTabControl::UpdateFocused()
  61 {
  62     for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
  63     {
  64         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
  65         if ( xChild.is() )
  66         {
  67             VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() );
  68             if ( pVCLXAccessibleTabPage )
  69                 pVCLXAccessibleTabPage->SetFocused( pVCLXAccessibleTabPage->IsFocused() );
  70         }
  71     }
  72 }
  73
  74 // -----------------------------------------------------------------------------
  75
  76 void VCLXAccessibleTabControl::UpdateSelected( sal_Int32 i, bool bSelected )
  77 {
  78     NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
  79
  80     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
  81     {
  82         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
  83         if ( xChild.is() )
  84         {
  85             VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() );
  86             if ( pVCLXAccessibleTabPage )
  87                 pVCLXAccessibleTabPage->SetSelected( bSelected );
  88         }
  89     }
  90 }
  91
  92 // -----------------------------------------------------------------------------
  93
  94 void VCLXAccessibleTabControl::UpdatePageText( sal_Int32 i )
  95 {
  96     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
  97     {
  98         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
  99         if ( xChild.is() )
 100         {
 101             VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() );
 102             if ( pVCLXAccessibleTabPage )
 103                 pVCLXAccessibleTabPage->SetPageText( pVCLXAccessibleTabPage->GetPageText() );
 104         }
 105     }
 106 }
 107
 108 // -----------------------------------------------------------------------------
 109
 110 void VCLXAccessibleTabControl::UpdateTabPage( sal_Int32 i, bool bNew )
 111 {
 112     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 113     {
 114         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 115         if ( xChild.is() )
 116         {
 117             VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() );
 118             if ( pVCLXAccessibleTabPage )
 119                 pVCLXAccessibleTabPage->Update( bNew );
 120         }
 121     }
 122 }
 123
 124 // -----------------------------------------------------------------------------
 125
 126 void VCLXAccessibleTabControl::InsertChild( sal_Int32 i )
 127 {
 128     if ( i >= 0 && i <= (sal_Int32)m_aAccessibleChildren.size() )
 129     {
 130         // insert entry in child list
 131         m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() );
 132
 133         // send accessible child event
 134         Reference< XAccessible > xChild( getAccessibleChild( i ) );
 135         if ( xChild.is() )
 136         {
 137             Any aOldValue, aNewValue;
 138             aNewValue <<= xChild;
 139             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 140         }
 141     }
 142 }
 143
 144 // -----------------------------------------------------------------------------
 145
 146 void VCLXAccessibleTabControl::RemoveChild( sal_Int32 i )
 147 {
 148     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 149     {
 150         // get the accessible of the removed page
 151         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 152
 153         // remove entry in child list
 154         m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
 155
 156         // send accessible child event
 157         if ( xChild.is() )
 158         {
 159             Any aOldValue, aNewValue;
 160             aOldValue <<= xChild;
 161             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 162
 163             Reference< XComponent > xComponent( xChild, UNO_QUERY );
 164             if ( xComponent.is() )
 165                 xComponent->dispose();
 166         }
 167     }
 168 }
 169
 170 // -----------------------------------------------------------------------------
 171
 172 void VCLXAccessibleTabControl::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 173 {
 174     switch ( rVclWindowEvent.GetId() )
 175     {
 176         case VCLEVENT_TABPAGE_ACTIVATE:
 177         case VCLEVENT_TABPAGE_DEACTIVATE:
 178         {
 179             if ( m_pTabControl )
 180             {
 181                 sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 182                 sal_uInt16 nPagePos = m_pTabControl->GetPagePos( nPageId );
 183                 UpdateFocused();
 184                 UpdateSelected( nPagePos, rVclWindowEvent.GetId() == VCLEVENT_TABPAGE_ACTIVATE );
 185             }
 186         }
 187         break;
 188         case VCLEVENT_TABPAGE_PAGETEXTCHANGED:
 189         {
 190             if ( m_pTabControl )
 191             {
 192                 sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 193                 sal_uInt16 nPagePos = m_pTabControl->GetPagePos( nPageId );
 194                 UpdatePageText( nPagePos );
 195             }
 196         }
 197         break;
 198         case VCLEVENT_TABPAGE_INSERTED:
 199         {
 200             if ( m_pTabControl )
 201             {
 202                 sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 203                 sal_uInt16 nPagePos = m_pTabControl->GetPagePos( nPageId );
 204                 InsertChild( nPagePos );
 205             }
 206         }
 207         break;
 208         case VCLEVENT_TABPAGE_REMOVED:
 209         {
 210             if ( m_pTabControl )
 211             {
 212                 sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 213                 for ( sal_Int32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
 214                 {
 215                     Reference< XAccessible > xChild( getAccessibleChild( i ) );
 216                     if ( xChild.is() )
 217                     {
 218                         VCLXAccessibleTabPage* pVCLXAccessibleTabPage = static_cast< VCLXAccessibleTabPage* >( xChild.get() );
 219                         if ( pVCLXAccessibleTabPage && pVCLXAccessibleTabPage->GetPageId() == nPageId )
 220                         {
 221                             RemoveChild( i );
 222                             break;
 223                         }
 224                     }
 225                 }
 226             }
 227         }
 228         break;
 229         case VCLEVENT_TABPAGE_REMOVEDALL:
 230         {
 231             for ( sal_Int32 i = m_aAccessibleChildren.size() - 1; i >= 0; --i )
 232                 RemoveChild( i );
 233         }
 234         break;
 235         case VCLEVENT_WINDOW_GETFOCUS:
 236         case VCLEVENT_WINDOW_LOSEFOCUS:
 237         {
 238             UpdateFocused();
 239         }
 240         break;
 241         case VCLEVENT_OBJECT_DYING:
 242         {
 243             if ( m_pTabControl )
 244             {
 245                 m_pTabControl = NULL;
 246
 247                 // dispose all tab pages
 248                 for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 249                 {
 250                     Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
 251                     if ( xComponent.is() )
 252                         xComponent->dispose();
 253                 }
 254                 m_aAccessibleChildren.clear();
 255             }
 256
 257             VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent );
 258         }
 259         break;
 260         default:
 261             VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent );
 262    }
 263 }
 264
 265 // -----------------------------------------------------------------------------
 266
 267 void VCLXAccessibleTabControl::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
 268 {
 269     switch ( rVclWindowEvent.GetId() )
 270     {
 271         case VCLEVENT_WINDOW_SHOW:
 272         case VCLEVENT_WINDOW_HIDE:
 273         {
 274             if ( m_pTabControl )
 275             {
 276                 Window* pChild = static_cast< Window* >( rVclWindowEvent.GetData() );
 277                 if ( pChild && pChild->GetType() == WINDOW_TABPAGE )
 278                 {
 279                     for ( sal_Int32 i = 0, nCount = m_pTabControl->GetPageCount(); i < nCount; ++i )
 280                     {
 281                         sal_uInt16 nPageId = m_pTabControl->GetPageId( (sal_uInt16)i );
 282                         TabPage* pTabPage = m_pTabControl->GetTabPage( nPageId );
 283                         if ( pTabPage == (TabPage*) pChild )
 284                             UpdateTabPage( i, rVclWindowEvent.GetId() == VCLEVENT_WINDOW_SHOW );
 285                     }
 286                 }
 287             }
 288         }
 289         break;
 290         default:
 291             VCLXAccessibleComponent::ProcessWindowChildEvent( rVclWindowEvent );
 292     }
 293 }
 294
 295
 296 // -----------------------------------------------------------------------------
 297
 298 void VCLXAccessibleTabControl::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 299 {
 300     VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
 301
 302     if ( m_pTabControl )
 303         rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 304 }
 305
 306 // -----------------------------------------------------------------------------
 307 // XInterface
 308 // -----------------------------------------------------------------------------
 309
 310 IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleTabControl, VCLXAccessibleComponent, VCLXAccessibleTabControl_BASE )
 311
 312 // -----------------------------------------------------------------------------
 313 // XTypeProvider
 314 // -----------------------------------------------------------------------------
 315
 316 IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleTabControl, VCLXAccessibleComponent, VCLXAccessibleTabControl_BASE )
 317
 318 // -----------------------------------------------------------------------------
 319 // XComponent
 320 // -----------------------------------------------------------------------------
 321
 322 void VCLXAccessibleTabControl::disposing()
 323 {
 324     VCLXAccessibleComponent::disposing();
 325
 326     if ( m_pTabControl )
 327     {
 328         m_pTabControl = NULL;
 329
 330         // dispose all tab pages
 331         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 332         {
 333             Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
 334             if ( xComponent.is() )
 335                 xComponent->dispose();
 336         }
 337         m_aAccessibleChildren.clear();
 338     }
 339 }
 340
 341 // -----------------------------------------------------------------------------
 342 // XServiceInfo
 343 // -----------------------------------------------------------------------------
 344
 345 OUString VCLXAccessibleTabControl::getImplementationName() throw (RuntimeException)
 346 {
 347     return OUString( "com.sun.star.comp.toolkit.AccessibleTabControl" );
 348 }
 349
 350 // -----------------------------------------------------------------------------
 351
 352 Sequence< OUString > VCLXAccessibleTabControl::getSupportedServiceNames() throw (RuntimeException)
 353 {
 354     Sequence< OUString > aNames(1);
 355     aNames[0] = "com.sun.star.awt.AccessibleTabControl";
 356     return aNames;
 357 }
 358
 359 // -----------------------------------------------------------------------------
 360 // XAccessibleContext
 361 // -----------------------------------------------------------------------------
 362
 363 sal_Int32 VCLXAccessibleTabControl::getAccessibleChildCount() throw (RuntimeException)
 364 {
 365     OExternalLockGuard aGuard( this );
 366
 367     return m_aAccessibleChildren.size();
 368 }
 369
 370 // -----------------------------------------------------------------------------
 371
 372 Reference< XAccessible > VCLXAccessibleTabControl::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 373 {
 374     OExternalLockGuard aGuard( this );
 375
 376     if ( i < 0 || i >= getAccessibleChildCount() )
 377         throw IndexOutOfBoundsException();
 378
 379     Reference< XAccessible > xChild = m_aAccessibleChildren[i];
 380     if ( !xChild.is() )
 381     {
 382         if ( m_pTabControl )
 383         {
 384             sal_uInt16 nPageId = m_pTabControl->GetPageId( (sal_uInt16)i );
 385
 386             xChild = new VCLXAccessibleTabPage( m_pTabControl, nPageId );
 387
 388             // insert into tab page list
 389             m_aAccessibleChildren[i] = xChild;
 390         }
 391     }
 392
 393     return xChild;
 394 }
 395
 396 // -----------------------------------------------------------------------------
 397
 398 sal_Int16 VCLXAccessibleTabControl::getAccessibleRole(  ) throw (RuntimeException)
 399 {
 400     OExternalLockGuard aGuard( this );
 401
 402     return AccessibleRole::PAGE_TAB_LIST;
 403 }
 404
 405 // -----------------------------------------------------------------------------
 406
 407 OUString VCLXAccessibleTabControl::getAccessibleName(  ) throw (RuntimeException)
 408 {
 409     OExternalLockGuard aGuard( this );
 410
 411     return OUString();
 412 }
 413
 414 // -----------------------------------------------------------------------------
 415 // XAccessibleSelection
 416 // -----------------------------------------------------------------------------
 417
 418 void VCLXAccessibleTabControl::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 419 {
 420     OExternalLockGuard aGuard( this );
 421
 422     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 423         throw IndexOutOfBoundsException();
 424
 425     if ( m_pTabControl )
 426         m_pTabControl->SelectTabPage( m_pTabControl->GetPageId( (sal_uInt16)nChildIndex ) );
 427 }
 428
 429 // -----------------------------------------------------------------------------
 430
 431 sal_Bool VCLXAccessibleTabControl::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 432 {
 433     OExternalLockGuard aGuard( this );
 434
 435     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 436         throw IndexOutOfBoundsException();
 437
 438     sal_Bool bSelected = sal_False;
 439     if ( m_pTabControl && m_pTabControl->GetCurPageId() == m_pTabControl->GetPageId( (sal_uInt16)nChildIndex ) )
 440         bSelected = sal_True;
 441
 442     return bSelected;
 443 }
 444
 445 // -----------------------------------------------------------------------------
 446
 447 void VCLXAccessibleTabControl::clearAccessibleSelection(  ) throw (RuntimeException)
 448 {
 449     // This method makes no sense in a tab control, and so does nothing.
 450 }
 451
 452 // -----------------------------------------------------------------------------
 453
 454 void VCLXAccessibleTabControl::selectAllAccessibleChildren(  ) throw (RuntimeException)
 455 {
 456     OExternalLockGuard aGuard( this );
 457
 458     selectAccessibleChild( 0 );
 459 }
 460
 461 // -----------------------------------------------------------------------------
 462
 463 sal_Int32 VCLXAccessibleTabControl::getSelectedAccessibleChildCount(  ) throw (RuntimeException)
 464 {
 465     OExternalLockGuard aGuard( this );
 466
 467     return 1;
 468 }
 469
 470 // -----------------------------------------------------------------------------
 471
 472 Reference< XAccessible > VCLXAccessibleTabControl::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 473 {
 474     OExternalLockGuard aGuard( this );
 475
 476     if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
 477         throw IndexOutOfBoundsException();
 478
 479     Reference< XAccessible > xChild;
 480
 481     for ( sal_Int32 i = 0, j = 0, nCount = getAccessibleChildCount(); i < nCount; i++ )
 482     {
 483         if ( isAccessibleChildSelected( i ) && ( j++ == nSelectedChildIndex ) )
 484         {
 485             xChild = getAccessibleChild( i );
 486             break;
 487         }
 488     }
 489
 490     return xChild;
 491 }
 492
 493 // -----------------------------------------------------------------------------
 494
 495 void VCLXAccessibleTabControl::deselectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 496 {
 497     OExternalLockGuard aGuard( this );
 498
 499     if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 500         throw IndexOutOfBoundsException();
 501
 502     // This method makes no sense in a tab control, and so does nothing.
 503 }
 504
 505 // -----------------------------------------------------------------------------
 506
 507 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */