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