accessibility/source/standard/vclxaccessiblecheckbox.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/vclxaccessiblecheckbox.hxx>
  21
  22 #include <toolkit/awt/vclxwindows.hxx>
  23 #include <accessibility/helper/accresmgr.hxx>
  24 #include <accessibility/helper/accessiblestrings.hrc>
  25
  26 #include <unotools/accessiblestatesethelper.hxx>
  27 #include <comphelper/accessiblekeybindinghelper.hxx>
  28 #include <com/sun/star/awt/KeyModifier.hpp>
  29 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  30 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  31 #include <cppuhelper/typeprovider.hxx>
  32 #include <comphelper/sequence.hxx>
  33
  34 #include <vcl/button.hxx>
  35
  36 using namespace ::com::sun::star;
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::lang;
  39 using namespace ::com::sun::star::beans;
  40 using namespace ::com::sun::star::accessibility;
  41 using namespace ::comphelper;
  42
  43
  44
  45 // VCLXAccessibleCheckBox
  46
  47
  48 VCLXAccessibleCheckBox::VCLXAccessibleCheckBox( VCLXWindow* pVCLWindow )
  49     :VCLXAccessibleTextComponent( pVCLWindow )
  50 {
  51     m_bChecked = IsChecked();
  52     m_bIndeterminate = IsIndeterminate();
  53 }
  54
  55
  56
  57 VCLXAccessibleCheckBox::~VCLXAccessibleCheckBox()
  58 {
  59 }
  60
  61
  62
  63 bool VCLXAccessibleCheckBox::IsChecked()
  64 {
  65     bool bChecked = false;
  66
  67     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
  68     if ( pVCLXCheckBox && pVCLXCheckBox->getState() == (sal_Int16) 1 )
  69         bChecked = true;
  70
  71     return bChecked;
  72 }
  73
  74
  75
  76 bool VCLXAccessibleCheckBox::IsIndeterminate()
  77 {
  78     bool bIndeterminate = false;
  79
  80     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
  81     if ( pVCLXCheckBox && pVCLXCheckBox->getState() == (sal_Int16) 2 )
  82         bIndeterminate = true;
  83
  84     return bIndeterminate;
  85 }
  86
  87
  88
  89 void VCLXAccessibleCheckBox::SetChecked( bool bChecked )
  90 {
  91     if ( m_bChecked != bChecked )
  92     {
  93         Any aOldValue, aNewValue;
  94         if ( m_bChecked )
  95             aOldValue <<= AccessibleStateType::CHECKED;
  96         else
  97             aNewValue <<= AccessibleStateType::CHECKED;
  98         m_bChecked = bChecked;
  99         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 100     }
 101 }
 102
 103
 104
 105 void VCLXAccessibleCheckBox::SetIndeterminate( bool bIndeterminate )
 106 {
 107     if ( m_bIndeterminate != bIndeterminate )
 108     {
 109         Any aOldValue, aNewValue;
 110         if ( m_bIndeterminate )
 111             aOldValue <<= AccessibleStateType::INDETERMINATE;
 112         else
 113             aNewValue <<= AccessibleStateType::INDETERMINATE;
 114         m_bIndeterminate = bIndeterminate;
 115         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 116     }
 117 }
 118
 119
 120
 121 void VCLXAccessibleCheckBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 122 {
 123     switch ( rVclWindowEvent.GetId() )
 124     {
 125         case VCLEVENT_CHECKBOX_TOGGLE:
 126         {
 127             SetChecked( IsChecked() );
 128             SetIndeterminate( IsIndeterminate() );
 129         }
 130         break;
 131         default:
 132             VCLXAccessibleTextComponent::ProcessWindowEvent( rVclWindowEvent );
 133    }
 134 }
 135
 136
 137
 138 void VCLXAccessibleCheckBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 139 {
 140     VCLXAccessibleTextComponent::FillAccessibleStateSet( rStateSet );
 141
 142     rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 143
 144     if ( IsChecked() )
 145         rStateSet.AddState( AccessibleStateType::CHECKED );
 146
 147     if ( IsIndeterminate() )
 148         rStateSet.AddState( AccessibleStateType::INDETERMINATE );
 149 }
 150
 151
 152 // XInterface
 153
 154
 155 IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleCheckBox, VCLXAccessibleTextComponent, VCLXAccessibleCheckBox_BASE )
 156
 157
 158 // XTypeProvider
 159
 160
 161 IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleCheckBox, VCLXAccessibleTextComponent, VCLXAccessibleCheckBox_BASE )
 162
 163
 164 // XServiceInfo
 165
 166
 167 OUString VCLXAccessibleCheckBox::getImplementationName() throw (RuntimeException, std::exception)
 168 {
 169     return OUString( "com.sun.star.comp.toolkit.AccessibleCheckBox" );
 170 }
 171
 172
 173
 174 Sequence< OUString > VCLXAccessibleCheckBox::getSupportedServiceNames() throw (RuntimeException, std::exception)
 175 {
 176     Sequence< OUString > aNames(1);
 177     aNames[0] = "com.sun.star.awt.AccessibleCheckBox";
 178     return aNames;
 179 }
 180
 181
 182 // XAccessibleAction
 183
 184
 185 sal_Int32 VCLXAccessibleCheckBox::getAccessibleActionCount( ) throw (RuntimeException, std::exception)
 186 {
 187     OExternalLockGuard aGuard( this );
 188
 189     return 1;
 190 }
 191
 192
 193
 194 sal_Bool VCLXAccessibleCheckBox::doAccessibleAction ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 195 {
 196     OExternalLockGuard aGuard( this );
 197
 198     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 199         throw IndexOutOfBoundsException();
 200
 201     VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
 202     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
 203     if ( pCheckBox && pVCLXCheckBox )
 204     {
 205         sal_Int32 nValueMin = (sal_Int32) 0;
 206         sal_Int32 nValueMax = (sal_Int32) 1;
 207
 208         if ( pCheckBox->IsTriStateEnabled() )
 209             nValueMax = (sal_Int32) 2;
 210
 211         sal_Int32 nValue = (sal_Int32) pVCLXCheckBox->getState();
 212
 213         ++nValue;
 214
 215         if ( nValue > nValueMax )
 216             nValue = nValueMin;
 217
 218         pVCLXCheckBox->setState( (sal_Int16) nValue );
 219     }
 220
 221     return true;
 222 }
 223
 224
 225
 226 OUString VCLXAccessibleCheckBox::getAccessibleActionDescription ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 227 {
 228     OExternalLockGuard aGuard( this );
 229
 230     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 231         throw IndexOutOfBoundsException();
 232
 233     if(IsChecked())
 234         return TK_RES_STRING( RID_STR_ACC_ACTION_UNCHECK );
 235     else
 236         return TK_RES_STRING( RID_STR_ACC_ACTION_CHECK );
 237 }
 238
 239
 240
 241 Reference< XAccessibleKeyBinding > VCLXAccessibleCheckBox::getAccessibleActionKeyBinding( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 242 {
 243     OExternalLockGuard aGuard( this );
 244
 245     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 246         throw IndexOutOfBoundsException();
 247
 248     OAccessibleKeyBindingHelper* pKeyBindingHelper = new OAccessibleKeyBindingHelper();
 249     Reference< XAccessibleKeyBinding > xKeyBinding = pKeyBindingHelper;
 250
 251     vcl::Window* pWindow = GetWindow();
 252     if ( pWindow )
 253     {
 254         KeyEvent aKeyEvent = pWindow->GetActivationKey();
 255         vcl::KeyCode aKeyCode = aKeyEvent.GetKeyCode();
 256         if ( aKeyCode.GetCode() != 0 )
 257         {
 258             awt::KeyStroke aKeyStroke;
 259             aKeyStroke.Modifiers = 0;
 260             if ( aKeyCode.IsShift() )
 261                 aKeyStroke.Modifiers |= awt::KeyModifier::SHIFT;
 262             if ( aKeyCode.IsMod1() )
 263                 aKeyStroke.Modifiers |= awt::KeyModifier::MOD1;
 264             if ( aKeyCode.IsMod2() )
 265                 aKeyStroke.Modifiers |= awt::KeyModifier::MOD2;
 266             if ( aKeyCode.IsMod3() )
 267                 aKeyStroke.Modifiers |= awt::KeyModifier::MOD3;
 268             aKeyStroke.KeyCode = aKeyCode.GetCode();
 269             aKeyStroke.KeyChar = aKeyEvent.GetCharCode();
 270             aKeyStroke.KeyFunc = static_cast< sal_Int16 >( aKeyCode.GetFunction() );
 271             pKeyBindingHelper->AddKeyBinding( aKeyStroke );
 272         }
 273     }
 274
 275     return xKeyBinding;
 276 }
 277
 278
 279 // XAccessibleValue
 280
 281
 282 Any VCLXAccessibleCheckBox::getCurrentValue(  ) throw (RuntimeException, std::exception)
 283 {
 284     OExternalLockGuard aGuard( this );
 285
 286     Any aValue;
 287
 288     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
 289     if ( pVCLXCheckBox )
 290         aValue <<= (sal_Int32) pVCLXCheckBox->getState();
 291
 292     return aValue;
 293 }
 294
 295
 296
 297 sal_Bool VCLXAccessibleCheckBox::setCurrentValue( const Any& aNumber ) throw (RuntimeException, std::exception)
 298 {
 299     OExternalLockGuard aGuard( this );
 300
 301     bool bReturn = false;
 302
 303     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
 304     if ( pVCLXCheckBox )
 305     {
 306         sal_Int32 nValue = 0, nValueMin = 0, nValueMax = 0;
 307         OSL_VERIFY( aNumber >>= nValue );
 308         OSL_VERIFY( getMinimumValue() >>= nValueMin );
 309         OSL_VERIFY( getMaximumValue() >>= nValueMax );
 310
 311         if ( nValue < nValueMin )
 312             nValue = nValueMin;
 313         else if ( nValue > nValueMax )
 314             nValue = nValueMax;
 315
 316         pVCLXCheckBox->setState( (sal_Int16) nValue );
 317         bReturn = true;
 318     }
 319
 320     return bReturn;
 321 }
 322
 323
 324
 325 Any VCLXAccessibleCheckBox::getMaximumValue(  ) throw (RuntimeException, std::exception)
 326 {
 327     OExternalLockGuard aGuard( this );
 328
 329     Any aValue;
 330
 331     VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
 332     if ( pCheckBox && pCheckBox->IsTriStateEnabled() )
 333         aValue <<= (sal_Int32) 2;
 334     else
 335         aValue <<= (sal_Int32) 1;
 336
 337     return aValue;
 338 }
 339
 340
 341
 342 Any VCLXAccessibleCheckBox::getMinimumValue(  ) throw (RuntimeException, std::exception)
 343 {
 344     OExternalLockGuard aGuard( this );
 345
 346     Any aValue;
 347     aValue <<= (sal_Int32) 0;
 348
 349     return aValue;
 350 }
 351
 352
 353
 354 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */