accessibility/source/standard/vclxaccessiblecheckbox.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: vclxaccessiblecheckbox.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_accessibility.hxx"
  33
  34 // includes --------------------------------------------------------------
  35 #include <accessibility/standard/vclxaccessiblecheckbox.hxx>
  36
  37 #include <toolkit/awt/vclxwindows.hxx>
  38 #include <accessibility/helper/accresmgr.hxx>
  39 #include <accessibility/helper/accessiblestrings.hrc>
  40
  41 #include <unotools/accessiblestatesethelper.hxx>
  42 #include <comphelper/accessiblekeybindinghelper.hxx>
  43 #include <com/sun/star/awt/KeyModifier.hpp>
  44 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  45 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  46 #include <cppuhelper/typeprovider.hxx>
  47 #include <comphelper/sequence.hxx>
  48
  49 #include <vcl/button.hxx>
  50
  51 using namespace ::com::sun::star;
  52 using namespace ::com::sun::star::uno;
  53 using namespace ::com::sun::star::lang;
  54 using namespace ::com::sun::star::beans;
  55 using namespace ::com::sun::star::accessibility;
  56 using namespace ::comphelper;
  57
  58
  59 // -----------------------------------------------------------------------------
  60 // VCLXAccessibleCheckBox
  61 // -----------------------------------------------------------------------------
  62
  63 VCLXAccessibleCheckBox::VCLXAccessibleCheckBox( VCLXWindow* pVCLWindow )
  64     :VCLXAccessibleTextComponent( pVCLWindow )
  65 {
  66     m_bChecked = IsChecked();
  67     m_bIndeterminate = IsIndeterminate();
  68 }
  69
  70 // -----------------------------------------------------------------------------
  71
  72 VCLXAccessibleCheckBox::~VCLXAccessibleCheckBox()
  73 {
  74 }
  75
  76 // -----------------------------------------------------------------------------
  77
  78 bool VCLXAccessibleCheckBox::IsChecked()
  79 {
  80     bool bChecked = false;
  81
  82     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
  83     if ( pVCLXCheckBox && pVCLXCheckBox->getState() == (sal_Int16) 1 )
  84         bChecked = true;
  85
  86     return bChecked;
  87 }
  88
  89 // -----------------------------------------------------------------------------
  90
  91 bool VCLXAccessibleCheckBox::IsIndeterminate()
  92 {
  93     bool bIndeterminate = false;
  94
  95     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
  96     if ( pVCLXCheckBox && pVCLXCheckBox->getState() == (sal_Int16) 2 )
  97         bIndeterminate = true;
  98
  99     return bIndeterminate;
 100 }
 101
 102 // -----------------------------------------------------------------------------
 103
 104 void VCLXAccessibleCheckBox::SetChecked( bool bChecked )
 105 {
 106     if ( m_bChecked != bChecked )
 107     {
 108         Any aOldValue, aNewValue;
 109         if ( m_bChecked )
 110             aOldValue <<= AccessibleStateType::CHECKED;
 111         else
 112             aNewValue <<= AccessibleStateType::CHECKED;
 113         m_bChecked = bChecked;
 114         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 115     }
 116 }
 117
 118 // -----------------------------------------------------------------------------
 119
 120 void VCLXAccessibleCheckBox::SetIndeterminate( bool bIndeterminate )
 121 {
 122     if ( m_bIndeterminate != bIndeterminate )
 123     {
 124         Any aOldValue, aNewValue;
 125         if ( m_bIndeterminate )
 126             aOldValue <<= AccessibleStateType::INDETERMINATE;
 127         else
 128             aNewValue <<= AccessibleStateType::INDETERMINATE;
 129         m_bIndeterminate = bIndeterminate;
 130         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 131     }
 132 }
 133
 134 // -----------------------------------------------------------------------------
 135
 136 void VCLXAccessibleCheckBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 137 {
 138     switch ( rVclWindowEvent.GetId() )
 139     {
 140         case VCLEVENT_CHECKBOX_TOGGLE:
 141         {
 142             SetChecked( IsChecked() );
 143             SetIndeterminate( IsIndeterminate() );
 144         }
 145         break;
 146         default:
 147             VCLXAccessibleTextComponent::ProcessWindowEvent( rVclWindowEvent );
 148    }
 149 }
 150
 151 // -----------------------------------------------------------------------------
 152
 153 void VCLXAccessibleCheckBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 154 {
 155     VCLXAccessibleTextComponent::FillAccessibleStateSet( rStateSet );
 156
 157     rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 158
 159     if ( IsChecked() )
 160         rStateSet.AddState( AccessibleStateType::CHECKED );
 161
 162     if ( IsIndeterminate() )
 163         rStateSet.AddState( AccessibleStateType::INDETERMINATE );
 164 }
 165
 166 // -----------------------------------------------------------------------------
 167 // XInterface
 168 // -----------------------------------------------------------------------------
 169
 170 IMPLEMENT_FORWARD_XINTERFACE2( VCLXAccessibleCheckBox, VCLXAccessibleTextComponent, VCLXAccessibleCheckBox_BASE )
 171
 172 // -----------------------------------------------------------------------------
 173 // XTypeProvider
 174 // -----------------------------------------------------------------------------
 175
 176 IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXAccessibleCheckBox, VCLXAccessibleTextComponent, VCLXAccessibleCheckBox_BASE )
 177
 178 // -----------------------------------------------------------------------------
 179 // XServiceInfo
 180 // -----------------------------------------------------------------------------
 181
 182 ::rtl::OUString VCLXAccessibleCheckBox::getImplementationName() throw (RuntimeException)
 183 {
 184     return ::rtl::OUString::createFromAscii( "com.sun.star.comp.toolkit.AccessibleCheckBox" );
 185 }
 186
 187 // -----------------------------------------------------------------------------
 188
 189 Sequence< ::rtl::OUString > VCLXAccessibleCheckBox::getSupportedServiceNames() throw (RuntimeException)
 190 {
 191     Sequence< ::rtl::OUString > aNames(1);
 192     aNames[0] = ::rtl::OUString::createFromAscii( "com.sun.star.awt.AccessibleCheckBox" );
 193     return aNames;
 194 }
 195
 196 // -----------------------------------------------------------------------------
 197 // XAccessibleAction
 198 // -----------------------------------------------------------------------------
 199
 200 sal_Int32 VCLXAccessibleCheckBox::getAccessibleActionCount( ) throw (RuntimeException)
 201 {
 202     OExternalLockGuard aGuard( this );
 203
 204     return 1;
 205 }
 206
 207 // -----------------------------------------------------------------------------
 208
 209 sal_Bool VCLXAccessibleCheckBox::doAccessibleAction ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 210 {
 211     OExternalLockGuard aGuard( this );
 212
 213     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 214         throw IndexOutOfBoundsException();
 215
 216     CheckBox* pCheckBox = (CheckBox*) GetWindow();
 217     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
 218     if ( pCheckBox && pVCLXCheckBox )
 219     {
 220         sal_Int32 nValueMin = (sal_Int32) 0;
 221         sal_Int32 nValueMax = (sal_Int32) 1;
 222
 223         if ( pCheckBox->IsTriStateEnabled() )
 224             nValueMax = (sal_Int32) 2;
 225
 226         sal_Int32 nValue = (sal_Int32) pVCLXCheckBox->getState();
 227
 228         ++nValue;
 229
 230         if ( nValue > nValueMax )
 231             nValue = nValueMin;
 232
 233         pVCLXCheckBox->setState( (sal_Int16) nValue );
 234     }
 235
 236     return sal_True;
 237 }
 238
 239 // -----------------------------------------------------------------------------
 240
 241 ::rtl::OUString VCLXAccessibleCheckBox::getAccessibleActionDescription ( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 242 {
 243     OExternalLockGuard aGuard( this );
 244
 245     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 246         throw IndexOutOfBoundsException();
 247
 248     return ::rtl::OUString( TK_RES_STRING( RID_STR_ACC_ACTION_CLICK ) );
 249 }
 250
 251 // -----------------------------------------------------------------------------
 252
 253 Reference< XAccessibleKeyBinding > VCLXAccessibleCheckBox::getAccessibleActionKeyBinding( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 254 {
 255     OExternalLockGuard aGuard( this );
 256
 257     if ( nIndex < 0 || nIndex >= getAccessibleActionCount() )
 258         throw IndexOutOfBoundsException();
 259
 260     OAccessibleKeyBindingHelper* pKeyBindingHelper = new OAccessibleKeyBindingHelper();
 261     Reference< XAccessibleKeyBinding > xKeyBinding = pKeyBindingHelper;
 262
 263     Window* pWindow = GetWindow();
 264     if ( pWindow )
 265     {
 266         KeyEvent aKeyEvent = pWindow->GetActivationKey();
 267         KeyCode aKeyCode = aKeyEvent.GetKeyCode();
 268         if ( aKeyCode.GetCode() != 0 )
 269         {
 270             awt::KeyStroke aKeyStroke;
 271             aKeyStroke.Modifiers = 0;
 272             if ( aKeyCode.IsShift() )
 273                 aKeyStroke.Modifiers |= awt::KeyModifier::SHIFT;
 274             if ( aKeyCode.IsMod1() )
 275                 aKeyStroke.Modifiers |= awt::KeyModifier::MOD1;
 276             if ( aKeyCode.IsMod2() )
 277                 aKeyStroke.Modifiers |= awt::KeyModifier::MOD2;
 278             if ( aKeyCode.IsMod3() )
 279                 aKeyStroke.Modifiers |= awt::KeyModifier::MOD3;
 280             aKeyStroke.KeyCode = aKeyCode.GetCode();
 281             aKeyStroke.KeyChar = aKeyEvent.GetCharCode();
 282             aKeyStroke.KeyFunc = static_cast< sal_Int16 >( aKeyCode.GetFunction() );
 283             pKeyBindingHelper->AddKeyBinding( aKeyStroke );
 284         }
 285     }
 286
 287     return xKeyBinding;
 288 }
 289
 290 // -----------------------------------------------------------------------------
 291 // XAccessibleValue
 292 // -----------------------------------------------------------------------------
 293
 294 Any VCLXAccessibleCheckBox::getCurrentValue(  ) throw (RuntimeException)
 295 {
 296     OExternalLockGuard aGuard( this );
 297
 298     Any aValue;
 299
 300     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
 301     if ( pVCLXCheckBox )
 302         aValue <<= (sal_Int32) pVCLXCheckBox->getState();
 303
 304     return aValue;
 305 }
 306
 307 // -----------------------------------------------------------------------------
 308
 309 sal_Bool VCLXAccessibleCheckBox::setCurrentValue( const Any& aNumber ) throw (RuntimeException)
 310 {
 311     OExternalLockGuard aGuard( this );
 312
 313     sal_Bool bReturn = sal_False;
 314
 315     VCLXCheckBox* pVCLXCheckBox = static_cast< VCLXCheckBox* >( GetVCLXWindow() );
 316     if ( pVCLXCheckBox )
 317     {
 318         sal_Int32 nValue = 0, nValueMin = 0, nValueMax = 0;
 319         OSL_VERIFY( aNumber >>= nValue );
 320         OSL_VERIFY( getMinimumValue() >>= nValueMin );
 321         OSL_VERIFY( getMaximumValue() >>= nValueMax );
 322
 323         if ( nValue < nValueMin )
 324             nValue = nValueMin;
 325         else if ( nValue > nValueMax )
 326             nValue = nValueMax;
 327
 328         pVCLXCheckBox->setState( (sal_Int16) nValue );
 329         bReturn = sal_True;
 330     }
 331
 332     return bReturn;
 333 }
 334
 335 // -----------------------------------------------------------------------------
 336
 337 Any VCLXAccessibleCheckBox::getMaximumValue(  ) throw (RuntimeException)
 338 {
 339     OExternalLockGuard aGuard( this );
 340
 341     Any aValue;
 342
 343     CheckBox* pCheckBox = (CheckBox*) GetWindow();
 344     if ( pCheckBox && pCheckBox->IsTriStateEnabled() )
 345         aValue <<= (sal_Int32) 2;
 346     else
 347         aValue <<= (sal_Int32) 1;
 348
 349     return aValue;
 350 }
 351
 352 // -----------------------------------------------------------------------------
 353
 354 Any VCLXAccessibleCheckBox::getMinimumValue(  ) throw (RuntimeException)
 355 {
 356     OExternalLockGuard aGuard( this );
 357
 358     Any aValue;
 359     aValue <<= (sal_Int32) 0;
 360
 361     return aValue;
 362 }
 363
 364 // -----------------------------------------------------------------------------