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