accessibility/source/standard/vclxaccessibletoolboxitem.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/vclxaccessibletoolboxitem.hxx>
  21 #include <helper/accresmgr.hxx>
  22 #include <strings.hrc>
  23 #include <com/sun/star/awt/Rectangle.hpp>
  24
  25 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  26 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  27 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  28 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
  29 #include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp>
  30 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  31 #include <comphelper/accessiblecontexthelper.hxx>
  32 #include <cppuhelper/supportsservice.hxx>
  33 #include <vcl/accessibility/strings.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <vcl/toolbox.hxx>
  36 #include <vcl/unohelp.hxx>
  37 #include <vcl/unohelp2.hxx>
  38 #include <vcl/help.hxx>
  39 #include <vcl/settings.hxx>
  40 #include <unotools/accessiblerelationsethelper.hxx>
  41 #include <sal/log.hxx>
  42 #include <i18nlangtag/languagetag.hxx>
  43
  44 #include <com/sun/star/accessibility/XAccessibleSelection.hpp>
  45
  46 #include <array>
  47
  48 // class VCLXAccessibleToolBoxItem ------------------------------------------
  49
  50 using namespace ::com::sun::star::accessibility;
  51 using namespace ::com::sun::star::uno;
  52 using namespace ::com::sun::star::beans;
  53 using namespace ::com::sun::star::lang;
  54 using namespace ::com::sun::star;
  55 using namespace ::comphelper;
  56
  57
  58 // Ctor() and Dtor()
  59
  60 VCLXAccessibleToolBoxItem::VCLXAccessibleToolBoxItem( ToolBox* _pToolBox, sal_Int32 _nPos ) :
  61     m_pToolBox      ( _pToolBox ),
  62     m_nIndexInParent( _nPos ),
  63     m_nRole         ( AccessibleRole::PUSH_BUTTON ),
  64     m_nItemId       ( 0 ),
  65     m_bHasFocus     ( false ),
  66     m_bIsChecked    ( false ),
  67     m_bIndeterminate( false )
  68
  69 {
  70     assert( m_pToolBox );
  71     m_nItemId = m_pToolBox->GetItemId( m_nIndexInParent );
  72     m_sOldName = implGetAccessibleName();
  73     m_bIsChecked = m_pToolBox->IsItemChecked( m_nItemId );
  74     m_bIndeterminate = ( m_pToolBox->GetItemState( m_nItemId ) == TRISTATE_INDET );
  75     ToolBoxItemType eType = m_pToolBox->GetItemType( m_nIndexInParent );
  76     switch ( eType )
  77     {
  78         case ToolBoxItemType::BUTTON :
  79         {
  80             ToolBoxItemBits nBits = m_pToolBox->GetItemBits( m_nItemId );
  81             if (
  82                  (( nBits & ToolBoxItemBits::DROPDOWN ) == ToolBoxItemBits::DROPDOWN) ||
  83                  (( nBits & ToolBoxItemBits::DROPDOWNONLY ) == ToolBoxItemBits::DROPDOWNONLY)
  84                )
  85                 m_nRole = AccessibleRole::BUTTON_DROPDOWN;
  86             else if (
  87                 ( ( nBits & ToolBoxItemBits::CHECKABLE ) == ToolBoxItemBits::CHECKABLE ) ||
  88                 ( ( nBits & ToolBoxItemBits::RADIOCHECK ) == ToolBoxItemBits::RADIOCHECK ) ||
  89                 ( ( nBits & ToolBoxItemBits::AUTOCHECK ) == ToolBoxItemBits::AUTOCHECK )
  90                )
  91                 m_nRole = AccessibleRole::TOGGLE_BUTTON;
  92             else if ( m_pToolBox->GetItemWindow( m_nItemId ) )
  93                 m_nRole = AccessibleRole::PANEL;
  94             break;
  95         }
  96
  97         case ToolBoxItemType::SPACE :
  98             m_nRole = AccessibleRole::FILLER;
  99             break;
 100
 101         case ToolBoxItemType::SEPARATOR :
 102         case ToolBoxItemType::BREAK :
 103             m_nRole = AccessibleRole::SEPARATOR;
 104             break;
 105
 106         default:
 107         {
 108             SAL_WARN( "accessibility", "unsupported toolbox itemtype" );
 109         }
 110     }
 111 }
 112
 113 VCLXAccessibleToolBoxItem::~VCLXAccessibleToolBoxItem()
 114 {
 115 }
 116
 117 void VCLXAccessibleToolBoxItem::SetFocus( bool _bFocus )
 118 {
 119     if ( m_bHasFocus != _bFocus )
 120     {
 121         Any aOldValue;
 122         Any aNewValue;
 123         if ( m_bHasFocus )
 124             aOldValue <<= AccessibleStateType::FOCUSED;
 125         else
 126             aNewValue <<= AccessibleStateType::FOCUSED;
 127         m_bHasFocus = _bFocus;
 128         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 129     }
 130 }
 131
 132 void VCLXAccessibleToolBoxItem::SetChecked( bool _bCheck )
 133 {
 134     if( m_nRole == AccessibleRole::PANEL)
 135         return;
 136     if ( m_bIsChecked != _bCheck )
 137     {
 138         Any aOldValue;
 139         Any aNewValue;
 140         if ( m_bIsChecked )
 141             aOldValue <<= AccessibleStateType::CHECKED;
 142         else
 143             aNewValue <<= AccessibleStateType::CHECKED;
 144         m_bIsChecked = _bCheck;
 145         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 146     }
 147 }
 148
 149 void VCLXAccessibleToolBoxItem::SetIndeterminate( bool _bIndeterminate )
 150 {
 151     if ( m_bIndeterminate != _bIndeterminate )
 152     {
 153         Any aOldValue, aNewValue;
 154         if ( m_bIndeterminate )
 155             aOldValue <<= AccessibleStateType::INDETERMINATE;
 156         else
 157             aNewValue <<= AccessibleStateType::INDETERMINATE;
 158         m_bIndeterminate = _bIndeterminate;
 159         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 160     }
 161 }
 162
 163 void VCLXAccessibleToolBoxItem::NameChanged()
 164 {
 165     OUString sNewName = implGetAccessibleName();
 166     if ( sNewName != m_sOldName )
 167     {
 168         Any aOldValue, aNewValue;
 169         aOldValue <<= m_sOldName;
 170         // save new name as old name for next change
 171         m_sOldName = sNewName;
 172         aNewValue <<= m_sOldName;
 173         NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue );
 174     }
 175 }
 176
 177 void VCLXAccessibleToolBoxItem::SetChild( const Reference< XAccessible >& _xChild )
 178 {
 179     m_xChild = _xChild;
 180 }
 181
 182 void VCLXAccessibleToolBoxItem::NotifyChildEvent( const Reference< XAccessible >& _xChild, bool _bShow )
 183 {
 184     Any aOld = _bShow ? Any() : Any( _xChild );
 185     Any aNew = _bShow ? Any( _xChild ) : Any();
 186     NotifyAccessibleEvent( AccessibleEventId::CHILD, aOld, aNew );
 187 }
 188
 189 void VCLXAccessibleToolBoxItem::ToggleEnableState()
 190 {
 191     std::array<Any, 2> aOldValue, aNewValue;
 192     if ( m_pToolBox->IsItemEnabled( m_nItemId ) )
 193     {
 194         aNewValue[0] <<= AccessibleStateType::SENSITIVE;
 195         aNewValue[1] <<= AccessibleStateType::ENABLED;
 196     }
 197     else
 198     {
 199         aOldValue[0] <<= AccessibleStateType::ENABLED;
 200         aOldValue[1] <<= AccessibleStateType::SENSITIVE;
 201     }
 202
 203     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] );
 204     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] );
 205 }
 206
 207 awt::Rectangle VCLXAccessibleToolBoxItem::implGetBounds(  )
 208 {
 209     awt::Rectangle aRect;
 210     if ( m_pToolBox )
 211         aRect = vcl::unohelper::ConvertToAWTRect(m_pToolBox->GetItemPosRect(m_nIndexInParent));
 212
 213     return aRect;
 214 }
 215
 216 OUString VCLXAccessibleToolBoxItem::implGetText()
 217 {
 218     // no text for separators and spaces
 219     if (!m_pToolBox || m_nItemId <= ToolBoxItemId(0))
 220         return OUString();
 221
 222     return m_pToolBox->GetItemText(m_nItemId);
 223 }
 224
 225 Locale VCLXAccessibleToolBoxItem::implGetLocale()
 226 {
 227     return Application::GetSettings().GetUILanguageTag().getLocale();
 228 }
 229
 230 void VCLXAccessibleToolBoxItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 231 {
 232     nStartIndex = 0;
 233     nEndIndex = 0;
 234 }
 235
 236 // XInterface
 237
 238 Any SAL_CALL VCLXAccessibleToolBoxItem::queryInterface( const Type& _rType )
 239 {
 240     // #i33611# - toolbox buttons without text don't support XAccessibleText
 241     if ( _rType == cppu::UnoType<XAccessibleText>::get()
 242         && ( !m_pToolBox || m_pToolBox->GetButtonType() == ButtonType::SYMBOLONLY ) )
 243         return Any();
 244
 245     return ImplInheritanceHelper::queryInterface( _rType );
 246 }
 247
 248 // XComponent
 249
 250 void SAL_CALL VCLXAccessibleToolBoxItem::disposing()
 251 {
 252     comphelper::OAccessibleTextHelper::disposing();
 253     m_pToolBox = nullptr;
 254 }
 255
 256 // XServiceInfo
 257
 258 OUString VCLXAccessibleToolBoxItem::getImplementationName()
 259 {
 260     return u"com.sun.star.comp.toolkit.AccessibleToolBoxItem"_ustr;
 261 }
 262
 263 sal_Bool VCLXAccessibleToolBoxItem::supportsService( const OUString& rServiceName )
 264 {
 265     return cppu::supportsService(this, rServiceName);
 266 }
 267
 268 Sequence< OUString > VCLXAccessibleToolBoxItem::getSupportedServiceNames()
 269 {
 270     return {u"com.sun.star.accessibility.AccessibleContext"_ustr,
 271             u"com.sun.star.accessibility.AccessibleComponent"_ustr,
 272             u"com.sun.star.accessibility.AccessibleExtendedComponent"_ustr,
 273             u"com.sun.star.accessibility.AccessibleToolBoxItem"_ustr};
 274 }
 275
 276 // XAccessible
 277
 278 Reference< XAccessibleContext > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleContext(  )
 279 {
 280     return this;
 281 }
 282
 283 // XAccessibleContext
 284
 285 sal_Int64 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChildCount(  )
 286 {
 287     OContextEntryGuard aGuard( this );
 288
 289     return m_xChild.is() ? 1 : 0;
 290 }
 291
 292 Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChild( sal_Int64 i )
 293 {
 294     OContextEntryGuard aGuard( this );
 295
 296     // no child -> so index is out of bounds
 297     if ( !m_xChild.is() || i != 0 )
 298         throw IndexOutOfBoundsException();
 299
 300     return m_xChild;
 301 }
 302
 303 Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleParent(  )
 304 {
 305     OContextEntryGuard aGuard( this );
 306
 307     return m_pToolBox->GetAccessible();
 308 }
 309
 310 sal_Int64 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleIndexInParent(  )
 311 {
 312     OContextEntryGuard aGuard( this );
 313
 314     return m_nIndexInParent;
 315 }
 316
 317 sal_Int16 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRole(  )
 318 {
 319     OContextEntryGuard aGuard( this );
 320
 321     return m_nRole;
 322 }
 323
 324 OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleDescription(  )
 325 {
 326     OExternalLockGuard aGuard( this );
 327
 328     if (m_nRole == AccessibleRole::PANEL && m_xChild.is())
 329     {
 330         return AccResId( RID_STR_ACC_PANEL_DESCRIPTION );
 331     }
 332     else
 333     {
 334         OUString sDescription;
 335         if ( m_pToolBox )
 336             sDescription = m_pToolBox->GetHelpText( m_nItemId );
 337         return sDescription;
 338     }
 339 }
 340
 341 OUString VCLXAccessibleToolBoxItem::implGetAccessibleName()
 342 {
 343     OUString sRet = m_pToolBox->GetAccessibleName(m_nItemId);
 344     if (!sRet.isEmpty())
 345         return sRet;
 346
 347     sRet = implGetText();
 348     if (!sRet.isEmpty())
 349         return sRet;
 350
 351     sRet = m_pToolBox->GetQuickHelpText( m_nItemId );
 352     if (!sRet.isEmpty())
 353         return sRet;
 354
 355     vcl::Window* pItemWindow = m_pToolBox->GetItemWindow( m_nItemId );
 356     if ( m_nRole == AccessibleRole::PANEL && pItemWindow && pItemWindow->GetAccessible().is() &&
 357         pItemWindow->GetAccessible()->getAccessibleContext().is() )
 358     {
 359         sRet = pItemWindow->GetAccessible()->getAccessibleContext()->getAccessibleName();
 360     }
 361     return sRet;
 362 }
 363
 364 OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleName(  )
 365 {
 366     OExternalLockGuard aGuard( this );
 367     return implGetAccessibleName();
 368 }
 369
 370 Reference< XAccessibleRelationSet > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRelationSet(  )
 371 {
 372     OContextEntryGuard aGuard( this );
 373
 374     return new utl::AccessibleRelationSetHelper;
 375 }
 376
 377 sal_Int64 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleStateSet(  )
 378 {
 379     OExternalLockGuard aGuard( this );
 380
 381     sal_Int64 nStateSet = 0;
 382
 383     if ( m_pToolBox && !rBHelper.bDisposed && !rBHelper.bInDispose )
 384     {
 385         nStateSet |= AccessibleStateType::FOCUSABLE;
 386         if (m_pToolBox->GetItemBits(m_nItemId) & ToolBoxItemBits::CHECKABLE)
 387             nStateSet |= AccessibleStateType::CHECKABLE;
 388         if ( m_bIsChecked && m_nRole != AccessibleRole::PANEL )
 389             nStateSet |= AccessibleStateType::CHECKED;
 390         if ( m_bIndeterminate )
 391             nStateSet |= AccessibleStateType::INDETERMINATE;
 392         if ( m_pToolBox->IsEnabled() && m_pToolBox->IsItemEnabled( m_nItemId ) )
 393         {
 394             nStateSet |= AccessibleStateType::ENABLED;
 395             nStateSet |= AccessibleStateType::SENSITIVE;
 396         }
 397         if ( m_pToolBox->IsItemVisible( m_nItemId ) )
 398             nStateSet |= AccessibleStateType::VISIBLE;
 399         if ( m_pToolBox->IsItemReallyVisible( m_nItemId ) )
 400             nStateSet |= AccessibleStateType::SHOWING;
 401         if ( m_bHasFocus )
 402             nStateSet |= AccessibleStateType::FOCUSED;
 403     }
 404     else
 405         nStateSet |= AccessibleStateType::DEFUNC;
 406
 407     return nStateSet;
 408 }
 409
 410 // XAccessibleText
 411
 412 OUString VCLXAccessibleToolBoxItem::getText()
 413 {
 414     OExternalLockGuard aGuard( this );
 415
 416     return implGetText();
 417 }
 418
 419 sal_Int32 VCLXAccessibleToolBoxItem::getCharacterCount()
 420 {
 421     return implGetText().getLength();
 422 }
 423
 424 sal_Unicode VCLXAccessibleToolBoxItem::getCharacter( sal_Int32 nIndex )
 425 {
 426      OExternalLockGuard aGuard( this );
 427
 428      return OCommonAccessibleText::implGetCharacter(implGetText(), nIndex);
 429 }
 430
 431 OUString VCLXAccessibleToolBoxItem::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 432 {
 433      OExternalLockGuard aGuard( this );
 434
 435      return OCommonAccessibleText::implGetTextRange(implGetText(), nStartIndex, nEndIndex);
 436 }
 437
 438 sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getCaretPosition()
 439 {
 440     return -1;
 441 }
 442
 443 sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::setCaretPosition( sal_Int32 nIndex )
 444 {
 445     OExternalLockGuard aGuard( this );
 446
 447     if (!implIsValidRange(nIndex, nIndex, implGetText().getLength()))
 448         throw IndexOutOfBoundsException();
 449
 450     return false;
 451 }
 452
 453 Sequence< PropertyValue > SAL_CALL VCLXAccessibleToolBoxItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& )
 454 {
 455     OExternalLockGuard aGuard( this );
 456
 457     OUString sText( implGetText() );
 458
 459     if ( !implIsValidIndex( nIndex, sText.getLength() ) )
 460         throw IndexOutOfBoundsException();
 461
 462     return Sequence< PropertyValue >();
 463 }
 464
 465 awt::Rectangle SAL_CALL VCLXAccessibleToolBoxItem::getCharacterBounds( sal_Int32 nIndex )
 466 {
 467     OExternalLockGuard aGuard( this );
 468
 469     OUString sText( implGetText() );
 470
 471     if ( !implIsValidIndex( nIndex, sText.getLength() ) )
 472         throw IndexOutOfBoundsException();
 473
 474     awt::Rectangle aBounds( 0, 0, 0, 0 );
 475     if ( m_pToolBox && m_pToolBox->GetButtonType() != ButtonType::SYMBOLONLY ) // symbol buttons have no character bounds
 476     {
 477         tools::Rectangle aCharRect = m_pToolBox->GetCharacterBounds( m_nItemId, nIndex );
 478         tools::Rectangle aItemRect = m_pToolBox->GetItemRect( m_nItemId );
 479         aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() );
 480         aBounds = vcl::unohelper::ConvertToAWTRect(aCharRect);
 481     }
 482
 483     return aBounds;
 484 }
 485
 486 sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getIndexAtPoint( const awt::Point& aPoint )
 487 {
 488     OExternalLockGuard aGuard( this );
 489
 490     sal_Int32 nIndex = -1;
 491     if ( m_pToolBox && m_pToolBox->GetButtonType() != ButtonType::SYMBOLONLY ) // symbol buttons have no character bounds
 492     {
 493         ToolBoxItemId nItemId;
 494         tools::Rectangle aItemRect = m_pToolBox->GetItemRect( m_nItemId );
 495         Point aPnt(vcl::unohelper::ConvertToVCLPoint(aPoint));
 496         aPnt += aItemRect.TopLeft();
 497         sal_Int32 nIdx = m_pToolBox->GetIndexForPoint( aPnt, nItemId );
 498         if ( nIdx != -1 && nItemId == m_nItemId )
 499             nIndex = nIdx;
 500     }
 501
 502     return nIndex;
 503 }
 504
 505 sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 506 {
 507     OExternalLockGuard aGuard( this );
 508
 509     if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
 510         throw IndexOutOfBoundsException();
 511
 512     return false;
 513 }
 514
 515 sal_Bool SAL_CALL VCLXAccessibleToolBoxItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 516 {
 517     OExternalLockGuard aGuard( this );
 518
 519     if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
 520         throw IndexOutOfBoundsException();
 521
 522     bool bReturn = false;
 523
 524     if ( m_pToolBox )
 525     {
 526         Reference< datatransfer::clipboard::XClipboard > xClipboard = m_pToolBox->GetClipboard();
 527         if ( xClipboard.is() )
 528         {
 529             OUString sText( OCommonAccessibleText::implGetTextRange( implGetText(), nStartIndex, nEndIndex ) );
 530
 531             rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText );
 532
 533             SolarMutexReleaser aReleaser;
 534             xClipboard->setContents( pDataObj, nullptr );
 535
 536             Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY );
 537             if( xFlushableClipboard.is() )
 538                 xFlushableClipboard->flushClipboard();
 539
 540             bReturn = true;
 541         }
 542     }
 543
 544     return bReturn;
 545 }
 546
 547 sal_Bool VCLXAccessibleToolBoxItem::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType )
 548 {
 549     return false;
 550 }
 551
 552 // XAccessibleComponent
 553
 554 Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleAtPoint( const awt::Point& )
 555 {
 556     return Reference< XAccessible >();
 557 }
 558
 559 void SAL_CALL VCLXAccessibleToolBoxItem::grabFocus(  )
 560 {
 561     Reference< XAccessible > xParent(getAccessibleParent());
 562
 563     if( xParent.is() )
 564     {
 565         Reference< XAccessibleSelection > rxAccessibleSelection(xParent->getAccessibleContext(), UNO_QUERY);
 566
 567         if ( rxAccessibleSelection.is() )
 568         {
 569             rxAccessibleSelection -> selectAccessibleChild ( getAccessibleIndexInParent() );
 570         }
 571     }
 572 }
 573
 574 sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getForeground(  )
 575 {
 576     OExternalLockGuard aGuard( this );
 577
 578     Color nColor;
 579     if ( m_pToolBox )
 580        nColor = m_pToolBox->GetControlForeground();
 581
 582     return sal_Int32(nColor);
 583 }
 584
 585 sal_Int32 SAL_CALL VCLXAccessibleToolBoxItem::getBackground(  )
 586 {
 587     OExternalLockGuard aGuard( this );
 588
 589     Color nColor;
 590     if ( m_pToolBox )
 591        nColor = m_pToolBox->GetControlBackground();
 592
 593     return sal_Int32(nColor);
 594 }
 595
 596 // XAccessibleExtendedComponent
 597
 598 OUString SAL_CALL VCLXAccessibleToolBoxItem::getTitledBorderText(  )
 599 {
 600     OExternalLockGuard aGuard( this );
 601
 602     OUString sRet;
 603     if ( m_pToolBox )
 604         sRet = m_pToolBox->GetItemText( m_nItemId );
 605
 606     return sRet;
 607 }
 608
 609 OUString SAL_CALL VCLXAccessibleToolBoxItem::getToolTipText(  )
 610 {
 611     OExternalLockGuard aGuard( this );
 612
 613     OUString sRet;
 614     if ( m_pToolBox )
 615     {
 616         if ( Help::IsExtHelpEnabled() )
 617             sRet = m_pToolBox->GetHelpText( m_nItemId );
 618         else
 619             sRet = m_pToolBox->GetQuickHelpText( m_nItemId );
 620         if ( sRet.isEmpty() )
 621             // no help text set, so use item text
 622             sRet = m_pToolBox->GetItemText( m_nItemId );
 623     }
 624     return sRet;
 625 }
 626
 627 // XAccessibleAction
 628
 629 sal_Int32 VCLXAccessibleToolBoxItem::getAccessibleActionCount( )
 630 {
 631     // "Click" and maybe "Toggle Popup"
 632     return ( m_pToolBox && m_pToolBox->ItemHasDropdown( m_nItemId ) ? 2 : 1 );
 633 }
 634
 635 sal_Bool VCLXAccessibleToolBoxItem::doAccessibleAction ( sal_Int32 nIndex )
 636 {
 637     OExternalLockGuard aGuard( this );
 638
 639     switch ( nIndex )
 640     {
 641         case 0:
 642             if ( m_pToolBox )
 643                 m_pToolBox->TriggerItem( m_nItemId );
 644             break;
 645         case 1:
 646             if ( m_pToolBox && m_pToolBox->ItemHasDropdown( m_nItemId ) )
 647                 m_pToolBox->TriggerItemDropdown( m_nItemId );
 648             break;
 649         default:
 650             throw IndexOutOfBoundsException();
 651     }
 652
 653     return true;
 654 }
 655
 656 OUString VCLXAccessibleToolBoxItem::getAccessibleActionDescription ( sal_Int32 nIndex )
 657 {
 658     OExternalLockGuard aGuard( this );
 659
 660     switch ( nIndex )
 661     {
 662         case 0:
 663             return RID_STR_ACC_ACTION_CLICK;
 664         case 1:
 665             return RID_STR_ACC_ACTION_TOGGLEPOPUP;
 666         default:
 667             throw IndexOutOfBoundsException();
 668     }
 669 }
 670
 671 Reference< XAccessibleKeyBinding > VCLXAccessibleToolBoxItem::getAccessibleActionKeyBinding( sal_Int32 nIndex )
 672 {
 673     OContextEntryGuard aGuard( this );
 674
 675     if (nIndex < 0 || nIndex >= getAccessibleActionCount())
 676         throw IndexOutOfBoundsException();
 677
 678     return Reference< XAccessibleKeyBinding >();
 679 }
 680
 681 // XAccessibleValue
 682
 683 Any VCLXAccessibleToolBoxItem::getCurrentValue(  )
 684 {
 685     OExternalLockGuard aGuard( this );
 686
 687     Any aValue;
 688     if ( m_pToolBox )
 689         aValue <<= static_cast<sal_Int32>(m_pToolBox->IsItemChecked( m_nItemId ));
 690
 691     if( m_nRole == AccessibleRole::PANEL )
 692         aValue <<= sal_Int32(0);
 693     return aValue;
 694 }
 695
 696 sal_Bool VCLXAccessibleToolBoxItem::setCurrentValue( const Any& aNumber )
 697 {
 698     OExternalLockGuard aGuard( this );
 699
 700     bool bReturn = false;
 701
 702     if ( m_pToolBox )
 703     {
 704         sal_Int32 nValue = 0;
 705         OSL_VERIFY( aNumber >>= nValue );
 706
 707         if ( nValue < 0 )
 708             nValue = 0;
 709         else if ( nValue > 1 )
 710             nValue = 1;
 711
 712         m_pToolBox->CheckItem( m_nItemId, nValue == 1 );
 713         bReturn = true;
 714     }
 715
 716     return bReturn;
 717 }
 718
 719 Any VCLXAccessibleToolBoxItem::getMaximumValue(  )
 720 {
 721     return Any(sal_Int32(1));
 722 }
 723
 724 Any VCLXAccessibleToolBoxItem::getMinimumValue(  )
 725 {
 726     return Any(sal_Int32(0));
 727 }
 728
 729 Any VCLXAccessibleToolBoxItem::getMinimumIncrement(  )
 730 {
 731     return Any(sal_Int32(1));
 732 }
 733
 734
 735 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */