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