Line data Source code
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/accessiblemenubasecomponent.hxx>
21 : #include <accessibility/standard/vclxaccessiblemenu.hxx>
22 : #include <accessibility/standard/vclxaccessiblemenuitem.hxx>
23 : #include <accessibility/standard/vclxaccessiblemenuseparator.hxx>
24 : #include <toolkit/helper/externallock.hxx>
25 : #include <toolkit/helper/convert.hxx>
26 :
27 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
28 : #include <com/sun/star/accessibility/AccessibleRole.hpp>
29 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
30 : #include <cppuhelper/supportsservice.hxx>
31 : #include <unotools/accessiblestatesethelper.hxx>
32 : #include <vcl/svapp.hxx>
33 : #include <vcl/window.hxx>
34 : #include <vcl/menu.hxx>
35 :
36 : using namespace ::com::sun::star;
37 : using namespace ::com::sun::star::lang;
38 : using namespace ::com::sun::star::uno;
39 : using namespace ::com::sun::star::accessibility;
40 : using namespace ::comphelper;
41 :
42 :
43 : // -----------------------------------------------------------------------------
44 : // OAccessibleMenuBaseComponent
45 : // -----------------------------------------------------------------------------
46 :
47 1949 : OAccessibleMenuBaseComponent::OAccessibleMenuBaseComponent( Menu* pMenu )
48 : :AccessibleExtendedComponentHelper_BASE( new VCLExternalSolarLock() )
49 : ,m_pMenu( pMenu )
50 : ,m_bEnabled( sal_False )
51 : ,m_bFocused( sal_False )
52 : ,m_bVisible( sal_False )
53 : ,m_bSelected( sal_False )
54 1949 : ,m_bChecked( sal_False )
55 : {
56 1949 : m_pExternalLock = static_cast< VCLExternalSolarLock* >( getExternalLock() );
57 :
58 1949 : if ( m_pMenu )
59 : {
60 281 : m_aAccessibleChildren.assign( m_pMenu->GetItemCount(), Reference< XAccessible >() );
61 281 : m_pMenu->AddEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
62 : }
63 1949 : }
64 :
65 : // -----------------------------------------------------------------------------
66 :
67 3898 : OAccessibleMenuBaseComponent::~OAccessibleMenuBaseComponent()
68 : {
69 1949 : if ( m_pMenu )
70 0 : m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
71 :
72 1949 : delete m_pExternalLock;
73 1949 : m_pExternalLock = NULL;
74 1949 : }
75 :
76 : // -----------------------------------------------------------------------------
77 :
78 0 : sal_Bool OAccessibleMenuBaseComponent::IsEnabled()
79 : {
80 0 : return sal_False;
81 : }
82 :
83 : // -----------------------------------------------------------------------------
84 :
85 271 : sal_Bool OAccessibleMenuBaseComponent::IsFocused()
86 : {
87 271 : return sal_False;
88 : }
89 :
90 : // -----------------------------------------------------------------------------
91 :
92 0 : sal_Bool OAccessibleMenuBaseComponent::IsVisible()
93 : {
94 0 : return sal_False;
95 : }
96 :
97 : // -----------------------------------------------------------------------------
98 :
99 296 : sal_Bool OAccessibleMenuBaseComponent::IsSelected()
100 : {
101 296 : return sal_False;
102 : }
103 :
104 : // -----------------------------------------------------------------------------
105 :
106 296 : sal_Bool OAccessibleMenuBaseComponent::IsChecked()
107 : {
108 296 : return sal_False;
109 : }
110 :
111 : // -----------------------------------------------------------------------------
112 :
113 1949 : void OAccessibleMenuBaseComponent::SetStates()
114 : {
115 1949 : m_bEnabled = IsEnabled();
116 1949 : m_bFocused = IsFocused();
117 1949 : m_bVisible = IsVisible();
118 1949 : m_bSelected = IsSelected();
119 1949 : m_bChecked = IsChecked();
120 1949 : }
121 :
122 : // -----------------------------------------------------------------------------
123 :
124 0 : void OAccessibleMenuBaseComponent::SetEnabled( sal_Bool bEnabled )
125 : {
126 0 : if ( m_bEnabled != bEnabled )
127 : {
128 0 : Any aOldValue[2], aNewValue[2];
129 0 : if ( m_bEnabled )
130 : {
131 0 : aOldValue[0] <<= AccessibleStateType::SENSITIVE;
132 0 : aOldValue[1] <<= AccessibleStateType::ENABLED;
133 : }
134 : else
135 : {
136 0 : aNewValue[0] <<= AccessibleStateType::ENABLED;
137 0 : aNewValue[1] <<= AccessibleStateType::SENSITIVE;
138 : }
139 0 : m_bEnabled = bEnabled;
140 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] );
141 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] );
142 : }
143 0 : }
144 :
145 : // -----------------------------------------------------------------------------
146 :
147 64 : void OAccessibleMenuBaseComponent::SetFocused( sal_Bool bFocused )
148 : {
149 64 : if ( m_bFocused != bFocused )
150 : {
151 60 : Any aOldValue, aNewValue;
152 30 : if ( m_bFocused )
153 14 : aOldValue <<= AccessibleStateType::FOCUSED;
154 : else
155 16 : aNewValue <<= AccessibleStateType::FOCUSED;
156 30 : m_bFocused = bFocused;
157 60 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
158 : }
159 64 : }
160 :
161 : // -----------------------------------------------------------------------------
162 :
163 168 : void OAccessibleMenuBaseComponent::SetVisible( sal_Bool bVisible )
164 : {
165 168 : if ( m_bVisible != bVisible )
166 : {
167 130 : Any aOldValue, aNewValue;
168 65 : if ( m_bVisible )
169 43 : aOldValue <<= AccessibleStateType::VISIBLE;
170 : else
171 22 : aNewValue <<= AccessibleStateType::VISIBLE;
172 65 : m_bVisible = bVisible;
173 130 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
174 : }
175 168 : }
176 :
177 : // -----------------------------------------------------------------------------
178 :
179 14 : void OAccessibleMenuBaseComponent::SetSelected( sal_Bool bSelected )
180 : {
181 14 : if ( m_bSelected != bSelected )
182 : {
183 28 : Any aOldValue, aNewValue;
184 14 : if ( m_bSelected )
185 6 : aOldValue <<= AccessibleStateType::SELECTED;
186 : else
187 8 : aNewValue <<= AccessibleStateType::SELECTED;
188 14 : m_bSelected = bSelected;
189 28 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
190 : }
191 14 : }
192 :
193 : // -----------------------------------------------------------------------------
194 :
195 0 : void OAccessibleMenuBaseComponent::SetChecked( sal_Bool bChecked )
196 : {
197 0 : if ( m_bChecked != bChecked )
198 : {
199 0 : Any aOldValue, aNewValue;
200 0 : if ( m_bChecked )
201 0 : aOldValue <<= AccessibleStateType::CHECKED;
202 : else
203 0 : aNewValue <<= AccessibleStateType::CHECKED;
204 0 : m_bChecked = bChecked;
205 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
206 : }
207 0 : }
208 :
209 : // -----------------------------------------------------------------------------
210 :
211 32 : void OAccessibleMenuBaseComponent::UpdateEnabled( sal_Int32 i, sal_Bool bEnabled )
212 : {
213 32 : if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
214 : {
215 32 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
216 32 : if ( xChild.is() )
217 : {
218 0 : OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
219 0 : if ( pComp )
220 0 : pComp->SetEnabled( bEnabled );
221 32 : }
222 : }
223 32 : }
224 :
225 : // -----------------------------------------------------------------------------
226 :
227 42 : void OAccessibleMenuBaseComponent::UpdateFocused( sal_Int32 i, sal_Bool bFocused )
228 : {
229 42 : if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
230 : {
231 26 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
232 26 : if ( xChild.is() )
233 : {
234 22 : OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
235 22 : if ( pComp )
236 22 : pComp->SetFocused( bFocused );
237 26 : }
238 : }
239 42 : }
240 :
241 : // -----------------------------------------------------------------------------
242 :
243 32 : void OAccessibleMenuBaseComponent::UpdateVisible()
244 : {
245 32 : SetVisible( IsVisible() );
246 864 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
247 : {
248 832 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
249 832 : if ( xChild.is() )
250 : {
251 136 : OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
252 136 : if ( pComp )
253 136 : pComp->SetVisible( pComp->IsVisible() );
254 : }
255 832 : }
256 32 : }
257 :
258 : // -----------------------------------------------------------------------------
259 :
260 34 : void OAccessibleMenuBaseComponent::UpdateSelected( sal_Int32 i, sal_Bool bSelected )
261 : {
262 34 : NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
263 :
264 34 : if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
265 : {
266 18 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
267 18 : if ( xChild.is() )
268 : {
269 14 : OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
270 14 : if ( pComp )
271 14 : pComp->SetSelected( bSelected );
272 18 : }
273 : }
274 34 : }
275 :
276 : // -----------------------------------------------------------------------------
277 :
278 6 : void OAccessibleMenuBaseComponent::UpdateChecked( sal_Int32 i, sal_Bool bChecked )
279 : {
280 6 : if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
281 : {
282 6 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
283 6 : if ( xChild.is() )
284 : {
285 0 : OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
286 0 : if ( pComp )
287 0 : pComp->SetChecked( bChecked );
288 6 : }
289 : }
290 6 : }
291 :
292 : // -----------------------------------------------------------------------------
293 :
294 67 : void OAccessibleMenuBaseComponent::UpdateAccessibleName( sal_Int32 i )
295 : {
296 67 : if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
297 : {
298 67 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
299 67 : if ( xChild.is() )
300 : {
301 0 : OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() );
302 0 : if ( pComp )
303 0 : pComp->SetAccessibleName( pComp->GetAccessibleName() );
304 67 : }
305 : }
306 67 : }
307 :
308 : // -----------------------------------------------------------------------------
309 :
310 67 : void OAccessibleMenuBaseComponent::UpdateItemText( sal_Int32 i )
311 : {
312 67 : if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
313 : {
314 67 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
315 67 : if ( xChild.is() )
316 : {
317 0 : OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() );
318 0 : if ( pComp )
319 0 : pComp->SetItemText( pComp->GetItemText() );
320 67 : }
321 : }
322 67 : }
323 :
324 : // -----------------------------------------------------------------------------
325 :
326 4396 : sal_Int32 OAccessibleMenuBaseComponent::GetChildCount()
327 : {
328 4396 : return m_aAccessibleChildren.size();
329 : }
330 :
331 : // -----------------------------------------------------------------------------
332 :
333 3632 : Reference< XAccessible > OAccessibleMenuBaseComponent::GetChild( sal_Int32 i )
334 : {
335 3632 : Reference< XAccessible > xChild = m_aAccessibleChildren[i];
336 3632 : if ( !xChild.is() )
337 : {
338 1924 : if ( m_pMenu )
339 : {
340 : // create a new child
341 : OAccessibleMenuBaseComponent* pChild;
342 :
343 1924 : if ( m_pMenu->GetItemType( (sal_uInt16)i ) == MENUITEM_SEPARATOR )
344 : {
345 271 : pChild = new VCLXAccessibleMenuSeparator( m_pMenu, (sal_uInt16)i );
346 : }
347 : else
348 : {
349 1653 : PopupMenu* pPopupMenu = m_pMenu->GetPopupMenu( m_pMenu->GetItemId( (sal_uInt16)i ) );
350 1653 : if ( pPopupMenu )
351 : {
352 256 : pChild = new VCLXAccessibleMenu( m_pMenu, (sal_uInt16)i, pPopupMenu );
353 256 : pPopupMenu->SetAccessible( pChild );
354 : }
355 : else
356 : {
357 1397 : pChild = new VCLXAccessibleMenuItem( m_pMenu, (sal_uInt16)i );
358 : }
359 : }
360 :
361 : // set states
362 1924 : pChild->SetStates();
363 :
364 1924 : xChild = pChild;
365 :
366 : // insert into menu item list
367 1924 : m_aAccessibleChildren[i] = xChild;
368 : }
369 : }
370 :
371 3632 : return xChild;
372 : }
373 :
374 : // -----------------------------------------------------------------------------
375 :
376 40 : Reference< XAccessible > OAccessibleMenuBaseComponent::GetChildAt( const awt::Point& rPoint )
377 : {
378 40 : Reference< XAccessible > xChild;
379 653 : for ( sal_uInt32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
380 : {
381 633 : Reference< XAccessible > xAcc = getAccessibleChild( i );
382 633 : if ( xAcc.is() )
383 : {
384 633 : Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
385 633 : if ( xComp.is() )
386 : {
387 633 : Rectangle aRect = VCLRectangle( xComp->getBounds() );
388 633 : Point aPos = VCLPoint( rPoint );
389 633 : if ( aRect.IsInside( aPos ) )
390 : {
391 20 : xChild = xAcc;
392 20 : break;
393 : }
394 613 : }
395 : }
396 613 : }
397 :
398 40 : return xChild;
399 : }
400 :
401 : // -----------------------------------------------------------------------------
402 :
403 57 : void OAccessibleMenuBaseComponent::InsertChild( sal_Int32 i )
404 : {
405 57 : if ( i > (sal_Int32)m_aAccessibleChildren.size() )
406 0 : i = m_aAccessibleChildren.size();
407 :
408 57 : if ( i >= 0 )
409 : {
410 : // insert entry in child list
411 57 : m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() );
412 :
413 : // update item position of accessible children
414 1011 : for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j )
415 : {
416 954 : Reference< XAccessible > xAcc( m_aAccessibleChildren[j] );
417 954 : if ( xAcc.is() )
418 : {
419 753 : OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() );
420 753 : if ( pComp )
421 753 : pComp->SetItemPos( (sal_uInt16)j );
422 : }
423 954 : }
424 :
425 : // send accessible child event
426 57 : Reference< XAccessible > xChild( GetChild( i ) );
427 57 : if ( xChild.is() )
428 : {
429 114 : Any aOldValue, aNewValue;
430 57 : aNewValue <<= xChild;
431 114 : NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
432 57 : }
433 : }
434 57 : }
435 :
436 : // -----------------------------------------------------------------------------
437 :
438 57 : void OAccessibleMenuBaseComponent::RemoveChild( sal_Int32 i )
439 : {
440 57 : if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
441 : {
442 : // keep the accessible of the removed item
443 57 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
444 :
445 : // remove entry in child list
446 57 : m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
447 :
448 : // update item position of accessible children
449 954 : for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j )
450 : {
451 897 : Reference< XAccessible > xAcc( m_aAccessibleChildren[j] );
452 897 : if ( xAcc.is() )
453 : {
454 753 : OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() );
455 753 : if ( pComp )
456 753 : pComp->SetItemPos( (sal_uInt16)j );
457 : }
458 897 : }
459 :
460 : // send accessible child event
461 57 : if ( xChild.is() )
462 : {
463 94 : Any aOldValue, aNewValue;
464 47 : aOldValue <<= xChild;
465 47 : NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
466 :
467 94 : Reference< XComponent > xComponent( xChild, UNO_QUERY );
468 47 : if ( xComponent.is() )
469 94 : xComponent->dispose();
470 57 : }
471 : }
472 57 : }
473 :
474 : // -----------------------------------------------------------------------------
475 :
476 0 : sal_Bool OAccessibleMenuBaseComponent::IsHighlighted()
477 : {
478 0 : return sal_False;
479 : }
480 :
481 : // -----------------------------------------------------------------------------
482 :
483 0 : sal_Bool OAccessibleMenuBaseComponent::IsChildHighlighted()
484 : {
485 0 : sal_Bool bChildHighlighted = sal_False;
486 :
487 0 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
488 : {
489 0 : Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
490 0 : if ( xChild.is() )
491 : {
492 0 : OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
493 0 : if ( pComp && pComp->IsHighlighted() )
494 : {
495 0 : bChildHighlighted = sal_True;
496 0 : break;
497 : }
498 : }
499 0 : }
500 :
501 0 : return bChildHighlighted;
502 : }
503 :
504 : // -----------------------------------------------------------------------------
505 :
506 0 : void OAccessibleMenuBaseComponent::SelectChild( sal_Int32 i )
507 : {
508 : // open the menu
509 0 : if ( getAccessibleRole() == AccessibleRole::MENU && !IsPopupMenuOpen() )
510 0 : Click();
511 :
512 : // highlight the child
513 0 : if ( m_pMenu )
514 0 : m_pMenu->HighlightItem( (sal_uInt16)i );
515 0 : }
516 :
517 : // -----------------------------------------------------------------------------
518 :
519 0 : void OAccessibleMenuBaseComponent::DeSelectAll()
520 : {
521 0 : if ( m_pMenu )
522 0 : m_pMenu->DeHighlight();
523 0 : }
524 :
525 : // -----------------------------------------------------------------------------
526 :
527 0 : sal_Bool OAccessibleMenuBaseComponent::IsChildSelected( sal_Int32 i )
528 : {
529 0 : sal_Bool bSelected = sal_False;
530 :
531 0 : if ( m_pMenu && m_pMenu->IsHighlighted( (sal_uInt16)i ) )
532 0 : bSelected = sal_True;
533 :
534 0 : return bSelected;
535 : }
536 :
537 : // -----------------------------------------------------------------------------
538 :
539 0 : void OAccessibleMenuBaseComponent::Select()
540 : {
541 0 : }
542 :
543 : // -----------------------------------------------------------------------------
544 :
545 0 : void OAccessibleMenuBaseComponent::DeSelect()
546 : {
547 0 : }
548 :
549 : // -----------------------------------------------------------------------------
550 :
551 0 : void OAccessibleMenuBaseComponent::Click()
552 : {
553 0 : }
554 :
555 : // -----------------------------------------------------------------------------
556 :
557 0 : sal_Bool OAccessibleMenuBaseComponent::IsPopupMenuOpen()
558 : {
559 0 : return sal_False;
560 : }
561 :
562 : // -----------------------------------------------------------------------------
563 :
564 1040 : IMPL_LINK( OAccessibleMenuBaseComponent, MenuEventListener, VclSimpleEvent*, pEvent )
565 : {
566 : OSL_ENSURE( pEvent && pEvent->ISA( VclMenuEvent ), "OAccessibleMenuBaseComponent - Unknown MenuEvent!" );
567 520 : if ( pEvent && pEvent->ISA( VclMenuEvent ) )
568 : {
569 : OSL_ENSURE( ((VclMenuEvent*)pEvent)->GetMenu(), "OAccessibleMenuBaseComponent - Menu?" );
570 520 : ProcessMenuEvent( *(VclMenuEvent*)pEvent );
571 : }
572 520 : return 0;
573 : }
574 :
575 : // -----------------------------------------------------------------------------
576 :
577 520 : void OAccessibleMenuBaseComponent::ProcessMenuEvent( const VclMenuEvent& rVclMenuEvent )
578 : {
579 520 : sal_uInt16 nItemPos = rVclMenuEvent.GetItemPos();
580 :
581 520 : switch ( rVclMenuEvent.GetId() )
582 : {
583 : case VCLEVENT_MENU_SHOW:
584 : case VCLEVENT_MENU_HIDE:
585 : {
586 32 : UpdateVisible();
587 : }
588 32 : break;
589 : case VCLEVENT_MENU_HIGHLIGHT:
590 : {
591 26 : SetFocused( sal_False );
592 26 : UpdateFocused( nItemPos, sal_True );
593 26 : UpdateSelected( nItemPos, sal_True );
594 : }
595 26 : break;
596 : case VCLEVENT_MENU_DEHIGHLIGHT:
597 : {
598 8 : UpdateFocused( nItemPos, sal_False );
599 8 : UpdateSelected( nItemPos, sal_False );
600 : }
601 8 : break;
602 : case VCLEVENT_MENU_SUBMENUACTIVATE:
603 : {
604 : }
605 8 : break;
606 : case VCLEVENT_MENU_SUBMENUDEACTIVATE:
607 : {
608 8 : UpdateFocused( nItemPos, sal_True );
609 : }
610 8 : break;
611 : case VCLEVENT_MENU_ENABLE:
612 : {
613 1 : UpdateEnabled( nItemPos, sal_True );
614 : }
615 1 : break;
616 : case VCLEVENT_MENU_DISABLE:
617 : {
618 31 : UpdateEnabled( nItemPos, sal_False );
619 : }
620 31 : break;
621 : case VCLEVENT_MENU_SUBMENUCHANGED:
622 : {
623 57 : RemoveChild( nItemPos );
624 57 : InsertChild( nItemPos );
625 : }
626 57 : break;
627 : case VCLEVENT_MENU_INSERTITEM:
628 : {
629 0 : InsertChild( nItemPos );
630 : }
631 0 : break;
632 : case VCLEVENT_MENU_REMOVEITEM:
633 : {
634 0 : RemoveChild( nItemPos );
635 : }
636 0 : break;
637 : case VCLEVENT_MENU_ACCESSIBLENAMECHANGED:
638 : {
639 0 : UpdateAccessibleName( nItemPos );
640 : }
641 0 : break;
642 : case VCLEVENT_MENU_ITEMTEXTCHANGED:
643 : {
644 67 : UpdateAccessibleName( nItemPos );
645 67 : UpdateItemText( nItemPos );
646 : }
647 67 : break;
648 : case VCLEVENT_MENU_ITEMCHECKED:
649 : {
650 6 : UpdateChecked( nItemPos, sal_True );
651 : }
652 6 : break;
653 : case VCLEVENT_MENU_ITEMUNCHECKED:
654 : {
655 0 : UpdateChecked( nItemPos, sal_False );
656 : }
657 0 : break;
658 : case VCLEVENT_OBJECT_DYING:
659 : {
660 234 : if ( m_pMenu )
661 : {
662 234 : m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
663 :
664 234 : m_pMenu = NULL;
665 :
666 : // dispose all menu items
667 2559 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
668 : {
669 2325 : Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
670 2325 : if ( xComponent.is() )
671 1877 : xComponent->dispose();
672 2325 : }
673 234 : m_aAccessibleChildren.clear();
674 : }
675 : }
676 234 : break;
677 : default:
678 : {
679 : }
680 42 : break;
681 : }
682 520 : }
683 :
684 : // -----------------------------------------------------------------------------
685 : // XInterface
686 : // -----------------------------------------------------------------------------
687 :
688 92602 : IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleMenuBaseComponent, AccessibleExtendedComponentHelper_BASE, OAccessibleMenuBaseComponent_BASE )
689 :
690 : // -----------------------------------------------------------------------------
691 : // XTypeProvider
692 : // -----------------------------------------------------------------------------
693 :
694 0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleMenuBaseComponent, AccessibleExtendedComponentHelper_BASE, OAccessibleMenuBaseComponent_BASE )
695 :
696 : // -----------------------------------------------------------------------------
697 : // XComponent
698 : // -----------------------------------------------------------------------------
699 :
700 1949 : void OAccessibleMenuBaseComponent::disposing()
701 : {
702 1949 : AccessibleExtendedComponentHelper_BASE::disposing();
703 :
704 1949 : if ( m_pMenu )
705 : {
706 47 : m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
707 :
708 47 : m_pMenu = NULL;
709 :
710 : // dispose all menu items
711 73 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
712 : {
713 26 : Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
714 26 : if ( xComponent.is() )
715 0 : xComponent->dispose();
716 26 : }
717 47 : m_aAccessibleChildren.clear();
718 : }
719 1949 : }
720 :
721 : // -----------------------------------------------------------------------------
722 : // XServiceInfo
723 : // -----------------------------------------------------------------------------
724 :
725 0 : sal_Bool OAccessibleMenuBaseComponent::supportsService( const OUString& rServiceName ) throw (RuntimeException)
726 : {
727 0 : return cppu::supportsService(this, rServiceName);
728 : }
729 :
730 : // -----------------------------------------------------------------------------
731 : // XAccessible
732 : // -----------------------------------------------------------------------------
733 :
734 5998 : Reference< XAccessibleContext > OAccessibleMenuBaseComponent::getAccessibleContext( ) throw (RuntimeException)
735 : {
736 5998 : OExternalLockGuard aGuard( this );
737 :
738 5998 : return this;
739 : }
740 :
741 : // -----------------------------------------------------------------------------
742 : // XAccessibleContext
743 : // -----------------------------------------------------------------------------
744 :
745 2199 : Reference< XAccessibleStateSet > OAccessibleMenuBaseComponent::getAccessibleStateSet( ) throw (RuntimeException)
746 : {
747 2199 : OExternalLockGuard aGuard( this );
748 :
749 2199 : utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
750 2199 : Reference< XAccessibleStateSet > xSet = pStateSetHelper;
751 :
752 2199 : if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
753 : {
754 2199 : FillAccessibleStateSet( *pStateSetHelper );
755 : }
756 : else
757 : {
758 0 : pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
759 : }
760 :
761 2199 : return xSet;
762 30 : }
763 :
764 : // -----------------------------------------------------------------------------
765 :
766 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|