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 <toolkit/helper/convert.hxx>
  22 #include <helper/accresmgr.hxx>
  23 #include <strings.hrc>
  24 #include <com/sun/star/awt/Rectangle.hpp>
  25
  26 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  27 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  28 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  29 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
  30 #include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp>
  31 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  32 #include <comphelper/accessiblecontexthelper.hxx>
  33 #include <cppuhelper/supportsservice.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <vcl/toolbox.hxx>
  36 #include <vcl/unohelp2.hxx>
  37 #include <vcl/help.hxx>
  38 #include <vcl/settings.hxx>
  39 #include <unotools/accessiblerelationsethelper.hxx>
  40 #include <strings.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 = GetText();
  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 OUString VCLXAccessibleToolBoxItem::GetText() const
 118 {
 119     OUString sRet;
 120     // no text for separators and spaces
 121     if ( m_pToolBox && m_nItemId > ToolBoxItemId(0) )
 122     {
 123         sRet = m_pToolBox->GetItemText( m_nItemId );
 124         if (sRet.isEmpty())
 125         {
 126             sRet = m_pToolBox->GetQuickHelpText( m_nItemId );
 127             if (sRet.isEmpty())
 128             {
 129                 vcl::Window* pItemWindow = m_pToolBox->GetItemWindow( m_nItemId );
 130                 if ( m_nRole == AccessibleRole::PANEL && pItemWindow && pItemWindow->GetAccessible().is() &&
 131                      pItemWindow->GetAccessible()->getAccessibleContext().is() )
 132                 {
 133                     OUString sWinText = pItemWindow->GetAccessible()->getAccessibleContext()->getAccessibleName();
 134                     if (!sWinText.isEmpty())
 135                         sRet = sWinText;
 136                 }
 137             }
 138         }
 139
 140     }
 141     return sRet;
 142 }
 143
 144 void VCLXAccessibleToolBoxItem::SetFocus( bool _bFocus )
 145 {
 146     if ( m_bHasFocus != _bFocus )
 147     {
 148         Any aOldValue;
 149         Any aNewValue;
 150         if ( m_bHasFocus )
 151             aOldValue <<= AccessibleStateType::FOCUSED;
 152         else
 153             aNewValue <<= AccessibleStateType::FOCUSED;
 154         m_bHasFocus = _bFocus;
 155         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 156     }
 157 }
 158
 159 void VCLXAccessibleToolBoxItem::SetChecked( bool _bCheck )
 160 {
 161     if( m_nRole == AccessibleRole::PANEL)
 162         return;
 163     if ( m_bIsChecked != _bCheck )
 164     {
 165         Any aOldValue;
 166         Any aNewValue;
 167         if ( m_bIsChecked )
 168             aOldValue <<= AccessibleStateType::CHECKED;
 169         else
 170             aNewValue <<= AccessibleStateType::CHECKED;
 171         m_bIsChecked = _bCheck;
 172         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 173     }
 174 }
 175
 176 void VCLXAccessibleToolBoxItem::SetIndeterminate( bool _bIndeterminate )
 177 {
 178     if ( m_bIndeterminate != _bIndeterminate )
 179     {
 180         Any aOldValue, aNewValue;
 181         if ( m_bIndeterminate )
 182             aOldValue <<= AccessibleStateType::INDETERMINATE;
 183         else
 184             aNewValue <<= AccessibleStateType::INDETERMINATE;
 185         m_bIndeterminate = _bIndeterminate;
 186         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 187     }
 188 }
 189
 190 void VCLXAccessibleToolBoxItem::NameChanged()
 191 {
 192     OUString sNewName = implGetText();
 193     if ( sNewName != m_sOldName )
 194     {
 195         Any aOldValue, aNewValue;
 196         aOldValue <<= m_sOldName;
 197         // save new name as old name for next change
 198         m_sOldName = sNewName;
 199         aNewValue <<= m_sOldName;
 200         NotifyAccessibleEvent( AccessibleEventId::NAME_CHANGED, aOldValue, aNewValue );
 201     }
 202 }
 203
 204 void VCLXAccessibleToolBoxItem::SetChild( const Reference< XAccessible >& _xChild )
 205 {
 206     m_xChild = _xChild;
 207 }
 208
 209 void VCLXAccessibleToolBoxItem::NotifyChildEvent( const Reference< XAccessible >& _xChild, bool _bShow )
 210 {
 211     Any aOld = _bShow ? Any() : Any( _xChild );
 212     Any aNew = _bShow ? Any( _xChild ) : Any();
 213     NotifyAccessibleEvent( AccessibleEventId::CHILD, aOld, aNew );
 214 }
 215
 216 void VCLXAccessibleToolBoxItem::ToggleEnableState()
 217 {
 218     std::array<Any, 2> aOldValue, aNewValue;
 219     if ( m_pToolBox->IsItemEnabled( m_nItemId ) )
 220     {
 221         aNewValue[0] <<= AccessibleStateType::SENSITIVE;
 222         aNewValue[1] <<= AccessibleStateType::ENABLED;
 223     }
 224     else
 225     {
 226         aOldValue[0] <<= AccessibleStateType::ENABLED;
 227         aOldValue[1] <<= AccessibleStateType::SENSITIVE;
 228     }
 229
 230     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] );
 231     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] );
 232 }
 233
 234 awt::Rectangle VCLXAccessibleToolBoxItem::implGetBounds(  )
 235 {
 236     awt::Rectangle aRect;
 237     if ( m_pToolBox )
 238         aRect = AWTRectangle( m_pToolBox->GetItemPosRect( m_nIndexInParent ) );
 239
 240     return aRect;
 241 }
 242
 243 OUString VCLXAccessibleToolBoxItem::implGetText()
 244 {
 245     return GetText();
 246 }
 247
 248 Locale VCLXAccessibleToolBoxItem::implGetLocale()
 249 {
 250     return Application::GetSettings().GetUILanguageTag().getLocale();
 251 }
 252
 253 void VCLXAccessibleToolBoxItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 254 {
 255     nStartIndex = 0;
 256     nEndIndex = 0;
 257 }
 258
 259 // XInterface
 260
 261 Any SAL_CALL VCLXAccessibleToolBoxItem::queryInterface( const Type& _rType )
 262 {
 263     // #i33611# - toolbox buttons without text don't support XAccessibleText
 264     if ( _rType == cppu::UnoType<XAccessibleText>::get()
 265         && ( !m_pToolBox || m_pToolBox->GetButtonType() == ButtonType::SYMBOLONLY ) )
 266         return Any();
 267
 268     return ImplInheritanceHelper::queryInterface( _rType );
 269 }
 270
 271 // XComponent
 272
 273 void SAL_CALL VCLXAccessibleToolBoxItem::disposing()
 274 {
 275     AccessibleTextHelper_BASE::disposing();
 276     m_pToolBox = nullptr;
 277 }
 278
 279 // XServiceInfo
 280
 281 OUString VCLXAccessibleToolBoxItem::getImplementationName()
 282 {
 283     return "com.sun.star.comp.toolkit.AccessibleToolBoxItem";
 284 }
 285
 286 sal_Bool VCLXAccessibleToolBoxItem::supportsService( const OUString& rServiceName )
 287 {
 288     return cppu::supportsService(this, rServiceName);
 289 }
 290
 291 Sequence< OUString > VCLXAccessibleToolBoxItem::getSupportedServiceNames()
 292 {
 293     return {"com.sun.star.accessibility.AccessibleContext",
 294             "com.sun.star.accessibility.AccessibleComponent",
 295             "com.sun.star.accessibility.AccessibleExtendedComponent",
 296             "com.sun.star.accessibility.AccessibleToolBoxItem"};
 297 }
 298
 299 // XAccessible
 300
 301 Reference< XAccessibleContext > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleContext(  )
 302 {
 303     return this;
 304 }
 305
 306 // XAccessibleContext
 307
 308 sal_Int64 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChildCount(  )
 309 {
 310     OContextEntryGuard aGuard( this );
 311
 312     return m_xChild.is() ? 1 : 0;
 313 }
 314
 315 Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleChild( sal_Int64 i )
 316 {
 317     OContextEntryGuard aGuard( this );
 318
 319     // no child -> so index is out of bounds
 320     if ( !m_xChild.is() || i != 0 )
 321         throw IndexOutOfBoundsException();
 322
 323     return m_xChild;
 324 }
 325
 326 Reference< XAccessible > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleParent(  )
 327 {
 328     OContextEntryGuard aGuard( this );
 329
 330     return m_pToolBox->GetAccessible();
 331 }
 332
 333 sal_Int64 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleIndexInParent(  )
 334 {
 335     OContextEntryGuard aGuard( this );
 336
 337     return m_nIndexInParent;
 338 }
 339
 340 sal_Int16 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRole(  )
 341 {
 342     OContextEntryGuard aGuard( this );
 343
 344     return m_nRole;
 345 }
 346
 347 OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleDescription(  )
 348 {
 349     OExternalLockGuard aGuard( this );
 350
 351     if (m_nRole == AccessibleRole::PANEL && m_xChild.is())
 352     {
 353         return AccResId( RID_STR_ACC_PANEL_DESCRIPTION );
 354     }
 355     else
 356     {
 357         OUString sDescription;
 358         if ( m_pToolBox )
 359             sDescription = m_pToolBox->GetHelpText( m_nItemId );
 360         return sDescription;
 361     }
 362 }
 363
 364 OUString SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleName(  )
 365 {
 366     OExternalLockGuard aGuard( this );
 367
 368     // entry text == accessible name
 369     return GetText();
 370 }
 371
 372 Reference< XAccessibleRelationSet > SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleRelationSet(  )
 373 {
 374     OContextEntryGuard aGuard( this );
 375
 376     return new utl::AccessibleRelationSetHelper;
 377 }
 378
 379 sal_Int64 SAL_CALL VCLXAccessibleToolBoxItem::getAccessibleStateSet(  )
 380 {
 381     OExternalLockGuard aGuard( this );
 382
 383     sal_Int64 nStateSet = 0;
 384
 385     if ( m_pToolBox && !rBHelper.bDisposed && !rBHelper.bInDispose )
 386     {
 387         nStateSet |= AccessibleStateType::FOCUSABLE;
 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 GetText();
 417 }
 418
 419 sal_Int32 VCLXAccessibleToolBoxItem::getCharacterCount()
 420 {
 421     return GetText().getLength();
 422 }
 423
 424 sal_Unicode VCLXAccessibleToolBoxItem::getCharacter( sal_Int32 nIndex )
 425 {
 426      OExternalLockGuard aGuard( this );
 427
 428      return OCommonAccessibleText::implGetCharacter( GetText(), nIndex );
 429 }
 430
 431 OUString VCLXAccessibleToolBoxItem::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 432 {
 433      OExternalLockGuard aGuard( this );
 434
 435      return OCommonAccessibleText::implGetTextRange( GetText(), 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, GetText().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 = AWTRectangle( 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( VCLPoint( 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 Reference< awt::XFont > SAL_CALL VCLXAccessibleToolBoxItem::getFont(    )
 598 {
 599     return uno::Reference< awt::XFont >();
 600 }
 601
 602 OUString SAL_CALL VCLXAccessibleToolBoxItem::getTitledBorderText(  )
 603 {
 604     OExternalLockGuard aGuard( this );
 605
 606     OUString sRet;
 607     if ( m_pToolBox )
 608         sRet = m_pToolBox->GetItemText( m_nItemId );
 609
 610     return sRet;
 611 }
 612
 613 OUString SAL_CALL VCLXAccessibleToolBoxItem::getToolTipText(  )
 614 {
 615     OExternalLockGuard aGuard( this );
 616
 617     OUString sRet;
 618     if ( m_pToolBox )
 619     {
 620         if ( Help::IsExtHelpEnabled() )
 621             sRet = m_pToolBox->GetHelpText( m_nItemId );
 622         else
 623             sRet = m_pToolBox->GetQuickHelpText( m_nItemId );
 624         if ( sRet.isEmpty() )
 625             // no help text set, so use item text
 626             sRet = m_pToolBox->GetItemText( m_nItemId );
 627     }
 628     return sRet;
 629 }
 630
 631 // XAccessibleAction
 632
 633 sal_Int32 VCLXAccessibleToolBoxItem::getAccessibleActionCount( )
 634 {
 635     // only one action -> "Click"
 636     return 1;
 637 }
 638
 639 sal_Bool VCLXAccessibleToolBoxItem::doAccessibleAction ( sal_Int32 nIndex )
 640 {
 641     OExternalLockGuard aGuard( this );
 642
 643     if ( nIndex != 0 )
 644         throw IndexOutOfBoundsException();
 645
 646     if ( m_pToolBox )
 647         m_pToolBox->TriggerItem( m_nItemId );
 648
 649     return true;
 650 }
 651
 652 OUString VCLXAccessibleToolBoxItem::getAccessibleActionDescription ( sal_Int32 nIndex )
 653 {
 654     OExternalLockGuard aGuard( this );
 655
 656     if ( nIndex != 0 )
 657         throw IndexOutOfBoundsException();
 658
 659     return RID_STR_ACC_ACTION_CLICK;
 660 }
 661
 662 Reference< XAccessibleKeyBinding > VCLXAccessibleToolBoxItem::getAccessibleActionKeyBinding( sal_Int32 nIndex )
 663 {
 664     OContextEntryGuard aGuard( this );
 665
 666     if ( nIndex != 0 )
 667         throw IndexOutOfBoundsException();
 668
 669     return Reference< XAccessibleKeyBinding >();
 670 }
 671
 672 // XAccessibleValue
 673
 674 Any VCLXAccessibleToolBoxItem::getCurrentValue(  )
 675 {
 676     OExternalLockGuard aGuard( this );
 677
 678     Any aValue;
 679     if ( m_pToolBox )
 680         aValue <<= static_cast<sal_Int32>(m_pToolBox->IsItemChecked( m_nItemId ));
 681
 682     if( m_nRole == AccessibleRole::PANEL )
 683         aValue <<= sal_Int32(0);
 684     return aValue;
 685 }
 686
 687 sal_Bool VCLXAccessibleToolBoxItem::setCurrentValue( const Any& aNumber )
 688 {
 689     OExternalLockGuard aGuard( this );
 690
 691     bool bReturn = false;
 692
 693     if ( m_pToolBox )
 694     {
 695         sal_Int32 nValue = 0;
 696         OSL_VERIFY( aNumber >>= nValue );
 697
 698         if ( nValue < 0 )
 699             nValue = 0;
 700         else if ( nValue > 1 )
 701             nValue = 1;
 702
 703         m_pToolBox->CheckItem( m_nItemId, nValue == 1 );
 704         bReturn = true;
 705     }
 706
 707     return bReturn;
 708 }
 709
 710 Any VCLXAccessibleToolBoxItem::getMaximumValue(  )
 711 {
 712     return Any(sal_Int32(1));
 713 }
 714
 715 Any VCLXAccessibleToolBoxItem::getMinimumValue(  )
 716 {
 717     return Any(sal_Int32(0));
 718 }
 719
 720 Any VCLXAccessibleToolBoxItem::getMinimumIncrement(  )
 721 {
 722     return Any(sal_Int32(1));
 723 }
 724
 725
 726 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */