accessibility/source/standard/vclxaccessiblelistitem.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/vclxaccessiblelistitem.hxx>
  21 #include <helper/IComboListBoxHelper.hxx>
  22 #include <com/sun/star/awt/Rectangle.hpp>
  23
  24 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  25 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  26 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  27 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
  28 #include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp>
  29 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <utility>
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/toolkit/lstbox.hxx>
  34 #include <vcl/unohelp.hxx>
  35 #include <vcl/unohelp2.hxx>
  36 #include <vcl/settings.hxx>
  37 #include <unotools/accessiblerelationsethelper.hxx>
  38 #include <comphelper/accessibleeventnotifier.hxx>
  39 #include <i18nlangtag/languagetag.hxx>
  40
  41 namespace
  42 {
  43     /// @throws css::lang::IndexOutOfBoundsException
  44     void checkIndex_Impl( sal_Int32 _nIndex, std::u16string_view _sText )
  45     {
  46         if ( _nIndex < 0 || _nIndex > static_cast<sal_Int32>(_sText.size()) )
  47             throw css::lang::IndexOutOfBoundsException();
  48     }
  49 }
  50
  51 // class VCLXAccessibleListItem ------------------------------------------
  52
  53 using namespace ::com::sun::star::accessibility;
  54 using namespace ::com::sun::star::uno;
  55 using namespace ::com::sun::star::beans;
  56 using namespace ::com::sun::star::lang;
  57 using namespace ::com::sun::star;
  58
  59
  60 // Ctor() and Dtor()
  61
  62 VCLXAccessibleListItem::VCLXAccessibleListItem(sal_Int32 _nIndexInParent, rtl::Reference< VCLXAccessibleList > _xParent)
  63     : m_nIndexInParent(_nIndexInParent)
  64     , m_bSelected(false)
  65     , m_bVisible(false)
  66     , m_nClientId(0)
  67     , m_xParent(std::move(_xParent))
  68 {
  69     assert(m_xParent.is());
  70     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent->getListBoxHelper();
  71     if (pListBoxHelper)
  72         m_sEntryText = pListBoxHelper->GetEntry(static_cast<sal_uInt16>(_nIndexInParent));
  73 }
  74
  75 void VCLXAccessibleListItem::SetSelected( bool _bSelected )
  76 {
  77     if ( m_bSelected != _bSelected )
  78     {
  79         Any aOldValue;
  80         Any aNewValue;
  81         if ( m_bSelected )
  82             aOldValue <<= AccessibleStateType::SELECTED;
  83         else
  84             aNewValue <<= AccessibleStateType::SELECTED;
  85         m_bSelected = _bSelected;
  86         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
  87     }
  88 }
  89
  90 void VCLXAccessibleListItem::SetVisible( bool _bVisible )
  91 {
  92     if ( m_bVisible != _bVisible )
  93     {
  94         Any aOldValue, aNewValue;
  95         m_bVisible = _bVisible;
  96         (_bVisible ? aNewValue : aOldValue ) <<= AccessibleStateType::VISIBLE;
  97         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
  98         (_bVisible ? aNewValue : aOldValue ) <<= AccessibleStateType::SHOWING;
  99         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 100     }
 101 }
 102
 103 void VCLXAccessibleListItem::NotifyAccessibleEvent( sal_Int16 _nEventId,
 104                                                     const css::uno::Any& _aOldValue,
 105                                                     const css::uno::Any& _aNewValue )
 106 {
 107     AccessibleEventObject aEvt;
 108     aEvt.Source = *this;
 109     aEvt.EventId = _nEventId;
 110     aEvt.OldValue = _aOldValue;
 111     aEvt.NewValue = _aNewValue;
 112
 113     if (m_nClientId)
 114         comphelper::AccessibleEventNotifier::addEvent( m_nClientId, aEvt );
 115 }
 116
 117 // OCommonAccessibleText
 118
 119 OUString VCLXAccessibleListItem::implGetText()
 120 {
 121     return m_sEntryText;
 122 }
 123
 124 Locale VCLXAccessibleListItem::implGetLocale()
 125 {
 126     return Application::GetSettings().GetLanguageTag().getLocale();
 127 }
 128
 129 void VCLXAccessibleListItem::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 130 {
 131     nStartIndex = 0;
 132     nEndIndex = 0;
 133 }
 134
 135 // XTypeProvider
 136
 137 Sequence< sal_Int8 > VCLXAccessibleListItem::getImplementationId()
 138 {
 139     return css::uno::Sequence<sal_Int8>();
 140 }
 141
 142 // XComponent
 143
 144 void VCLXAccessibleListItem::disposing(std::unique_lock<std::mutex>& rGuard)
 145 {
 146     VCLXAccessibleListItem_BASE::disposing(rGuard);
 147
 148     m_sEntryText.clear();
 149     m_xParent           = nullptr;
 150     comphelper::AccessibleEventNotifier::TClientId nId = m_nClientId;
 151     m_nClientId =  0;
 152     Reference< XInterface > xEventSource;
 153     if ( nId )
 154     {
 155         xEventSource = *this;
 156
 157         // Send a disposing to all listeners.
 158         rGuard.unlock();
 159         comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( nId, *this );
 160         rGuard.lock();
 161     }
 162 }
 163
 164 // XServiceInfo
 165
 166 OUString VCLXAccessibleListItem::getImplementationName()
 167 {
 168     return u"com.sun.star.comp.toolkit.AccessibleListItem"_ustr;
 169 }
 170
 171 sal_Bool VCLXAccessibleListItem::supportsService( const OUString& rServiceName )
 172 {
 173     return cppu::supportsService(this, rServiceName);
 174 }
 175
 176 Sequence< OUString > VCLXAccessibleListItem::getSupportedServiceNames()
 177 {
 178     return {u"com.sun.star.accessibility.AccessibleContext"_ustr,
 179             u"com.sun.star.accessibility.AccessibleComponent"_ustr,
 180             u"com.sun.star.accessibility.AccessibleListItem"_ustr};
 181 }
 182
 183 // XAccessible
 184
 185 Reference< XAccessibleContext > SAL_CALL VCLXAccessibleListItem::getAccessibleContext(  )
 186 {
 187     return this;
 188 }
 189
 190 // XAccessibleContext
 191
 192 sal_Int64 SAL_CALL VCLXAccessibleListItem::getAccessibleChildCount(  )
 193 {
 194     return 0;
 195 }
 196
 197 Reference< XAccessible > SAL_CALL VCLXAccessibleListItem::getAccessibleChild( sal_Int64 )
 198 {
 199     return Reference< XAccessible >();
 200 }
 201
 202 Reference< XAccessible > SAL_CALL VCLXAccessibleListItem::getAccessibleParent(  )
 203 {
 204     std::unique_lock aGuard( m_aMutex );
 205
 206     return m_xParent;
 207 }
 208
 209 sal_Int64 SAL_CALL VCLXAccessibleListItem::getAccessibleIndexInParent(  )
 210 {
 211     return m_nIndexInParent;
 212 }
 213
 214 sal_Int16 SAL_CALL VCLXAccessibleListItem::getAccessibleRole(  )
 215 {
 216     return AccessibleRole::LIST_ITEM;
 217     //  return AccessibleRole::LABEL;
 218 }
 219
 220 OUString SAL_CALL VCLXAccessibleListItem::getAccessibleDescription(  )
 221 {
 222     // no description for every item
 223     return OUString();
 224 }
 225
 226 OUString SAL_CALL VCLXAccessibleListItem::getAccessibleName(  )
 227 {
 228     std::unique_lock aGuard( m_aMutex );
 229
 230     // entry text == accessible name
 231     return m_sEntryText;
 232 }
 233
 234 Reference< XAccessibleRelationSet > SAL_CALL VCLXAccessibleListItem::getAccessibleRelationSet(  )
 235 {
 236     return new utl::AccessibleRelationSetHelper;
 237 }
 238
 239 sal_Int64 SAL_CALL VCLXAccessibleListItem::getAccessibleStateSet(  )
 240 {
 241     std::unique_lock aGuard( m_aMutex );
 242
 243     sal_Int64 nStateSet = 0;
 244
 245     if ( !m_bDisposed )
 246     {
 247         nStateSet |= AccessibleStateType::TRANSIENT;
 248
 249         ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 250         if (pListBoxHelper && pListBoxHelper->IsEnabled())
 251         {
 252             nStateSet |= AccessibleStateType::SELECTABLE;
 253             nStateSet |= AccessibleStateType::ENABLED;
 254             nStateSet |= AccessibleStateType::SENSITIVE;
 255         }
 256
 257         if ( m_bSelected )
 258             nStateSet |= AccessibleStateType::SELECTED;
 259         if ( m_bVisible )
 260         {
 261             nStateSet |= AccessibleStateType::VISIBLE;
 262             nStateSet |= AccessibleStateType::SHOWING;
 263         }
 264     }
 265     else
 266         nStateSet |= AccessibleStateType::DEFUNC;
 267
 268     return nStateSet;
 269 }
 270
 271 Locale SAL_CALL VCLXAccessibleListItem::getLocale(  )
 272 {
 273     SolarMutexGuard aSolarGuard;
 274     std::unique_lock aGuard( m_aMutex );
 275
 276     return implGetLocale();
 277 }
 278
 279 // XAccessibleComponent
 280
 281 sal_Bool SAL_CALL VCLXAccessibleListItem::containsPoint( const awt::Point& _aPoint )
 282 {
 283     SolarMutexGuard aSolarGuard;
 284     std::unique_lock aGuard( m_aMutex );
 285
 286     bool bInside = false;
 287     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 288     if (pListBoxHelper)
 289     {
 290         tools::Rectangle aRect(pListBoxHelper->GetBoundingRectangle(static_cast<sal_uInt16>(m_nIndexInParent)));
 291         aRect.Move(-aRect.Left(), -aRect.Top());
 292         bInside = aRect.Contains(vcl::unohelper::ConvertToVCLPoint(_aPoint));
 293     }
 294     return bInside;
 295 }
 296
 297 Reference< XAccessible > SAL_CALL VCLXAccessibleListItem::getAccessibleAtPoint( const awt::Point& )
 298 {
 299     return Reference< XAccessible >();
 300 }
 301
 302 awt::Rectangle SAL_CALL VCLXAccessibleListItem::getBounds(  )
 303 {
 304     SolarMutexGuard aSolarGuard;
 305     std::unique_lock aGuard( m_aMutex );
 306
 307     awt::Rectangle aRect;
 308     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 309     if (pListBoxHelper)
 310         aRect = vcl::unohelper::ConvertToAWTRect(
 311             pListBoxHelper->GetBoundingRectangle(static_cast<sal_uInt16>(m_nIndexInParent)));
 312
 313     return aRect;
 314 }
 315
 316 awt::Point SAL_CALL VCLXAccessibleListItem::getLocation(  )
 317 {
 318     SolarMutexGuard aSolarGuard;
 319     std::unique_lock aGuard( m_aMutex );
 320
 321     Point aPoint(0,0);
 322     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 323     if (pListBoxHelper)
 324     {
 325         tools::Rectangle aRect = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) );
 326         aPoint = aRect.TopLeft();
 327     }
 328     return vcl::unohelper::ConvertToAWTPoint(aPoint);
 329 }
 330
 331 awt::Point SAL_CALL VCLXAccessibleListItem::getLocationOnScreen(  )
 332 {
 333     SolarMutexGuard aSolarGuard;
 334     std::unique_lock aGuard( m_aMutex );
 335
 336     Point aPoint(0,0);
 337     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 338     if (pListBoxHelper)
 339     {
 340         tools::Rectangle aRect = pListBoxHelper->GetBoundingRectangle(static_cast<sal_uInt16>(m_nIndexInParent));
 341         aPoint = aRect.TopLeft();
 342         aPoint += Point(pListBoxHelper->GetWindowExtentsAbsolute().TopLeft());
 343     }
 344     return vcl::unohelper::ConvertToAWTPoint(aPoint);
 345 }
 346
 347 awt::Size SAL_CALL VCLXAccessibleListItem::getSize(  )
 348 {
 349     SolarMutexGuard aSolarGuard;
 350     std::unique_lock aGuard( m_aMutex );
 351
 352     Size aSize;
 353     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 354     if (pListBoxHelper)
 355         aSize = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) ).GetSize();
 356
 357     return vcl::unohelper::ConvertToAWTSize(aSize);
 358 }
 359
 360 void SAL_CALL VCLXAccessibleListItem::grabFocus(  )
 361 {
 362     // no focus for each item
 363 }
 364
 365 // XAccessibleText
 366
 367 sal_Int32 SAL_CALL VCLXAccessibleListItem::getCaretPosition()
 368 {
 369     return -1;
 370 }
 371
 372 sal_Bool SAL_CALL VCLXAccessibleListItem::setCaretPosition( sal_Int32 nIndex )
 373 {
 374     SolarMutexGuard aSolarGuard;
 375     std::unique_lock aGuard( m_aMutex );
 376
 377     if ( !implIsValidRange( nIndex, nIndex, m_sEntryText.getLength() ) )
 378         throw IndexOutOfBoundsException();
 379
 380     return false;
 381 }
 382
 383 sal_Unicode SAL_CALL VCLXAccessibleListItem::getCharacter( sal_Int32 nIndex )
 384 {
 385     SolarMutexGuard aSolarGuard;
 386     std::unique_lock aGuard( m_aMutex );
 387
 388     return OCommonAccessibleText::implGetCharacter( m_sEntryText, nIndex );
 389 }
 390
 391 Sequence< PropertyValue > SAL_CALL VCLXAccessibleListItem::getCharacterAttributes( sal_Int32 nIndex, const Sequence< OUString >& )
 392 {
 393     SolarMutexGuard aSolarGuard;
 394     std::unique_lock aGuard( m_aMutex );
 395
 396     if ( !implIsValidIndex( nIndex, m_sEntryText.getLength() ) )
 397         throw IndexOutOfBoundsException();
 398
 399     return Sequence< PropertyValue >();
 400 }
 401
 402 awt::Rectangle SAL_CALL VCLXAccessibleListItem::getCharacterBounds( sal_Int32 nIndex )
 403 {
 404     SolarMutexGuard aSolarGuard;
 405     std::unique_lock aGuard( m_aMutex );
 406
 407     if ( !implIsValidIndex( nIndex, m_sEntryText.getLength() ) )
 408         throw IndexOutOfBoundsException();
 409
 410     awt::Rectangle aBounds( 0, 0, 0, 0 );
 411     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 412     if (pListBoxHelper)
 413     {
 414         tools::Rectangle aCharRect = pListBoxHelper->GetEntryCharacterBounds( m_nIndexInParent, nIndex );
 415         tools::Rectangle aItemRect = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) );
 416         aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() );
 417         aBounds = vcl::unohelper::ConvertToAWTRect(aCharRect);
 418     }
 419
 420     return aBounds;
 421 }
 422
 423 sal_Int32 SAL_CALL VCLXAccessibleListItem::getCharacterCount()
 424 {
 425     std::unique_lock aGuard( m_aMutex );
 426
 427     return m_sEntryText.getLength();
 428 }
 429
 430 sal_Int32 SAL_CALL VCLXAccessibleListItem::getIndexAtPoint( const awt::Point& aPoint )
 431 {
 432     SolarMutexGuard aSolarGuard;
 433     std::unique_lock aGuard( m_aMutex );
 434
 435     sal_Int32 nIndex = -1;
 436     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 437     if (pListBoxHelper)
 438     {
 439         sal_Int32 nPos = LISTBOX_ENTRY_NOTFOUND;
 440         tools::Rectangle aItemRect = pListBoxHelper->GetBoundingRectangle( static_cast<sal_uInt16>(m_nIndexInParent) );
 441         Point aPnt(vcl::unohelper::ConvertToVCLPoint(aPoint));
 442         aPnt += aItemRect.TopLeft();
 443         sal_Int32 nI = pListBoxHelper->GetIndexForPoint( aPnt, nPos );
 444         if ( nI != -1 && m_nIndexInParent == nPos )
 445             nIndex = nI;
 446     }
 447     return nIndex;
 448 }
 449
 450 OUString SAL_CALL VCLXAccessibleListItem::getSelectedText()
 451 {
 452     return OUString();
 453 }
 454
 455 sal_Int32 SAL_CALL VCLXAccessibleListItem::getSelectionStart()
 456 {
 457     return 0;
 458 }
 459
 460 sal_Int32 SAL_CALL VCLXAccessibleListItem::getSelectionEnd()
 461 {
 462     return 0;
 463 }
 464
 465 sal_Bool SAL_CALL VCLXAccessibleListItem::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 466 {
 467     std::unique_lock aGuard( m_aMutex );
 468
 469     if ( !implIsValidRange( nStartIndex, nEndIndex, m_sEntryText.getLength() ) )
 470         throw IndexOutOfBoundsException();
 471
 472     return false;
 473 }
 474
 475 OUString SAL_CALL VCLXAccessibleListItem::getText()
 476 {
 477     std::unique_lock aGuard( m_aMutex );
 478
 479     return m_sEntryText;
 480 }
 481
 482 OUString VCLXAccessibleListItem::getTextRangeImpl(std::unique_lock<std::mutex>& /*rGuard*/, sal_Int32 nStartIndex, sal_Int32 nEndIndex)
 483 {
 484     return OCommonAccessibleText::implGetTextRange(m_sEntryText, nStartIndex, nEndIndex);
 485 }
 486
 487 OUString SAL_CALL VCLXAccessibleListItem::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 488 {
 489     SolarMutexGuard aSolarGuard;
 490     std::unique_lock aGuard( m_aMutex );
 491
 492     return getTextRangeImpl(aGuard, nStartIndex, nEndIndex);
 493 }
 494
 495 css::accessibility::TextSegment SAL_CALL VCLXAccessibleListItem::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType )
 496 {
 497     SolarMutexGuard aSolarGuard;
 498     std::unique_lock aGuard( m_aMutex );
 499
 500     return OCommonAccessibleText::getTextAtIndex( nIndex, aTextType );
 501 }
 502
 503 css::accessibility::TextSegment SAL_CALL VCLXAccessibleListItem::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType )
 504 {
 505     SolarMutexGuard aSolarGuard;
 506     std::unique_lock aGuard( m_aMutex );
 507
 508     return OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType );
 509 }
 510
 511 css::accessibility::TextSegment SAL_CALL VCLXAccessibleListItem::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType )
 512 {
 513     SolarMutexGuard aSolarGuard;
 514     std::unique_lock aGuard( m_aMutex );
 515
 516     return OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType );
 517 }
 518
 519 sal_Bool SAL_CALL VCLXAccessibleListItem::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 520 {
 521     SolarMutexGuard aSolarGuard;
 522     std::unique_lock aGuard( m_aMutex );
 523
 524     checkIndex_Impl( nStartIndex, m_sEntryText );
 525     checkIndex_Impl( nEndIndex, m_sEntryText );
 526
 527     bool bRet = false;
 528     ::accessibility::IComboListBoxHelper* pListBoxHelper = m_xParent.is() ? m_xParent->getListBoxHelper() : nullptr;
 529     if (pListBoxHelper)
 530     {
 531         Reference< datatransfer::clipboard::XClipboard > xClipboard = pListBoxHelper->GetClipboard();
 532         if ( xClipboard.is() )
 533         {
 534             OUString sText(getTextRangeImpl(aGuard, nStartIndex, nEndIndex));
 535             rtl::Reference<vcl::unohelper::TextDataObject> pDataObj = new vcl::unohelper::TextDataObject( sText );
 536
 537             SolarMutexReleaser aReleaser;
 538             xClipboard->setContents( pDataObj, nullptr );
 539             Reference< datatransfer::clipboard::XFlushableClipboard > xFlushableClipboard( xClipboard, uno::UNO_QUERY );
 540             if( xFlushableClipboard.is() )
 541                 xFlushableClipboard->flushClipboard();
 542
 543             bRet = true;
 544         }
 545     }
 546
 547     return bRet;
 548 }
 549
 550 sal_Bool VCLXAccessibleListItem::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType )
 551 {
 552     return false;
 553 }
 554
 555 // XAccessibleEventBroadcaster
 556
 557 void SAL_CALL VCLXAccessibleListItem::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 558 {
 559     if (xListener.is())
 560     {
 561         if (!m_nClientId)
 562             m_nClientId = comphelper::AccessibleEventNotifier::registerClient( );
 563         comphelper::AccessibleEventNotifier::addEventListener( m_nClientId, xListener );
 564     }
 565 }
 566
 567 void SAL_CALL VCLXAccessibleListItem::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 568 {
 569     if ( !(xListener.is() && m_nClientId) )
 570         return;
 571
 572     sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( m_nClientId, xListener );
 573     if ( nListenerCount )
 574         return;
 575
 576     // no listeners anymore
 577     // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 578     // and at least to us not firing any events anymore, in case somebody calls
 579     // NotifyAccessibleEvent, again
 580     if ( m_nClientId )
 581     {
 582         comphelper::AccessibleEventNotifier::TClientId nId( m_nClientId );
 583         m_nClientId = 0;
 584         comphelper::AccessibleEventNotifier::revokeClient( nId );
 585     }
 586 }
 587
 588
 589 // AF (Oct. 29 2002): Return black as constant foreground color.  This is an
 590 // initial implementation and has to be substituted by code that determines
 591 // the color that is actually used.
 592 sal_Int32 SAL_CALL VCLXAccessibleListItem::getForeground()
 593 {
 594     return sal_Int32(COL_BLACK);
 595 }
 596
 597 // AF (Oct. 29 2002): Return white as constant background color.  This is an
 598 // initial implementation and has to be substituted by code that determines
 599 // the color that is actually used.
 600 sal_Int32 SAL_CALL VCLXAccessibleListItem::getBackground()
 601 {
 602     return sal_Int32(COL_WHITE);
 603 }
 604
 605
 606 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */