accessibility/source/standard/vclxaccessiblelist.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: vclxaccessiblelist.cxx,v $
  10  * $Revision: 1.4 $
  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 #include <accessibility/standard/vclxaccessiblelist.hxx>
  34 #include <accessibility/standard/vclxaccessiblelistitem.hxx>
  35 #include <accessibility/helper/listboxhelper.hxx>
  36
  37 #include <unotools/accessiblestatesethelper.hxx>
  38 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  39 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  40 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  41 #include <vcl/svapp.hxx>
  42 #include <vcl/combobox.hxx>
  43 #include <vcl/lstbox.hxx>
  44 #include <toolkit/helper/convert.hxx>
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::uno;
  48 using namespace ::com::sun::star::lang;
  49 using namespace ::com::sun::star::beans;
  50 using namespace ::com::sun::star::accessibility;
  51 using namespace ::accessibility;
  52
  53 namespace
  54 {
  55     void checkSelection_Impl( sal_Int32 _nIndex, const IComboListBoxHelper& _rListBox, sal_Bool bSelected )
  56         throw (::com::sun::star::lang::IndexOutOfBoundsException)
  57     {
  58         sal_Int32 nCount = bSelected ? (sal_Int32)_rListBox.GetSelectEntryCount()
  59                                      : (sal_Int32)_rListBox.GetEntryCount();
  60         if ( _nIndex < 0 || _nIndex >= nCount )
  61             throw ::com::sun::star::lang::IndexOutOfBoundsException();
  62     }
  63 }
  64
  65 VCLXAccessibleList::VCLXAccessibleList (VCLXWindow* pVCLWindow, BoxType aBoxType,
  66                                         const Reference< XAccessible >& _xParent)
  67     : VCLXAccessibleComponent   (pVCLWindow),
  68       m_aBoxType                                (aBoxType),
  69       m_nVisibleLineCount               (0),
  70       m_nIndexInParent                  (DEFAULT_INDEX_IN_PARENT),
  71       m_nLastTopEntry                   ( 0 ),
  72       m_nLastSelectedPos                ( LISTBOX_ENTRY_NOTFOUND ),
  73       m_bDisableProcessEvent    ( false ),
  74       m_bVisible                                ( true ),
  75       m_xParent                 ( _xParent )
  76 {
  77     // Because combo boxes and list boxes have the no common interface for
  78     // methods with identical signature we have to write down twice the
  79     // same code.
  80     switch (m_aBoxType)
  81     {
  82         case COMBOBOX:
  83         {
  84             ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
  85             if ( pBox != NULL )
  86                 m_pListBoxHelper = new VCLListBoxHelper<ComboBox> (*pBox);
  87             break;
  88         }
  89
  90         case LISTBOX:
  91         {
  92             ListBox* pBox = static_cast<ListBox*>(GetWindow());
  93             if ( pBox != NULL )
  94                 m_pListBoxHelper = new VCLListBoxHelper<ListBox> (*pBox);
  95             break;
  96         }
  97     }
  98     UpdateVisibleLineCount();
  99
 100     USHORT nCount = static_cast<USHORT>(getAccessibleChildCount());
 101     m_aAccessibleChildren.reserve(nCount);
 102 }
 103 // -----------------------------------------------------------------------------
 104
 105 VCLXAccessibleList::~VCLXAccessibleList (void)
 106 {
 107     delete m_pListBoxHelper;
 108 }
 109 // -----------------------------------------------------------------------------
 110
 111 void VCLXAccessibleList::SetIndexInParent (sal_Int32 nIndex)
 112 {
 113     m_nIndexInParent = nIndex;
 114 }
 115 // -----------------------------------------------------------------------------
 116
 117 void SAL_CALL VCLXAccessibleList::disposing (void)
 118 {
 119     VCLXAccessibleComponent::disposing();
 120
 121     // Dispose all items in the list.
 122     clearItems();
 123
 124     delete m_pListBoxHelper;
 125     m_pListBoxHelper = NULL;
 126 }
 127 // -----------------------------------------------------------------------------
 128
 129 void VCLXAccessibleList::clearItems()
 130 {
 131 //      ListItems::iterator aEnd = m_aAccessibleChildren.end();
 132 //      for (ListItems::iterator aIter = m_aAccessibleChildren.begin(); aIter != aEnd; ++aIter)
 133 //              ::comphelper::disposeComponent(*aIter);
 134
 135     // Clear the list itself and delete all the rest.
 136     ListItems().swap(m_aAccessibleChildren); // clear and minimize
 137 }
 138 // -----------------------------------------------------------------------------
 139
 140 void VCLXAccessibleList::FillAccessibleStateSet (utl::AccessibleStateSetHelper& rStateSet)
 141 {
 142     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 143
 144     VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
 145     // check if our list should be visible
 146     if (        m_pListBoxHelper
 147         && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN
 148         && !m_pListBoxHelper->IsInDropDown() )
 149     {
 150         rStateSet.RemoveState (AccessibleStateType::VISIBLE);
 151         rStateSet.RemoveState (AccessibleStateType::SHOWING);
 152         m_bVisible = false;
 153     }
 154
 155     // Both the combo box and list box are handled identical in the
 156     // following but for some reason they don't have a common interface for
 157     // the methods used.
 158     if ( m_pListBoxHelper )
 159     {
 160         if ( m_pListBoxHelper->IsMultiSelectionEnabled() )
 161             rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE);
 162         rStateSet.AddState (AccessibleStateType::FOCUSABLE);
 163         // All children are transient.
 164         rStateSet.AddState (AccessibleStateType::MANAGES_DESCENDANTS);
 165     }
 166 }
 167 // -----------------------------------------------------------------------------
 168 void VCLXAccessibleList::notifyVisibleStates(sal_Bool _bSetNew )
 169 {
 170     m_bVisible = _bSetNew ? true : false;
 171     Any aOldValue, aNewValue;
 172     (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::VISIBLE;
 173     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 174     (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::SHOWING;
 175     NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 176
 177     ListItems::iterator aIter = m_aAccessibleChildren.begin();
 178     ListItems::iterator aEnd = m_aAccessibleChildren.end();
 179     UpdateVisibleLineCount();
 180     // adjust the index inside the VCLXAccessibleListItem
 181     for (;aIter != aEnd ; ++aIter)
 182     {
 183         Reference< XAccessible > xHold = *aIter;
 184         VCLXAccessibleListItem* pItem = static_cast<VCLXAccessibleListItem*>(xHold.get());
 185         if ( pItem )
 186         {
 187             USHORT nTopEntry = 0;
 188             if ( m_pListBoxHelper )
 189                 nTopEntry = m_pListBoxHelper->GetTopEntry();
 190             USHORT nPos = (USHORT)(aIter - m_aAccessibleChildren.begin());
 191             sal_Bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) );
 192             pItem->SetVisible( m_bVisible && bVisible );
 193         }
 194
 195     }
 196 }
 197 // -----------------------------------------------------------------------------
 198 void VCLXAccessibleList::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent)
 199 {
 200     // Create a reference to this object to prevent an early release of the
 201     // listbox (VCLEVENT_OBJECT_DYING).
 202     Reference< XAccessible > xTemp = this;
 203
 204     switch ( rVclWindowEvent.GetId() )
 205     {
 206         case VCLEVENT_DROPDOWN_OPEN:
 207             notifyVisibleStates(sal_True);
 208             break;
 209         case VCLEVENT_DROPDOWN_CLOSE:
 210             notifyVisibleStates(sal_False);
 211             break;
 212         case VCLEVENT_LISTBOX_SCROLLED:
 213         case VCLEVENT_COMBOBOX_SCROLLED:
 214             UpdateEntryRange_Impl();
 215             break;
 216
 217         case VCLEVENT_LISTBOX_SELECT:
 218             if ( !m_bDisableProcessEvent )
 219                 UpdateSelection_Impl();
 220             break;
 221         // The selection events VCLEVENT_COMBOBOX_SELECT and
 222         // VCLEVENT_COMBOBOX_DESELECT are not handled here because here we
 223         // have no access to the edit field.  Its text is necessary to
 224         // identify the currently selected item.
 225
 226         case VCLEVENT_OBJECT_DYING:
 227         {
 228             dispose();
 229
 230             VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
 231             break;
 232         }
 233
 234         case VCLEVENT_LISTBOX_ITEMREMOVED:
 235         case VCLEVENT_COMBOBOX_ITEMREMOVED:
 236             HandleChangedItemList (false, reinterpret_cast<sal_IntPtr>(
 237                 rVclWindowEvent.GetData()));
 238             break;
 239
 240         case VCLEVENT_LISTBOX_ITEMADDED:
 241         case VCLEVENT_COMBOBOX_ITEMADDED:
 242             HandleChangedItemList (true, reinterpret_cast<sal_IntPtr>(
 243                 rVclWindowEvent.GetData()));
 244             break;
 245         case VCLEVENT_CONTROL_GETFOCUS:
 246             VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
 247             if ( m_pListBoxHelper )
 248             {
 249                 uno::Any        aOldValue,
 250                             aNewValue;
 251                 USHORT nPos = m_pListBoxHelper->GetSelectEntryPos();
 252                 if ( nPos == LISTBOX_ENTRY_NOTFOUND )
 253                     nPos = m_pListBoxHelper->GetTopEntry();
 254                 if ( nPos != LISTBOX_ENTRY_NOTFOUND )
 255                     aNewValue <<= CreateChild(nPos);
 256
 257                 NotifyAccessibleEvent(  AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
 258                                         aOldValue,
 259                                         aNewValue );
 260             }
 261             break;
 262
 263         default:
 264             VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
 265     }
 266 }
 267 // -----------------------------------------------------------------------------
 268
 269 /** To find out which item is currently selected and to update the SELECTED
 270     state of the associated accessibility objects accordingly we exploit the
 271     fact that the
 272 */
 273 void VCLXAccessibleList::UpdateSelection (::rtl::OUString sTextOfSelectedItem)
 274 {
 275     if ( m_aBoxType == COMBOBOX )
 276     {
 277         ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
 278         if ( pBox != NULL )
 279         {
 280             // Find the index of the selected item inside the VCL control...
 281             USHORT nIndex = pBox->GetEntryPos (XubString(sTextOfSelectedItem));
 282             // ...and then find the associated accessibility object.
 283             if ( nIndex == LISTBOX_ENTRY_NOTFOUND )
 284                 nIndex = 0;
 285             UpdateSelection_Impl(nIndex);
 286         }
 287     }
 288 }
 289 // -----------------------------------------------------------------------------
 290
 291 void VCLXAccessibleList::adjustEntriesIndexInParent(ListItems::iterator& _aBegin,::std::mem_fun_t<bool,VCLXAccessibleListItem>& _rMemFun)
 292 {
 293     ListItems::iterator aIter = _aBegin;
 294     ListItems::iterator aEnd = m_aAccessibleChildren.end();
 295     // adjust the index inside the VCLXAccessibleListItem
 296     for (;aIter != aEnd ; ++aIter)
 297     {
 298         Reference< XAccessible > xHold = *aIter;
 299         VCLXAccessibleListItem* pItem = static_cast<VCLXAccessibleListItem*>(xHold.get());
 300         if ( pItem )
 301             _rMemFun(pItem);
 302     }
 303 }
 304 // -----------------------------------------------------------------------------
 305
 306 Reference<XAccessible> VCLXAccessibleList::CreateChild (sal_Int32 i)
 307 {
 308     Reference<XAccessible> xChild;
 309
 310     USHORT nPos = static_cast<USHORT>(i);
 311     if ( nPos >= m_aAccessibleChildren.size() )
 312     {
 313         m_aAccessibleChildren.resize(nPos + 1);
 314
 315         // insert into the container
 316         xChild = new VCLXAccessibleListItem(m_pListBoxHelper, i, this);
 317         m_aAccessibleChildren[nPos] = xChild;
 318     }
 319     else
 320     {
 321         xChild = m_aAccessibleChildren[nPos];
 322         // check if position is empty and can be used else we have to adjust all entries behind this
 323         if ( xChild.is() )
 324         {
 325             ListItems::iterator aIter = m_aAccessibleChildren.begin() + nPos;
 326             ::std::mem_fun_t<bool, VCLXAccessibleListItem> aTemp(&VCLXAccessibleListItem::IncrementIndexInParent);
 327             adjustEntriesIndexInParent( aIter, aTemp);
 328         }
 329         else
 330         {
 331             xChild = new VCLXAccessibleListItem(m_pListBoxHelper, i, this);
 332             m_aAccessibleChildren[nPos] = xChild;
 333         }
 334     }
 335
 336     if ( xChild.is() )
 337     {
 338         // Just add the SELECTED state.
 339         BOOL bNowSelected = FALSE;
 340         if ( m_pListBoxHelper )
 341             bNowSelected = m_pListBoxHelper->IsEntryPosSelected ((USHORT)i);
 342         VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >(xChild.get());
 343         pItem->SetSelected( bNowSelected );
 344
 345         // Set the child's VISIBLE state.
 346         UpdateVisibleLineCount();
 347         USHORT nTopEntry = 0;
 348         if ( m_pListBoxHelper )
 349             nTopEntry = m_pListBoxHelper->GetTopEntry();
 350         sal_Bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) );
 351         pItem->SetVisible( m_bVisible && bVisible );
 352     }
 353
 354     return xChild;
 355 }
 356 // -----------------------------------------------------------------------------
 357
 358 void VCLXAccessibleList::HandleChangedItemList (bool bItemInserted, sal_Int32 nIndex)
 359 {
 360     if ( !bItemInserted )
 361     {
 362         if ( nIndex == -1 ) // special handling here
 363         {
 364             clearItems();
 365         }
 366         else
 367         {
 368             if ( nIndex >= 0 && static_cast<USHORT>(nIndex) < m_aAccessibleChildren.size() )
 369             {
 370                 ListItems::iterator aIter = m_aAccessibleChildren.erase(m_aAccessibleChildren.begin()+nIndex);
 371             ::std::mem_fun_t<bool, VCLXAccessibleListItem> aTemp(&VCLXAccessibleListItem::DecrementIndexInParent);
 372                 adjustEntriesIndexInParent(     aIter, aTemp );
 373             }
 374         }
 375     }
 376     else
 377         getAccessibleChild(nIndex);
 378
 379     NotifyAccessibleEvent (
 380         AccessibleEventId::INVALIDATE_ALL_CHILDREN,
 381         Any(), Any());
 382 }
 383 // -----------------------------------------------------------------------------
 384
 385 IMPLEMENT_FORWARD_XINTERFACE2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE)
 386 IMPLEMENT_FORWARD_XTYPEPROVIDER2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE)
 387
 388 //=====  XAccessible  =========================================================
 389
 390 Reference<XAccessibleContext> SAL_CALL
 391     VCLXAccessibleList::getAccessibleContext (void)
 392     throw (RuntimeException)
 393 {
 394     return this;
 395 }
 396 // -----------------------------------------------------------------------------
 397
 398 //=====  XAccessibleContext  ==================================================
 399
 400 sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleChildCount (void)
 401     throw (RuntimeException)
 402 {
 403     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 404     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 405
 406     sal_Int32 nCount = 0;
 407     if ( m_pListBoxHelper )
 408         nCount = m_pListBoxHelper->GetEntryCount();
 409
 410     return nCount;
 411 }
 412 // -----------------------------------------------------------------------------
 413
 414 Reference<XAccessible> SAL_CALL VCLXAccessibleList::getAccessibleChild (sal_Int32 i)
 415     throw (IndexOutOfBoundsException, RuntimeException)
 416 {
 417     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 418     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 419
 420     if ( i < 0 || i >= getAccessibleChildCount() )
 421         throw IndexOutOfBoundsException();
 422
 423     Reference< XAccessible > xChild;
 424     // search for the child
 425     if ( static_cast<USHORT>(i) >= m_aAccessibleChildren.size() )
 426         xChild = CreateChild (i);
 427     else
 428     {
 429         xChild = m_aAccessibleChildren[i];
 430         if ( !xChild.is() )
 431             xChild = CreateChild (i);
 432     }
 433     OSL_ENSURE( xChild.is(), "VCLXAccessibleList::getAccessibleChild: returning empty child!" );
 434     return xChild;
 435 }
 436 // -----------------------------------------------------------------------------
 437
 438 Reference< XAccessible > SAL_CALL VCLXAccessibleList::getAccessibleParent(  )
 439     throw (RuntimeException)
 440 {
 441     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 442
 443     return m_xParent;
 444 }
 445 // -----------------------------------------------------------------------------
 446
 447 sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleIndexInParent (void)
 448     throw (::com::sun::star::uno::RuntimeException)
 449 {
 450     if (m_nIndexInParent != DEFAULT_INDEX_IN_PARENT)
 451         return m_nIndexInParent;
 452     else
 453         return VCLXAccessibleComponent::getAccessibleIndexInParent();
 454 }
 455 // -----------------------------------------------------------------------------
 456
 457 sal_Int16 SAL_CALL VCLXAccessibleList::getAccessibleRole (void)
 458     throw (RuntimeException)
 459 {
 460     return AccessibleRole::LIST;
 461 }
 462 // -----------------------------------------------------------------------------
 463
 464 //=====  XAccessibleComponent  ================================================
 465
 466 sal_Bool SAL_CALL VCLXAccessibleList::contains( const awt::Point& rPoint ) throw (RuntimeException)
 467 {
 468     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 469     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 470
 471     sal_Bool bInside = sal_False;
 472
 473     Window* pListBox = GetWindow();
 474     if ( pListBox )
 475     {
 476         Rectangle aRect( Point(0,0), pListBox->GetSizePixel() );
 477         bInside = aRect.IsInside( VCLPoint( rPoint ) );
 478     }
 479
 480     return bInside;
 481 }
 482 // -----------------------------------------------------------------------------
 483
 484 Reference< XAccessible > SAL_CALL VCLXAccessibleList::getAccessibleAt( const awt::Point& rPoint )
 485     throw (RuntimeException)
 486 {
 487     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 488     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 489
 490     Reference< XAccessible > xChild;
 491     if ( m_pListBoxHelper )
 492     {
 493         UpdateVisibleLineCount();
 494         if ( contains( rPoint ) && m_nVisibleLineCount > 0 )
 495         {
 496             Point aPos = VCLPoint( rPoint );
 497             USHORT nEndPos = m_pListBoxHelper->GetTopEntry() + (USHORT)m_nVisibleLineCount;
 498             for ( USHORT i = m_pListBoxHelper->GetTopEntry(); i < nEndPos; ++i )
 499             {
 500                 if ( m_pListBoxHelper->GetBoundingRectangle(i).IsInside( aPos ) )
 501                 {
 502                     xChild = getAccessibleChild(i);
 503                     break;
 504                 }
 505             }
 506         }
 507     }
 508
 509     return xChild;
 510 }
 511 // -----------------------------------------------------------------------------
 512
 513 //===== XServiceInfo ==========================================================
 514
 515 ::rtl::OUString VCLXAccessibleList::getImplementationName (void)
 516     throw (RuntimeException)
 517 {
 518     return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.toolkit.AccessibleList"));
 519 }
 520 // -----------------------------------------------------------------------------
 521
 522 Sequence< ::rtl::OUString > VCLXAccessibleList::getSupportedServiceNames (void)
 523     throw (RuntimeException)
 524 {
 525     Sequence< ::rtl::OUString > aNames = VCLXAccessibleComponent::getSupportedServiceNames();
 526     sal_Int32 nLength = aNames.getLength();
 527     aNames.realloc( nLength + 1 );
 528     aNames[nLength] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.accessibility.AccessibleList"));
 529     return aNames;
 530 }
 531 // -----------------------------------------------------------------------------
 532
 533 void VCLXAccessibleList::UpdateVisibleLineCount()
 534 {
 535     if ( m_pListBoxHelper )
 536     {
 537         if ( (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
 538             m_nVisibleLineCount = m_pListBoxHelper->GetDisplayLineCount();
 539         else
 540         {
 541             USHORT nCols = 0,
 542                 nLines = 0;
 543             m_pListBoxHelper->GetMaxVisColumnsAndLines (nCols, nLines);
 544             m_nVisibleLineCount = nLines;
 545         }
 546     }
 547 }
 548
 549 // -----------------------------------------------------------------------------
 550 void VCLXAccessibleList::UpdateEntryRange_Impl()
 551 {
 552     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 553     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 554
 555     sal_Int32 nTop = m_nLastTopEntry;
 556
 557     if ( m_pListBoxHelper )
 558         nTop = m_pListBoxHelper->GetTopEntry();
 559     if ( nTop != m_nLastTopEntry )
 560     {
 561         UpdateVisibleLineCount();
 562         sal_Int32 nBegin = Min( m_nLastTopEntry, nTop );
 563         sal_Int32 nEnd = Max( m_nLastTopEntry + m_nVisibleLineCount, nTop + m_nVisibleLineCount );
 564         for (USHORT i = static_cast<USHORT>(nBegin); (i <= static_cast<USHORT>(nEnd)); ++i)
 565         {
 566             sal_Bool bVisible = ( i >= nTop && i < ( nTop + m_nVisibleLineCount ) );
 567             Reference< XAccessible > xHold;
 568             if ( i < m_aAccessibleChildren.size() )
 569                 xHold = m_aAccessibleChildren[i];
 570             else if ( bVisible )
 571                 xHold = CreateChild(i);
 572
 573             if ( xHold.is() )
 574                 static_cast< VCLXAccessibleListItem* >( xHold.get() )->SetVisible( m_bVisible && bVisible );
 575         }
 576     }
 577
 578     m_nLastTopEntry = nTop;
 579 }
 580 // -----------------------------------------------------------------------------
 581 BOOL VCLXAccessibleList::checkEntrySelected(USHORT _nPos,Any& _rNewValue,Reference< XAccessible >& _rxNewAcc)
 582 {
 583     OSL_ENSURE(m_pListBoxHelper,"Helper is not valid!");
 584     BOOL bNowSelected = FALSE;
 585     if ( m_pListBoxHelper )
 586     {
 587         bNowSelected = m_pListBoxHelper->IsEntryPosSelected (_nPos);
 588         if ( bNowSelected )
 589         {
 590             _rxNewAcc = CreateChild(_nPos);
 591             _rNewValue <<= _rxNewAcc;
 592         }
 593     }
 594     return bNowSelected;
 595 }
 596 // -----------------------------------------------------------------------------
 597
 598 void VCLXAccessibleList::UpdateSelection_Impl(USHORT)
 599 {
 600     uno::Any aOldValue, aNewValue;
 601
 602     {
 603         vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 604         ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 605         Reference< XAccessible > xNewAcc;
 606
 607         if ( m_pListBoxHelper )
 608         {
 609             USHORT i=0;
 610             for ( ListItems::iterator aIter = m_aAccessibleChildren.begin();
 611                   aIter != m_aAccessibleChildren.end(); ++aIter,++i)
 612             {
 613                 Reference< XAccessible > xHold = *aIter;
 614                 if ( xHold.is() )
 615                 {
 616                     VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >( xHold.get() );
 617                     // Retrieve the item's index from the list entry.
 618                     BOOL bNowSelected = m_pListBoxHelper->IsEntryPosSelected (i);
 619
 620                     if ( bNowSelected && !pItem->IsSelected() )
 621                     {
 622                         xNewAcc = *aIter;
 623                         aNewValue <<= xNewAcc;
 624                     }
 625                     else if ( pItem->IsSelected() )
 626                         m_nLastSelectedPos = i;
 627
 628                     pItem->SetSelected( bNowSelected );
 629                 }
 630                 else
 631                 { // it could happen that a child was not created before
 632                     checkEntrySelected(i,aNewValue,xNewAcc);
 633                 }
 634             }
 635             USHORT nCount = m_pListBoxHelper->GetEntryCount();
 636             if ( i < nCount ) // here we have to check the if any other listbox entry is selected
 637             {
 638                 for (; i < nCount && !checkEntrySelected(i,aNewValue,xNewAcc) ;++i )
 639                     ;
 640             }
 641             if ( xNewAcc.is() && GetWindow()->HasFocus() )
 642             {
 643                 if ( m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND )
 644                     aOldValue <<= getAccessibleChild( (sal_Int32)m_nLastSelectedPos );
 645                 aNewValue <<= xNewAcc;
 646             }
 647         }
 648     }
 649
 650     if ( aNewValue.hasValue() || aOldValue.hasValue() )
 651         NotifyAccessibleEvent(
 652             AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
 653             aOldValue,
 654             aNewValue );
 655
 656     NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
 657 }
 658
 659 // -----------------------------------------------------------------------------
 660 // XAccessibleSelection
 661 // -----------------------------------------------------------------------------
 662 void SAL_CALL VCLXAccessibleList::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 663 {
 664     sal_Bool bNotify = sal_False;
 665
 666     {
 667         vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 668         ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 669
 670         if ( m_pListBoxHelper )
 671         {
 672             checkSelection_Impl(nChildIndex,*m_pListBoxHelper,sal_False);
 673
 674             m_pListBoxHelper->SelectEntryPos( (USHORT)nChildIndex, TRUE );
 675             // call the select handler, don't handle events in this time
 676             m_bDisableProcessEvent = true;
 677             m_pListBoxHelper->Select();
 678             m_bDisableProcessEvent = false;
 679             bNotify = sal_True;
 680         }
 681     }
 682
 683     if ( bNotify )
 684         UpdateSelection_Impl();
 685 }
 686 // -----------------------------------------------------------------------------
 687 sal_Bool SAL_CALL VCLXAccessibleList::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 688 {
 689     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 690     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 691
 692     sal_Bool bRet = sal_False;
 693     if ( m_pListBoxHelper )
 694     {
 695         checkSelection_Impl(nChildIndex,*m_pListBoxHelper,sal_False);
 696
 697         bRet = m_pListBoxHelper->IsEntryPosSelected( (USHORT)nChildIndex );
 698     }
 699     return bRet;
 700 }
 701 // -----------------------------------------------------------------------------
 702 void SAL_CALL VCLXAccessibleList::clearAccessibleSelection(  ) throw (RuntimeException)
 703 {
 704     sal_Bool bNotify = sal_False;
 705
 706     {
 707         vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 708         ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 709
 710         if ( m_pListBoxHelper )
 711         {
 712             m_pListBoxHelper->SetNoSelection();
 713             bNotify = sal_True;
 714         }
 715     }
 716
 717     if ( bNotify )
 718         UpdateSelection_Impl();
 719 }
 720 // -----------------------------------------------------------------------------
 721 void SAL_CALL VCLXAccessibleList::selectAllAccessibleChildren(  ) throw (RuntimeException)
 722 {
 723     sal_Bool bNotify = sal_False;
 724
 725     {
 726         vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 727         ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 728
 729         if ( m_pListBoxHelper )
 730         {
 731             USHORT nCount = m_pListBoxHelper->GetEntryCount();
 732             for ( USHORT i = 0; i < nCount; ++i )
 733                 m_pListBoxHelper->SelectEntryPos( i, TRUE );
 734             // call the select handler, don't handle events in this time
 735             m_bDisableProcessEvent = true;
 736             m_pListBoxHelper->Select();
 737             m_bDisableProcessEvent = false;
 738             bNotify = sal_True;
 739         }
 740     }
 741
 742     if ( bNotify )
 743         UpdateSelection_Impl();
 744 }
 745 // -----------------------------------------------------------------------------
 746 sal_Int32 SAL_CALL VCLXAccessibleList::getSelectedAccessibleChildCount(  ) throw (RuntimeException)
 747 {
 748     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 749     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 750
 751     sal_Int32 nCount = 0;
 752     if ( m_pListBoxHelper )
 753            nCount = m_pListBoxHelper->GetSelectEntryCount();
 754     return nCount;
 755 }
 756 // -----------------------------------------------------------------------------
 757 Reference< XAccessible > SAL_CALL VCLXAccessibleList::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 758 {
 759     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 760     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 761
 762     if ( m_pListBoxHelper )
 763     {
 764         checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,sal_True);
 765         return getAccessibleChild( (sal_Int32)m_pListBoxHelper->GetSelectEntryPos( (USHORT)nSelectedChildIndex ) );
 766     }
 767
 768     return NULL;
 769 }
 770 // -----------------------------------------------------------------------------
 771 void SAL_CALL VCLXAccessibleList::deselectAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 772 {
 773     sal_Bool bNotify = sal_False;
 774
 775     {
 776         vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 777         ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 778
 779         if ( m_pListBoxHelper )
 780         {
 781             checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,sal_False);
 782
 783             m_pListBoxHelper->SelectEntryPos( (USHORT)nSelectedChildIndex, FALSE );
 784             // call the select handler, don't handle events in this time
 785             m_bDisableProcessEvent = true;
 786             m_pListBoxHelper->Select();
 787             m_bDisableProcessEvent = false;
 788             bNotify = sal_True;
 789         }
 790     }
 791
 792     if ( bNotify )
 793         UpdateSelection_Impl();
 794 }
 795 // -----------------------------------------------------------------------------
 796 // accessibility::XAccessibleComponent
 797 awt::Rectangle VCLXAccessibleList::implGetBounds() throw (uno::RuntimeException)
 798 {
 799     awt::Rectangle aBounds ( 0, 0, 0, 0 );
 800     if ( m_pListBoxHelper
 801         && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
 802     {
 803         if ( m_pListBoxHelper->IsInDropDown() )
 804             aBounds = AWTRectangle(m_pListBoxHelper->GetDropDownPosSizePixel());
 805     }
 806     else
 807     {
 808         // a list has the same bounds as his parent but starts at (0,0)
 809         aBounds = VCLXAccessibleComponent::implGetBounds();
 810         aBounds.X = 0;
 811         aBounds.Y = 0;
 812         if ( m_aBoxType == COMBOBOX )
 813         {
 814             ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
 815             if ( pBox )
 816             {
 817                 Size aSize = pBox->GetSubEdit()->GetSizePixel();
 818                 aBounds.X += aSize.Height();
 819                 aBounds.Y += aSize.Width();
 820                 aBounds.Height -= aSize.Height();
 821                 aBounds.Width  -= aSize.Width();
 822             }
 823         }
 824     }
 825     return aBounds;
 826 }
 827 // -----------------------------------------------------------------------------
 828
 829 awt::Point VCLXAccessibleList::getLocationOnScreen(  ) throw (uno::RuntimeException)
 830 {
 831     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 832     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 833
 834     awt::Point aPos;
 835     if ( m_pListBoxHelper
 836         && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
 837     {
 838         if ( m_pListBoxHelper->IsInDropDown() )
 839             aPos = AWTPoint(m_pListBoxHelper->GetDropDownPosSizePixel().TopLeft());
 840     }
 841     else
 842     {
 843         aPos = VCLXAccessibleComponent::getLocationOnScreen();
 844         if ( m_aBoxType == COMBOBOX )
 845         {
 846             ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
 847             if ( pBox )
 848             {
 849                 aPos.X += pBox->GetSubEdit()->GetSizePixel().Height();
 850                 aPos.Y += pBox->GetSubEdit()->GetSizePixel().Width();
 851             }
 852         }
 853     }
 854     return aPos;
 855 }
 856 // -----------------------------------------------------------------------------
 857