1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_accessibility.hxx"
26 #include <accessibility/standard/vclxaccessiblelist.hxx>
27 #include <accessibility/standard/vclxaccessiblelistitem.hxx>
28 #include <accessibility/helper/listboxhelper.hxx>
29
30 #include <unotools/accessiblestatesethelper.hxx>
31 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
32 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
33 #include <com/sun/star/accessibility/AccessibleRole.hpp>
34 #include <vcl/svapp.hxx>
35 #include <vcl/combobox.hxx>
36 #include <vcl/lstbox.hxx>
37 #include <toolkit/helper/convert.hxx>
38
39 #ifndef _UTL_ACCESSIBLERELATIONSETHELPER_HXX_
40 #include <unotools/accessiblerelationsethelper.hxx>
41 #endif
42 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLERELATIONTYPE_HPP_
43 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
44 #endif
45 using namespace ::com::sun::star;
46 using namespace ::com::sun::star::uno;
47 using namespace ::com::sun::star::lang;
48 using namespace ::com::sun::star::beans;
49 using namespace ::com::sun::star::accessibility;
50 using namespace ::accessibility;
51
52 namespace
53 {
checkSelection_Impl(sal_Int32 _nIndex,const IComboListBoxHelper & _rListBox,sal_Bool bSelected)54 void checkSelection_Impl( sal_Int32 _nIndex, const IComboListBoxHelper& _rListBox, sal_Bool bSelected )
55 throw (::com::sun::star::lang::IndexOutOfBoundsException)
56 {
57 sal_Int32 nCount = bSelected ? (sal_Int32)_rListBox.GetSelectEntryCount()
58 : (sal_Int32)_rListBox.GetEntryCount();
59 if ( _nIndex < 0 || _nIndex >= nCount )
60 throw ::com::sun::star::lang::IndexOutOfBoundsException();
61 }
62 }
63
VCLXAccessibleList(VCLXWindow * pVCLWindow,BoxType aBoxType,const Reference<XAccessible> & _xParent)64 VCLXAccessibleList::VCLXAccessibleList (VCLXWindow* pVCLWindow, BoxType aBoxType,
65 const Reference< XAccessible >& _xParent)
66 : VCLXAccessibleComponent (pVCLWindow),
67 m_aBoxType (aBoxType),
68 m_nVisibleLineCount (0),
69 m_nIndexInParent (DEFAULT_INDEX_IN_PARENT),
70 m_nLastTopEntry ( 0 ),
71 m_nLastSelectedPos ( LISTBOX_ENTRY_NOTFOUND ),
72 m_bDisableProcessEvent ( false ),
73 m_bVisible ( true ),
74 m_nCurSelectedPos ( LISTBOX_ENTRY_NOTFOUND ),
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 m_nCurSelectedPos=m_pListBoxHelper->GetSelectEntryPos();
100
101 sal_uInt16 nCount = static_cast<sal_uInt16>(getAccessibleChildCount());
102 m_aAccessibleChildren.reserve(nCount);
103 }
104 // -----------------------------------------------------------------------------
105
~VCLXAccessibleList(void)106 VCLXAccessibleList::~VCLXAccessibleList (void)
107 {
108 delete m_pListBoxHelper;
109 }
110 // -----------------------------------------------------------------------------
111
SetIndexInParent(sal_Int32 nIndex)112 void VCLXAccessibleList::SetIndexInParent (sal_Int32 nIndex)
113 {
114 m_nIndexInParent = nIndex;
115 }
116 // -----------------------------------------------------------------------------
117
disposing(void)118 void SAL_CALL VCLXAccessibleList::disposing (void)
119 {
120 VCLXAccessibleComponent::disposing();
121
122 // Dispose all items in the list.
123 clearItems();
124
125 delete m_pListBoxHelper;
126 m_pListBoxHelper = NULL;
127 }
128 // -----------------------------------------------------------------------------
129
clearItems()130 void VCLXAccessibleList::clearItems()
131 {
132 // ListItems::iterator aEnd = m_aAccessibleChildren.end();
133 // for (ListItems::iterator aIter = m_aAccessibleChildren.begin(); aIter != aEnd; ++aIter)
134 // ::comphelper::disposeComponent(*aIter);
135
136 // Clear the list itself and delete all the rest.
137 ListItems().swap(m_aAccessibleChildren); // clear and minimize
138 }
139 // -----------------------------------------------------------------------------
140
FillAccessibleStateSet(utl::AccessibleStateSetHelper & rStateSet)141 void VCLXAccessibleList::FillAccessibleStateSet (utl::AccessibleStateSetHelper& rStateSet)
142 {
143 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
144
145 VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
146 // check if our list should be visible
147 if ( m_pListBoxHelper
148 && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN
149 && !m_pListBoxHelper->IsInDropDown() )
150 {
151 rStateSet.RemoveState (AccessibleStateType::VISIBLE);
152 rStateSet.RemoveState (AccessibleStateType::SHOWING);
153 m_bVisible = false;
154 }
155
156 // Both the combo box and list box are handled identical in the
157 // following but for some reason they don't have a common interface for
158 // the methods used.
159 if ( m_pListBoxHelper )
160 {
161 if ( m_pListBoxHelper->IsMultiSelectionEnabled() )
162 rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE);
163 rStateSet.AddState (AccessibleStateType::FOCUSABLE);
164 // All children are transient.
165 rStateSet.AddState (AccessibleStateType::MANAGES_DESCENDANTS);
166 }
167 }
168 // -----------------------------------------------------------------------------
notifyVisibleStates(sal_Bool _bSetNew)169 void VCLXAccessibleList::notifyVisibleStates(sal_Bool _bSetNew )
170 {
171 m_bVisible = _bSetNew ? true : false;
172 Any aOldValue, aNewValue;
173 (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::VISIBLE;
174 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
175 (_bSetNew ? aNewValue : aOldValue ) <<= AccessibleStateType::SHOWING;
176 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
177
178 ListItems::iterator aIter = m_aAccessibleChildren.begin();
179 ListItems::iterator aEnd = m_aAccessibleChildren.end();
180 UpdateVisibleLineCount();
181 // adjust the index inside the VCLXAccessibleListItem
182 for (;aIter != aEnd ; ++aIter)
183 {
184 Reference< XAccessible > xHold = *aIter;
185 VCLXAccessibleListItem* pItem = static_cast<VCLXAccessibleListItem*>(xHold.get());
186 if ( pItem )
187 {
188 sal_uInt16 nTopEntry = 0;
189 if ( m_pListBoxHelper )
190 nTopEntry = m_pListBoxHelper->GetTopEntry();
191 sal_uInt16 nPos = (sal_uInt16)(aIter - m_aAccessibleChildren.begin());
192 sal_Bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) );
193 pItem->SetVisible( m_bVisible && bVisible );
194 }
195
196 }
197 }
198 // -----------------------------------------------------------------------------
UpdateSelection_Acc(::rtl::OUString sTextOfSelectedItem,bool b_IsDropDownList)199 void VCLXAccessibleList::UpdateSelection_Acc (::rtl::OUString sTextOfSelectedItem, bool b_IsDropDownList)
200 {
201 if ( m_aBoxType == COMBOBOX )
202 {
203 ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
204 if ( pBox != NULL )
205 {
206 // Find the index of the selected item inside the VCL control...
207 sal_uInt16 nIndex = pBox->GetEntryPos (XubString(sTextOfSelectedItem));
208 // ...and then find the associated accessibility object.
209 if ( nIndex == LISTBOX_ENTRY_NOTFOUND )
210 nIndex = 0;
211 UpdateSelection_Impl_Acc(b_IsDropDownList);
212 }
213 }
214 }
215
216 // -----------------------------------------------------------------------------
UpdateSelection_Impl_Acc(bool b_IsDropDownList)217 void VCLXAccessibleList::UpdateSelection_Impl_Acc(bool b_IsDropDownList)
218 {
219 uno::Any aOldValue, aNewValue;
220 VCLXAccessibleListItem* pCurItem =NULL;
221
222 {
223 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
224 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
225 Reference< XAccessible > xNewAcc;
226 if ( m_pListBoxHelper )
227 {
228 sal_uInt16 i=0;
229 m_nCurSelectedPos = LISTBOX_ENTRY_NOTFOUND;
230 for ( ListItems::iterator aIter = m_aAccessibleChildren.begin();
231 aIter != m_aAccessibleChildren.end(); ++aIter,++i)
232 {
233 Reference< XAccessible > xHold = *aIter;
234 if ( xHold.is() )
235 {
236 VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >( xHold.get() );
237 // Retrieve the item's index from the list entry.
238 sal_Bool bNowSelected = m_pListBoxHelper->IsEntryPosSelected (i);
239 if (bNowSelected)
240 m_nCurSelectedPos = i;
241
242 if ( bNowSelected && !pItem->IsSelected() )
243 {
244 xNewAcc = *aIter;
245 aNewValue <<= xNewAcc;
246
247 pCurItem = pItem;
248
249 }
250 else if ( pItem->IsSelected() )
251 m_nLastSelectedPos = i;
252
253 pItem->SetSelected( bNowSelected );
254 }
255 else
256 { // it could happen that a child was not created before
257 checkEntrySelected(i,aNewValue,xNewAcc);
258 }
259 }
260 sal_uInt16 nCount = m_pListBoxHelper->GetEntryCount();
261 if ( i < nCount ) // here we have to check the if any other listbox entry is selected
262 {
263 for (; i < nCount && !checkEntrySelected(i,aNewValue,xNewAcc) ;++i )
264 ;
265 }
266 if ( xNewAcc.is() && GetWindow()->HasFocus() )
267 {
268 if ( m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND )
269 aOldValue <<= getAccessibleChild( (sal_Int32)m_nLastSelectedPos );
270 aNewValue <<= xNewAcc;
271 }
272 }
273 }
274 if (m_aBoxType == COMBOBOX && b_IsDropDownList)
275 {
276 //VCLXAccessibleDropDownComboBox
277 //when in list is dropped down, xText = NULL
278 if (m_pListBoxHelper->IsInDropDown())
279 {
280 if ( aNewValue.hasValue() || aOldValue.hasValue() )
281 {
282 NotifyAccessibleEvent(
283 AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
284 aOldValue,
285 aNewValue );
286
287 NotifyListItem(aNewValue);
288
289 }
290 }
291 }
292 else if (m_aBoxType == COMBOBOX && !b_IsDropDownList)
293 {
294 //VCLXAccessibleComboBox
295 NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, uno::Any(), uno::Any() );
296 }
297 else if (m_aBoxType == LISTBOX && b_IsDropDownList)
298 {
299 //VCLXAccessibleDropdownListBox
300 //when in list is dropped down, xText = NULL
301 if (m_pListBoxHelper->IsInDropDown())
302 {
303 if ( aNewValue.hasValue() || aOldValue.hasValue() )
304 {
305 NotifyAccessibleEvent(
306 AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
307 aOldValue,
308 aNewValue );
309
310 NotifyListItem(aNewValue);
311 }
312 }
313 }
314 else if (m_aBoxType == LISTBOX && !b_IsDropDownList)
315 {
316 //VCLXAccessibleListBox, xText = NULL.
317
318
319 if ( aNewValue.hasValue())
320 {
321 NotifyListItem(aNewValue);
322 }
323 }
324 }
NotifyListItem(::com::sun::star::uno::Any & val)325 void VCLXAccessibleList::NotifyListItem(::com::sun::star::uno::Any& val)
326 {
327 Reference< XAccessible > xCurItem;
328 val >>= xCurItem;
329 if (xCurItem.is())
330 {
331 VCLXAccessibleListItem* pCurItem = static_cast< VCLXAccessibleListItem* >(xCurItem.get());
332 if (pCurItem)
333 {
334 pCurItem->NotifyAccessibleEvent(AccessibleEventId::SELECTION_CHANGED,Any(),Any());
335 }
336 }
337 }
338
339
UpdateFocus_Impl_Acc(sal_uInt16 nPos,bool b_IsDropDownList)340 void VCLXAccessibleList::UpdateFocus_Impl_Acc (sal_uInt16 nPos ,bool b_IsDropDownList)
341 {
342 if (!(m_aBoxType == LISTBOX && !b_IsDropDownList))
343 {
344 return ;
345 }
346 Reference<XAccessible> xChild= CreateChild(nPos);
347 if ( !xChild.is() )
348 {
349 return ;
350 }
351 m_nCurSelectedPos = nPos;
352 uno::Any aOldValue, aNewValue;
353 aNewValue <<= xChild;
354
355 NotifyAccessibleEvent(
356 AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
357 aOldValue,
358 aNewValue );
359 }
360
361 // -----------------------------------------------------------------------------
ProcessWindowEvent(const VclWindowEvent & rVclWindowEvent,bool b_IsDropDownList)362 void VCLXAccessibleList::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent, bool b_IsDropDownList)
363 {
364 switch ( rVclWindowEvent.GetId() )
365 {
366 case VCLEVENT_DROPDOWN_SELECT:
367 case VCLEVENT_LISTBOX_SELECT:
368 if ( !m_bDisableProcessEvent )
369 UpdateSelection_Impl_Acc(b_IsDropDownList);
370 break;
371 case VCLEVENT_LISTBOX_FOCUSITEMCHANGED:
372 if ( !m_bDisableProcessEvent )
373 UpdateFocus_Impl_Acc((sal_uInt16)reinterpret_cast<sal_uIntPtr>(rVclWindowEvent.GetData()),b_IsDropDownList);
374 break;
375 case VCLEVENT_WINDOW_GETFOCUS:
376 break;
377 case VCLEVENT_CONTROL_GETFOCUS:
378 {
379 VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
380 if (m_aBoxType == COMBOBOX && b_IsDropDownList)
381 {
382 //VCLXAccessibleDropDownComboBox
383 }
384 else if (m_aBoxType == LISTBOX && b_IsDropDownList)
385 {
386 }
387 else if ( m_aBoxType == LISTBOX && !b_IsDropDownList)
388 {
389 if ( m_pListBoxHelper )
390 {
391 uno::Any aOldValue,
392 aNewValue;
393 sal_uInt16 nPos = m_nCurSelectedPos; //m_pListBoxHelper->GetSelectEntryPos();
394
395 if ( nPos == LISTBOX_ENTRY_NOTFOUND )
396 nPos = m_pListBoxHelper->GetTopEntry();
397 if ( nPos != LISTBOX_ENTRY_NOTFOUND )
398 aNewValue <<= CreateChild(nPos);
399 NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
400 aOldValue,
401 aNewValue );
402 }
403 }
404 }
405 break;
406 default:
407 break;
408 }
409
410 }
411 // -----------------------------------------------------------------------------
ProcessWindowEvent(const VclWindowEvent & rVclWindowEvent)412 void VCLXAccessibleList::ProcessWindowEvent (const VclWindowEvent& rVclWindowEvent)
413 {
414 // Create a reference to this object to prevent an early release of the
415 // listbox (VCLEVENT_OBJECT_DYING).
416 Reference< XAccessible > xTemp = this;
417
418 switch ( rVclWindowEvent.GetId() )
419 {
420 case VCLEVENT_DROPDOWN_OPEN:
421 notifyVisibleStates(sal_True);
422 break;
423 case VCLEVENT_DROPDOWN_CLOSE:
424 notifyVisibleStates(sal_False);
425 break;
426 case VCLEVENT_LISTBOX_SCROLLED:
427 case VCLEVENT_COMBOBOX_SCROLLED:
428 UpdateEntryRange_Impl();
429 break;
430
431 // The selection events VCLEVENT_COMBOBOX_SELECT and
432 // VCLEVENT_COMBOBOX_DESELECT are not handled here because here we
433 // have no access to the edit field. Its text is necessary to
434 // identify the currently selected item.
435
436 case VCLEVENT_OBJECT_DYING:
437 {
438 dispose();
439
440 VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
441 break;
442 }
443
444 case VCLEVENT_LISTBOX_ITEMREMOVED:
445 case VCLEVENT_COMBOBOX_ITEMREMOVED:
446 HandleChangedItemList (false, reinterpret_cast<sal_IntPtr>(
447 rVclWindowEvent.GetData()));
448 break;
449
450 case VCLEVENT_LISTBOX_ITEMADDED:
451 case VCLEVENT_COMBOBOX_ITEMADDED:
452 HandleChangedItemList (true, reinterpret_cast<sal_IntPtr>(
453 rVclWindowEvent.GetData()));
454 break;
455 case VCLEVENT_CONTROL_GETFOCUS:
456 {
457 VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
458 // Added by IBM Symphony Acc team to handle the list item focus when List control get focus
459 sal_Bool b_IsDropDownList = sal_True;
460 if (m_pListBoxHelper)
461 b_IsDropDownList = ((m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN);
462 if ( m_aBoxType == LISTBOX && !b_IsDropDownList )
463 {
464 if ( m_pListBoxHelper )
465 {
466 uno::Any aOldValue,
467 aNewValue;
468 sal_uInt16 nPos = m_nCurSelectedPos;
469
470 if ( nPos == LISTBOX_ENTRY_NOTFOUND )
471 nPos = m_pListBoxHelper->GetTopEntry();
472 if ( nPos != LISTBOX_ENTRY_NOTFOUND )
473 aNewValue <<= CreateChild(nPos);
474 NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
475 aOldValue,
476 aNewValue );
477 }
478 }
479 }
480 break;
481
482 default:
483 VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
484 }
485 }
486
FillAccessibleRelationSet(utl::AccessibleRelationSetHelper & rRelationSet)487 void VCLXAccessibleList::FillAccessibleRelationSet( utl::AccessibleRelationSetHelper& rRelationSet )
488 {
489 ListBox* pBox = static_cast<ListBox*>(GetWindow());
490 if( m_aBoxType == LISTBOX )
491 {
492 if (m_pListBoxHelper && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) != WB_DROPDOWN)
493 {
494 uno::Sequence< uno::Reference< uno::XInterface > > aSequence(1);
495 aSequence[0] = pBox->GetAccessible();
496 rRelationSet.AddRelation( com::sun::star::accessibility::AccessibleRelation( com::sun::star::accessibility::AccessibleRelationType::MEMBER_OF, aSequence ) );
497 }
498 }
499 else
500 {
501 VCLXAccessibleComponent::FillAccessibleRelationSet(rRelationSet);
502 }
503 }
504 // -----------------------------------------------------------------------------
505
506 /** To find out which item is currently selected and to update the SELECTED
507 state of the associated accessibility objects accordingly we exploit the
508 fact that the
509 */
UpdateSelection(::rtl::OUString sTextOfSelectedItem)510 void VCLXAccessibleList::UpdateSelection (::rtl::OUString sTextOfSelectedItem)
511 {
512 if ( m_aBoxType == COMBOBOX )
513 {
514 ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
515 if ( pBox != NULL )
516 {
517 // Find the index of the selected item inside the VCL control...
518 sal_uInt16 nIndex = pBox->GetEntryPos (XubString(sTextOfSelectedItem));
519 // ...and then find the associated accessibility object.
520 if ( nIndex == LISTBOX_ENTRY_NOTFOUND )
521 nIndex = 0;
522 UpdateSelection_Impl(nIndex);
523 }
524 }
525 }
526 // -----------------------------------------------------------------------------
527
adjustEntriesIndexInParent(ListItems::iterator & _aBegin,::std::mem_fun_t<bool,VCLXAccessibleListItem> & _rMemFun)528 void VCLXAccessibleList::adjustEntriesIndexInParent(ListItems::iterator& _aBegin,::std::mem_fun_t<bool,VCLXAccessibleListItem>& _rMemFun)
529 {
530 ListItems::iterator aIter = _aBegin;
531 ListItems::iterator aEnd = m_aAccessibleChildren.end();
532 // adjust the index inside the VCLXAccessibleListItem
533 for (;aIter != aEnd ; ++aIter)
534 {
535 Reference< XAccessible > xHold = *aIter;
536 VCLXAccessibleListItem* pItem = static_cast<VCLXAccessibleListItem*>(xHold.get());
537 if ( pItem )
538 _rMemFun(pItem);
539 }
540 }
541 // -----------------------------------------------------------------------------
542
CreateChild(sal_Int32 i)543 Reference<XAccessible> VCLXAccessibleList::CreateChild (sal_Int32 i)
544 {
545 Reference<XAccessible> xChild;
546
547 sal_uInt16 nPos = static_cast<sal_uInt16>(i);
548 if ( nPos >= m_aAccessibleChildren.size() )
549 {
550 m_aAccessibleChildren.resize(nPos + 1);
551
552 // insert into the container
553 xChild = new VCLXAccessibleListItem(m_pListBoxHelper, i, this);
554 m_aAccessibleChildren[nPos] = xChild;
555 }
556 else
557 {
558 xChild = m_aAccessibleChildren[nPos];
559 // check if position is empty and can be used else we have to adjust all entries behind this
560 if ( !xChild.is() )
561 {
562 xChild = new VCLXAccessibleListItem(m_pListBoxHelper, i, this);
563 m_aAccessibleChildren[nPos] = xChild;
564 }
565 }
566
567 if ( xChild.is() )
568 {
569 // Just add the SELECTED state.
570 sal_Bool bNowSelected = sal_False;
571 if ( m_pListBoxHelper )
572 bNowSelected = m_pListBoxHelper->IsEntryPosSelected ((sal_uInt16)i);
573 if (bNowSelected)
574 m_nCurSelectedPos = sal_uInt16(i);
575 VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >(xChild.get());
576 pItem->SetSelected( bNowSelected );
577
578 // Set the child's VISIBLE state.
579 UpdateVisibleLineCount();
580 sal_uInt16 nTopEntry = 0;
581 if ( m_pListBoxHelper )
582 nTopEntry = m_pListBoxHelper->GetTopEntry();
583 sal_Bool bVisible = ( nPos>=nTopEntry && nPos<( nTopEntry + m_nVisibleLineCount ) );
584 pItem->SetVisible( m_bVisible && bVisible );
585 }
586
587 return xChild;
588 }
589 // -----------------------------------------------------------------------------
590
HandleChangedItemList(bool bItemInserted,sal_Int32 nIndex)591 void VCLXAccessibleList::HandleChangedItemList (bool bItemInserted, sal_Int32 nIndex)
592 {
593 clearItems();
594 NotifyAccessibleEvent (
595 AccessibleEventId::INVALIDATE_ALL_CHILDREN,
596 Any(), Any());
597 }
598 // -----------------------------------------------------------------------------
599
IMPLEMENT_FORWARD_XINTERFACE2(VCLXAccessibleList,VCLXAccessibleComponent,VCLXAccessibleList_BASE)600 IMPLEMENT_FORWARD_XINTERFACE2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE)
601 IMPLEMENT_FORWARD_XTYPEPROVIDER2(VCLXAccessibleList, VCLXAccessibleComponent, VCLXAccessibleList_BASE)
602
603 //===== XAccessible =========================================================
604
605 Reference<XAccessibleContext> SAL_CALL
606 VCLXAccessibleList::getAccessibleContext (void)
607 throw (RuntimeException)
608 {
609 return this;
610 }
611 // -----------------------------------------------------------------------------
612
613 //===== XAccessibleContext ==================================================
614
getAccessibleChildCount(void)615 sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleChildCount (void)
616 throw (RuntimeException)
617 {
618 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
619 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
620
621 sal_Int32 nCount = 0;
622 if ( m_pListBoxHelper )
623 nCount = m_pListBoxHelper->GetEntryCount();
624
625 return nCount;
626 }
627 // -----------------------------------------------------------------------------
628
getAccessibleChild(sal_Int32 i)629 Reference<XAccessible> SAL_CALL VCLXAccessibleList::getAccessibleChild (sal_Int32 i)
630 throw (IndexOutOfBoundsException, RuntimeException)
631 {
632 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
633 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
634
635 if ( i < 0 || i >= getAccessibleChildCount() )
636 throw IndexOutOfBoundsException();
637
638 Reference< XAccessible > xChild;
639 // search for the child
640 if ( i >= static_cast<sal_Int32>(m_aAccessibleChildren.size()) )
641 xChild = CreateChild (i);
642 else
643 {
644 xChild = m_aAccessibleChildren[i];
645 if ( !xChild.is() )
646 xChild = CreateChild (i);
647 }
648 OSL_ENSURE( xChild.is(), "VCLXAccessibleList::getAccessibleChild: returning empty child!" );
649 return xChild;
650 }
651 // -----------------------------------------------------------------------------
652
getAccessibleParent()653 Reference< XAccessible > SAL_CALL VCLXAccessibleList::getAccessibleParent( )
654 throw (RuntimeException)
655 {
656 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
657
658 return m_xParent;
659 }
660 // -----------------------------------------------------------------------------
661
getAccessibleIndexInParent(void)662 sal_Int32 SAL_CALL VCLXAccessibleList::getAccessibleIndexInParent (void)
663 throw (::com::sun::star::uno::RuntimeException)
664 {
665 if (m_nIndexInParent != DEFAULT_INDEX_IN_PARENT)
666 return m_nIndexInParent;
667 else
668 return VCLXAccessibleComponent::getAccessibleIndexInParent();
669 }
670 // -----------------------------------------------------------------------------
671
getAccessibleRole(void)672 sal_Int16 SAL_CALL VCLXAccessibleList::getAccessibleRole (void)
673 throw (RuntimeException)
674 {
675 return AccessibleRole::LIST;
676 }
677 // -----------------------------------------------------------------------------
678
679 //===== XAccessibleComponent ================================================
680
contains(const awt::Point & rPoint)681 sal_Bool SAL_CALL VCLXAccessibleList::contains( const awt::Point& rPoint ) throw (RuntimeException)
682 {
683 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
684 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
685
686 sal_Bool bInside = sal_False;
687
688 Window* pListBox = GetWindow();
689 if ( pListBox )
690 {
691 Rectangle aRect( Point(0,0), pListBox->GetSizePixel() );
692 bInside = aRect.IsInside( VCLPoint( rPoint ) );
693 }
694
695 return bInside;
696 }
697 // -----------------------------------------------------------------------------
698
getAccessibleAt(const awt::Point & rPoint)699 Reference< XAccessible > SAL_CALL VCLXAccessibleList::getAccessibleAt( const awt::Point& rPoint )
700 throw (RuntimeException)
701 {
702 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
703 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
704
705 Reference< XAccessible > xChild;
706 if ( m_pListBoxHelper )
707 {
708 UpdateVisibleLineCount();
709 if ( contains( rPoint ) && m_nVisibleLineCount > 0 )
710 {
711 Point aPos = VCLPoint( rPoint );
712 sal_uInt16 nEndPos = m_pListBoxHelper->GetTopEntry() + (sal_uInt16)m_nVisibleLineCount;
713 for ( sal_uInt16 i = m_pListBoxHelper->GetTopEntry(); i < nEndPos; ++i )
714 {
715 if ( m_pListBoxHelper->GetBoundingRectangle(i).IsInside( aPos ) )
716 {
717 xChild = getAccessibleChild(i);
718 break;
719 }
720 }
721 }
722 }
723
724 return xChild;
725 }
726 // -----------------------------------------------------------------------------
727
728 //===== XServiceInfo ==========================================================
729
getImplementationName(void)730 ::rtl::OUString VCLXAccessibleList::getImplementationName (void)
731 throw (RuntimeException)
732 {
733 return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.toolkit.AccessibleList"));
734 }
735 // -----------------------------------------------------------------------------
736
getSupportedServiceNames(void)737 Sequence< ::rtl::OUString > VCLXAccessibleList::getSupportedServiceNames (void)
738 throw (RuntimeException)
739 {
740 Sequence< ::rtl::OUString > aNames = VCLXAccessibleComponent::getSupportedServiceNames();
741 sal_Int32 nLength = aNames.getLength();
742 aNames.realloc( nLength + 1 );
743 aNames[nLength] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.accessibility.AccessibleList"));
744 return aNames;
745 }
746 // -----------------------------------------------------------------------------
747
UpdateVisibleLineCount()748 void VCLXAccessibleList::UpdateVisibleLineCount()
749 {
750 if ( m_pListBoxHelper )
751 {
752 if ( (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
753 m_nVisibleLineCount = m_pListBoxHelper->GetDisplayLineCount();
754 else
755 {
756 sal_uInt16 nCols = 0,
757 nLines = 0;
758 m_pListBoxHelper->GetMaxVisColumnsAndLines (nCols, nLines);
759 m_nVisibleLineCount = nLines;
760 }
761 }
762 }
763
764 // -----------------------------------------------------------------------------
UpdateEntryRange_Impl()765 void VCLXAccessibleList::UpdateEntryRange_Impl()
766 {
767 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
768 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
769
770 sal_Int32 nTop = m_nLastTopEntry;
771
772 if ( m_pListBoxHelper )
773 nTop = m_pListBoxHelper->GetTopEntry();
774 if ( nTop != m_nLastTopEntry )
775 {
776 UpdateVisibleLineCount();
777 sal_Int32 nBegin = Min( m_nLastTopEntry, nTop );
778 sal_Int32 nEnd = Max( m_nLastTopEntry + m_nVisibleLineCount, nTop + m_nVisibleLineCount );
779 for (sal_uInt16 i = static_cast<sal_uInt16>(nBegin); (i <= static_cast<sal_uInt16>(nEnd)); ++i)
780 {
781 sal_Bool bVisible = ( i >= nTop && i < ( nTop + m_nVisibleLineCount ) );
782 Reference< XAccessible > xHold;
783 if ( i < m_aAccessibleChildren.size() )
784 xHold = m_aAccessibleChildren[i];
785 else if ( bVisible )
786 xHold = CreateChild(i);
787
788 if ( xHold.is() )
789 static_cast< VCLXAccessibleListItem* >( xHold.get() )->SetVisible( m_bVisible && bVisible );
790 }
791 }
792
793 m_nLastTopEntry = nTop;
794 }
795 // -----------------------------------------------------------------------------
checkEntrySelected(sal_uInt16 _nPos,Any & _rNewValue,Reference<XAccessible> & _rxNewAcc)796 sal_Bool VCLXAccessibleList::checkEntrySelected(sal_uInt16 _nPos,Any& _rNewValue,Reference< XAccessible >& _rxNewAcc)
797 {
798 OSL_ENSURE(m_pListBoxHelper,"Helper is not valid!");
799 sal_Bool bNowSelected = sal_False;
800 if ( m_pListBoxHelper )
801 {
802 bNowSelected = m_pListBoxHelper->IsEntryPosSelected (_nPos);
803 if ( bNowSelected )
804 {
805 _rxNewAcc = CreateChild(_nPos);
806 _rNewValue <<= _rxNewAcc;
807 }
808 }
809 return bNowSelected;
810 }
811 // -----------------------------------------------------------------------------
812
UpdateSelection_Impl(sal_uInt16)813 void VCLXAccessibleList::UpdateSelection_Impl(sal_uInt16)
814 {
815 uno::Any aOldValue, aNewValue;
816
817 {
818 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
819 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
820 Reference< XAccessible > xNewAcc;
821
822 if ( m_pListBoxHelper )
823 {
824 sal_uInt16 i=0;
825 m_nCurSelectedPos = LISTBOX_ENTRY_NOTFOUND;
826 for ( ListItems::iterator aIter = m_aAccessibleChildren.begin();
827 aIter != m_aAccessibleChildren.end(); ++aIter,++i)
828 {
829 Reference< XAccessible > xHold = *aIter;
830 if ( xHold.is() )
831 {
832 VCLXAccessibleListItem* pItem = static_cast< VCLXAccessibleListItem* >( xHold.get() );
833 // Retrieve the item's index from the list entry.
834 sal_Bool bNowSelected = m_pListBoxHelper->IsEntryPosSelected (i);
835 if (bNowSelected)
836 m_nCurSelectedPos = i;
837
838 if ( bNowSelected && !pItem->IsSelected() )
839 {
840 xNewAcc = *aIter;
841 aNewValue <<= xNewAcc;
842 }
843 else if ( pItem->IsSelected() )
844 m_nLastSelectedPos = i;
845
846 pItem->SetSelected( bNowSelected );
847 }
848 else
849 { // it could happen that a child was not created before
850 checkEntrySelected(i,aNewValue,xNewAcc);
851 }
852 }
853 sal_uInt16 nCount = m_pListBoxHelper->GetEntryCount();
854 if ( i < nCount ) // here we have to check the if any other listbox entry is selected
855 {
856 for (; i < nCount && !checkEntrySelected(i,aNewValue,xNewAcc) ;++i )
857 ;
858 }
859 if ( xNewAcc.is() && GetWindow()->HasFocus() )
860 {
861 if ( m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND )
862 aOldValue <<= getAccessibleChild( (sal_Int32)m_nLastSelectedPos );
863 aNewValue <<= xNewAcc;
864 }
865 }
866 }
867 if (!m_pListBoxHelper->IsInDropDown())
868 {
869 }
870 else
871 {
872 if ( aNewValue.hasValue() || aOldValue.hasValue() )
873 NotifyAccessibleEvent(
874 AccessibleEventId::ACTIVE_DESCENDANT_CHANGED,
875 aOldValue,
876 aNewValue );
877 //the SELECTION_CHANGED is not necessary
878 //NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
879 }
880 }
881
882 // -----------------------------------------------------------------------------
883 // XAccessibleSelection
884 // -----------------------------------------------------------------------------
selectAccessibleChild(sal_Int32 nChildIndex)885 void SAL_CALL VCLXAccessibleList::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
886 {
887 sal_Bool bNotify = sal_False;
888
889 {
890 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
891 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
892
893 if ( m_pListBoxHelper )
894 {
895 checkSelection_Impl(nChildIndex,*m_pListBoxHelper,sal_False);
896
897 m_pListBoxHelper->SelectEntryPos( (sal_uInt16)nChildIndex, sal_True );
898 // call the select handler, don't handle events in this time
899 m_bDisableProcessEvent = true;
900 m_pListBoxHelper->Select();
901 m_bDisableProcessEvent = false;
902 bNotify = sal_True;
903 }
904 }
905
906 if ( bNotify )
907 UpdateSelection_Impl();
908 }
909 // -----------------------------------------------------------------------------
isAccessibleChildSelected(sal_Int32 nChildIndex)910 sal_Bool SAL_CALL VCLXAccessibleList::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
911 {
912 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
913 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
914
915 sal_Bool bRet = sal_False;
916 if ( m_pListBoxHelper )
917 {
918 checkSelection_Impl(nChildIndex,*m_pListBoxHelper,sal_False);
919
920 bRet = m_pListBoxHelper->IsEntryPosSelected( (sal_uInt16)nChildIndex );
921 }
922 return bRet;
923 }
924 // -----------------------------------------------------------------------------
clearAccessibleSelection()925 void SAL_CALL VCLXAccessibleList::clearAccessibleSelection( ) throw (RuntimeException)
926 {
927 sal_Bool bNotify = sal_False;
928
929 {
930 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
931 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
932
933 if ( m_pListBoxHelper )
934 {
935 m_pListBoxHelper->SetNoSelection();
936 bNotify = sal_True;
937 }
938 }
939
940 if ( bNotify )
941 UpdateSelection_Impl();
942 }
943 // -----------------------------------------------------------------------------
selectAllAccessibleChildren()944 void SAL_CALL VCLXAccessibleList::selectAllAccessibleChildren( ) throw (RuntimeException)
945 {
946 sal_Bool bNotify = sal_False;
947
948 {
949 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
950 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
951
952 if ( m_pListBoxHelper )
953 {
954 sal_uInt16 nCount = m_pListBoxHelper->GetEntryCount();
955 for ( sal_uInt16 i = 0; i < nCount; ++i )
956 m_pListBoxHelper->SelectEntryPos( i, sal_True );
957 // call the select handler, don't handle events in this time
958 m_bDisableProcessEvent = true;
959 m_pListBoxHelper->Select();
960 m_bDisableProcessEvent = false;
961 bNotify = sal_True;
962 }
963 }
964
965 if ( bNotify )
966 UpdateSelection_Impl();
967 }
968 // -----------------------------------------------------------------------------
getSelectedAccessibleChildCount()969 sal_Int32 SAL_CALL VCLXAccessibleList::getSelectedAccessibleChildCount( ) throw (RuntimeException)
970 {
971 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
972 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
973
974 sal_Int32 nCount = 0;
975 if ( m_pListBoxHelper )
976 nCount = m_pListBoxHelper->GetSelectEntryCount();
977 return nCount;
978 }
979 // -----------------------------------------------------------------------------
getSelectedAccessibleChild(sal_Int32 nSelectedChildIndex)980 Reference< XAccessible > SAL_CALL VCLXAccessibleList::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
981 {
982 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
983 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
984
985 if ( m_pListBoxHelper )
986 {
987 checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,sal_True);
988 return getAccessibleChild( (sal_Int32)m_pListBoxHelper->GetSelectEntryPos( (sal_uInt16)nSelectedChildIndex ) );
989 }
990
991 return NULL;
992 }
993 // -----------------------------------------------------------------------------
deselectAccessibleChild(sal_Int32 nSelectedChildIndex)994 void SAL_CALL VCLXAccessibleList::deselectAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
995 {
996 sal_Bool bNotify = sal_False;
997
998 {
999 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1000 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
1001
1002 if ( m_pListBoxHelper )
1003 {
1004 checkSelection_Impl(nSelectedChildIndex,*m_pListBoxHelper,sal_False);
1005
1006 m_pListBoxHelper->SelectEntryPos( (sal_uInt16)nSelectedChildIndex, sal_False );
1007 // call the select handler, don't handle events in this time
1008 m_bDisableProcessEvent = true;
1009 m_pListBoxHelper->Select();
1010 m_bDisableProcessEvent = false;
1011 bNotify = sal_True;
1012 }
1013 }
1014
1015 if ( bNotify )
1016 UpdateSelection_Impl();
1017 }
1018 // -----------------------------------------------------------------------------
1019 // accessibility::XAccessibleComponent
implGetBounds()1020 awt::Rectangle VCLXAccessibleList::implGetBounds() throw (uno::RuntimeException)
1021 {
1022 awt::Rectangle aBounds ( 0, 0, 0, 0 );
1023 if ( m_pListBoxHelper
1024 && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
1025 {
1026 if ( m_pListBoxHelper->IsInDropDown() )
1027 aBounds = AWTRectangle(m_pListBoxHelper->GetDropDownPosSizePixel());
1028 }
1029 else
1030 {
1031 // a list has the same bounds as his parent but starts at (0,0)
1032 aBounds = VCLXAccessibleComponent::implGetBounds();
1033 aBounds.X = 0;
1034 aBounds.Y = 0;
1035 if ( m_aBoxType == COMBOBOX )
1036 {
1037 ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
1038 if ( pBox )
1039 {
1040 Size aSize = pBox->GetSubEdit()->GetSizePixel();
1041 aBounds.Y += aSize.Height();
1042 aBounds.Height -= aSize.Height();
1043 }
1044 }
1045 }
1046 return aBounds;
1047 }
1048 // -----------------------------------------------------------------------------
1049
getLocationOnScreen()1050 awt::Point VCLXAccessibleList::getLocationOnScreen( ) throw (uno::RuntimeException)
1051 {
1052 vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1053 ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
1054
1055 awt::Point aPos;
1056 if ( m_pListBoxHelper
1057 && (m_pListBoxHelper->GetStyle() & WB_DROPDOWN ) == WB_DROPDOWN )
1058 {
1059 if ( m_pListBoxHelper->IsInDropDown() )
1060 aPos = AWTPoint(m_pListBoxHelper->GetDropDownPosSizePixel().TopLeft());
1061 }
1062 else
1063 {
1064 aPos = VCLXAccessibleComponent::getLocationOnScreen();
1065 if ( m_aBoxType == COMBOBOX )
1066 {
1067 ComboBox* pBox = static_cast<ComboBox*>(GetWindow());
1068 if ( pBox )
1069 {
1070 aPos.Y += pBox->GetSubEdit()->GetSizePixel().Height();
1071 }
1072 }
1073 }
1074 return aPos;
1075 }
1076 // -----------------------------------------------------------------------------
IsInDropDown()1077 sal_Bool VCLXAccessibleList::IsInDropDown()
1078 {
1079 return m_pListBoxHelper->IsInDropDown();
1080 }
1081 // -----------------------------------------------------------------------------
HandleDropOpen()1082 void VCLXAccessibleList::HandleDropOpen()
1083 {
1084 if ( !m_bDisableProcessEvent )
1085 UpdateSelection_Impl();
1086 if (m_nCurSelectedPos != LISTBOX_ENTRY_NOTFOUND &&
1087 m_nLastSelectedPos != LISTBOX_ENTRY_NOTFOUND)
1088 {
1089 Reference< XAccessible > xChild = getAccessibleChild(m_nCurSelectedPos);
1090 if(xChild.is())
1091 {
1092 uno::Any aNewValue;
1093 aNewValue <<= xChild;
1094 NotifyAccessibleEvent(AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, uno::Any(), aNewValue );
1095 }
1096 }
1097 }
1098