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 :
21 : #include <accessibledialogwindow.hxx>
22 : #include <accessibledialogcontrolshape.hxx>
23 : #include <baside3.hxx>
24 : #include <dlged.hxx>
25 : #include <dlgedmod.hxx>
26 : #include <dlgedpage.hxx>
27 : #include <dlgedview.hxx>
28 : #include <dlgedobj.hxx>
29 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
30 : #include <com/sun/star/accessibility/AccessibleRole.hpp>
31 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
32 : #include <unotools/accessiblestatesethelper.hxx>
33 : #include <unotools/accessiblerelationsethelper.hxx>
34 : #include <toolkit/awt/vclxfont.hxx>
35 : #include <toolkit/helper/externallock.hxx>
36 : #include <toolkit/helper/convert.hxx>
37 : #include <vcl/svapp.hxx>
38 :
39 : namespace basctl
40 : {
41 :
42 : using namespace ::com::sun::star;
43 : using namespace ::com::sun::star::uno;
44 : using namespace ::com::sun::star::lang;
45 : using namespace ::com::sun::star::accessibility;
46 : using namespace ::comphelper;
47 :
48 : DBG_NAME( AccessibleDialogWindow )
49 :
50 :
51 : // -----------------------------------------------------------------------------
52 : // class ChildDescriptor
53 : // -----------------------------------------------------------------------------
54 :
55 0 : AccessibleDialogWindow::ChildDescriptor::ChildDescriptor( DlgEdObj* _pDlgEdObj )
56 : :pDlgEdObj( _pDlgEdObj )
57 0 : ,rxAccessible( 0 )
58 : {
59 0 : }
60 :
61 : // -----------------------------------------------------------------------------
62 :
63 0 : AccessibleDialogWindow::ChildDescriptor::~ChildDescriptor()
64 : {
65 0 : }
66 :
67 : // -----------------------------------------------------------------------------
68 :
69 0 : AccessibleDialogWindow::ChildDescriptor::ChildDescriptor( const ChildDescriptor& rDesc )
70 : :pDlgEdObj( rDesc.pDlgEdObj )
71 0 : ,rxAccessible( rDesc.rxAccessible )
72 : {
73 0 : }
74 :
75 : // -----------------------------------------------------------------------------
76 :
77 0 : AccessibleDialogWindow::ChildDescriptor& AccessibleDialogWindow::ChildDescriptor::operator=( const ChildDescriptor& rDesc )
78 : {
79 0 : pDlgEdObj = rDesc.pDlgEdObj;
80 0 : rxAccessible = rDesc.rxAccessible;
81 :
82 0 : return *this;
83 : }
84 :
85 : // -----------------------------------------------------------------------------
86 :
87 0 : bool AccessibleDialogWindow::ChildDescriptor::operator==( const ChildDescriptor& rDesc )
88 : {
89 0 : bool bRet = false;
90 0 : if ( pDlgEdObj == rDesc.pDlgEdObj )
91 0 : bRet = true;
92 :
93 0 : return bRet;
94 : }
95 :
96 : // -----------------------------------------------------------------------------
97 :
98 0 : bool AccessibleDialogWindow::ChildDescriptor::operator<( const ChildDescriptor& rDesc ) const
99 : {
100 0 : bool bRet = false;
101 0 : if ( pDlgEdObj && rDesc.pDlgEdObj && pDlgEdObj->GetOrdNum() < rDesc.pDlgEdObj->GetOrdNum() )
102 0 : bRet = true;
103 :
104 0 : return bRet;
105 : }
106 :
107 : // -----------------------------------------------------------------------------
108 : // class AccessibleDialogWindow
109 : // -----------------------------------------------------------------------------
110 :
111 0 : AccessibleDialogWindow::AccessibleDialogWindow (basctl::DialogWindow* pDialogWindow)
112 : :AccessibleExtendedComponentHelper_BASE( new VCLExternalSolarLock() )
113 0 : ,m_pDialogWindow( pDialogWindow )
114 : {
115 : DBG_CTOR( AccessibleDialogWindow, NULL );
116 0 : m_pExternalLock = static_cast< VCLExternalSolarLock* >( getExternalLock() );
117 :
118 0 : if ( m_pDialogWindow )
119 : {
120 0 : SdrPage& rPage = m_pDialogWindow->GetPage();
121 0 : sal_uLong nCount = rPage.GetObjCount();
122 :
123 0 : for ( sal_uLong i = 0; i < nCount; ++i )
124 : {
125 0 : if (DlgEdObj* pDlgEdObj = dynamic_cast<DlgEdObj*>(rPage.GetObj(i)))
126 : {
127 0 : ChildDescriptor aDesc( pDlgEdObj );
128 0 : if ( IsChildVisible( aDesc ) )
129 0 : m_aAccessibleChildren.push_back( aDesc );
130 : }
131 : }
132 :
133 0 : m_pDialogWindow->AddEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
134 :
135 0 : StartListening(m_pDialogWindow->GetEditor());
136 :
137 0 : m_pDlgEdModel = &m_pDialogWindow->GetModel();
138 0 : StartListening(*m_pDlgEdModel);
139 : }
140 0 : }
141 :
142 : // -----------------------------------------------------------------------------
143 :
144 0 : AccessibleDialogWindow::~AccessibleDialogWindow()
145 : {
146 : DBG_DTOR( AccessibleDialogWindow, NULL );
147 0 : if ( m_pDialogWindow )
148 0 : m_pDialogWindow->RemoveEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
149 :
150 0 : if ( m_pDlgEditor )
151 0 : EndListening( *m_pDlgEditor );
152 :
153 0 : if ( m_pDlgEdModel )
154 0 : EndListening( *m_pDlgEdModel );
155 :
156 0 : delete m_pExternalLock;
157 0 : m_pExternalLock = NULL;
158 0 : }
159 :
160 : // -----------------------------------------------------------------------------
161 :
162 0 : void AccessibleDialogWindow::UpdateFocused()
163 : {
164 0 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
165 : {
166 0 : Reference< XAccessible > xChild( m_aAccessibleChildren[i].rxAccessible );
167 0 : if ( xChild.is() )
168 : {
169 0 : AccessibleDialogControlShape* pShape = static_cast< AccessibleDialogControlShape* >( xChild.get() );
170 0 : if ( pShape )
171 0 : pShape->SetFocused( pShape->IsFocused() );
172 : }
173 0 : }
174 0 : }
175 :
176 : // -----------------------------------------------------------------------------
177 :
178 0 : void AccessibleDialogWindow::UpdateSelected()
179 : {
180 0 : NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
181 :
182 0 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
183 : {
184 0 : Reference< XAccessible > xChild( m_aAccessibleChildren[i].rxAccessible );
185 0 : if ( xChild.is() )
186 : {
187 0 : AccessibleDialogControlShape* pShape = static_cast< AccessibleDialogControlShape* >( xChild.get() );
188 0 : if ( pShape )
189 0 : pShape->SetSelected( pShape->IsSelected() );
190 : }
191 0 : }
192 0 : }
193 :
194 : // -----------------------------------------------------------------------------
195 :
196 0 : void AccessibleDialogWindow::UpdateBounds()
197 : {
198 0 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
199 : {
200 0 : Reference< XAccessible > xChild( m_aAccessibleChildren[i].rxAccessible );
201 0 : if ( xChild.is() )
202 : {
203 0 : AccessibleDialogControlShape* pShape = static_cast< AccessibleDialogControlShape* >( xChild.get() );
204 0 : if ( pShape )
205 0 : pShape->SetBounds( pShape->GetBounds() );
206 : }
207 0 : }
208 0 : }
209 :
210 : // -----------------------------------------------------------------------------
211 :
212 0 : bool AccessibleDialogWindow::IsChildVisible( const ChildDescriptor& rDesc )
213 : {
214 0 : bool bVisible = false;
215 :
216 0 : if ( m_pDialogWindow )
217 : {
218 : // first check, if the shape is in a visible layer
219 0 : SdrLayerAdmin& rLayerAdmin = m_pDialogWindow->GetModel().GetLayerAdmin();
220 0 : DlgEdObj* pDlgEdObj = rDesc.pDlgEdObj;
221 0 : if ( pDlgEdObj )
222 : {
223 0 : SdrLayerID nLayerId = pDlgEdObj->GetLayer();
224 0 : const SdrLayer* pSdrLayer = rLayerAdmin.GetLayerPerID( nLayerId );
225 0 : if ( pSdrLayer )
226 : {
227 0 : OUString aLayerName = pSdrLayer->GetName();
228 0 : SdrView& rView = m_pDialogWindow->GetView();
229 0 : if (rView.IsLayerVisible(aLayerName))
230 : {
231 : // get the bounding box of the shape in logic units
232 0 : Rectangle aRect = pDlgEdObj->GetSnapRect();
233 :
234 : // transform coordinates relative to the parent
235 0 : MapMode aMap = m_pDialogWindow->GetMapMode();
236 0 : Point aOrg = aMap.GetOrigin();
237 0 : aRect.Move( aOrg.X(), aOrg.Y() );
238 :
239 : // convert logic units to pixel
240 0 : aRect = m_pDialogWindow->LogicToPixel( aRect, MapMode(MAP_100TH_MM) );
241 :
242 : // check, if the shape's bounding box intersects with the bounding box of its parent
243 0 : Rectangle aParentRect( Point( 0, 0 ), m_pDialogWindow->GetSizePixel() );
244 0 : if ( aParentRect.IsOver( aRect ) )
245 0 : bVisible = true;
246 0 : }
247 : }
248 : }
249 : }
250 :
251 0 : return bVisible;
252 : }
253 :
254 : // -----------------------------------------------------------------------------
255 :
256 0 : void AccessibleDialogWindow::InsertChild( const ChildDescriptor& rDesc )
257 : {
258 : // check, if object is already in child list
259 0 : AccessibleChildren::iterator aIter = ::std::find( m_aAccessibleChildren.begin(), m_aAccessibleChildren.end(), rDesc );
260 :
261 : // if not found, insert in child list
262 0 : if ( aIter == m_aAccessibleChildren.end() )
263 : {
264 : // insert entry in child list
265 0 : m_aAccessibleChildren.push_back( rDesc );
266 :
267 : // get the accessible of the inserted child
268 0 : Reference< XAccessible > xChild( getAccessibleChild( m_aAccessibleChildren.size() - 1 ) );
269 :
270 : // sort child list
271 0 : SortChildren();
272 :
273 : // send accessible child event
274 0 : if ( xChild.is() )
275 : {
276 0 : Any aOldValue, aNewValue;
277 0 : aNewValue <<= xChild;
278 0 : NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
279 0 : }
280 : }
281 0 : }
282 :
283 : // -----------------------------------------------------------------------------
284 :
285 0 : void AccessibleDialogWindow::RemoveChild( const ChildDescriptor& rDesc )
286 : {
287 : // find object in child list
288 0 : AccessibleChildren::iterator aIter = ::std::find( m_aAccessibleChildren.begin(), m_aAccessibleChildren.end(), rDesc );
289 :
290 : // if found, remove from child list
291 0 : if ( aIter != m_aAccessibleChildren.end() )
292 : {
293 : // get the accessible of the removed child
294 0 : Reference< XAccessible > xChild( aIter->rxAccessible );
295 :
296 : // remove entry from child list
297 0 : m_aAccessibleChildren.erase( aIter );
298 :
299 : // send accessible child event
300 0 : if ( xChild.is() )
301 : {
302 0 : Any aOldValue, aNewValue;
303 0 : aOldValue <<= xChild;
304 0 : NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
305 :
306 0 : Reference< XComponent > xComponent( xChild, UNO_QUERY );
307 0 : if ( xComponent.is() )
308 0 : xComponent->dispose();
309 0 : }
310 : }
311 0 : }
312 :
313 : // -----------------------------------------------------------------------------
314 :
315 0 : void AccessibleDialogWindow::UpdateChild( const ChildDescriptor& rDesc )
316 : {
317 0 : if ( IsChildVisible( rDesc ) )
318 : {
319 : // if the object is not in the child list, insert child
320 0 : InsertChild( rDesc );
321 : }
322 : else
323 : {
324 : // if the object is in the child list, remove child
325 0 : RemoveChild( rDesc );
326 : }
327 0 : }
328 :
329 : // -----------------------------------------------------------------------------
330 :
331 0 : void AccessibleDialogWindow::UpdateChildren()
332 : {
333 0 : if ( m_pDialogWindow )
334 : {
335 0 : SdrPage& rPage = m_pDialogWindow->GetPage();
336 0 : for ( sal_uLong i = 0, nCount = rPage.GetObjCount(); i < nCount; ++i )
337 0 : if (DlgEdObj* pDlgEdObj = dynamic_cast<DlgEdObj*>(rPage.GetObj(i)))
338 0 : UpdateChild( ChildDescriptor( pDlgEdObj ) );
339 : }
340 0 : }
341 :
342 : // -----------------------------------------------------------------------------
343 :
344 0 : void AccessibleDialogWindow::SortChildren()
345 : {
346 : // sort child list
347 0 : ::std::sort( m_aAccessibleChildren.begin(), m_aAccessibleChildren.end() );
348 0 : }
349 :
350 : // -----------------------------------------------------------------------------
351 :
352 0 : IMPL_LINK( AccessibleDialogWindow, WindowEventListener, VclSimpleEvent*, pEvent )
353 : {
354 : DBG_CHKTHIS( AccessibleDialogWindow, 0 );
355 :
356 0 : if (VclWindowEvent* pWinEvent = dynamic_cast<VclWindowEvent*>(pEvent))
357 : {
358 : DBG_ASSERT(pWinEvent->GetWindow(), "AccessibleDialogWindow::WindowEventListener: no window!");
359 0 : if (!pWinEvent->GetWindow()->IsAccessibilityEventsSuppressed() || pEvent->GetId() == VCLEVENT_OBJECT_DYING)
360 0 : ProcessWindowEvent(*pWinEvent);
361 : }
362 : else
363 : DBG_ASSERT(false, "AccessibleDialogWindow::WindowEventListener: unknown window event!");
364 0 : return 0;
365 : }
366 :
367 : // -----------------------------------------------------------------------------
368 :
369 0 : void AccessibleDialogWindow::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
370 : {
371 0 : Any aOldValue, aNewValue;
372 :
373 0 : switch ( rVclWindowEvent.GetId() )
374 : {
375 : case VCLEVENT_WINDOW_ENABLED:
376 : {
377 0 : aNewValue <<= AccessibleStateType::ENABLED;
378 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
379 : }
380 0 : break;
381 : case VCLEVENT_WINDOW_DISABLED:
382 : {
383 0 : aOldValue <<= AccessibleStateType::ENABLED;
384 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
385 : }
386 0 : break;
387 : case VCLEVENT_WINDOW_ACTIVATE:
388 : {
389 0 : aNewValue <<= AccessibleStateType::ACTIVE;
390 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
391 : }
392 0 : break;
393 : case VCLEVENT_WINDOW_DEACTIVATE:
394 : {
395 0 : aOldValue <<= AccessibleStateType::ACTIVE;
396 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
397 : }
398 0 : break;
399 : case VCLEVENT_WINDOW_GETFOCUS:
400 : {
401 0 : aNewValue <<= AccessibleStateType::FOCUSED;
402 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
403 : }
404 0 : break;
405 : case VCLEVENT_WINDOW_LOSEFOCUS:
406 : {
407 0 : aOldValue <<= AccessibleStateType::FOCUSED;
408 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
409 : }
410 0 : break;
411 : case VCLEVENT_WINDOW_SHOW:
412 : {
413 0 : aNewValue <<= AccessibleStateType::SHOWING;
414 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
415 : }
416 0 : break;
417 : case VCLEVENT_WINDOW_HIDE:
418 : {
419 0 : aOldValue <<= AccessibleStateType::SHOWING;
420 0 : NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
421 : }
422 0 : break;
423 : case VCLEVENT_WINDOW_RESIZE:
424 : {
425 0 : NotifyAccessibleEvent( AccessibleEventId::BOUNDRECT_CHANGED, aOldValue, aNewValue );
426 0 : UpdateChildren();
427 0 : UpdateBounds();
428 : }
429 0 : break;
430 : case VCLEVENT_OBJECT_DYING:
431 : {
432 0 : if ( m_pDialogWindow )
433 : {
434 0 : m_pDialogWindow->RemoveEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
435 0 : m_pDialogWindow = NULL;
436 :
437 0 : if ( m_pDlgEditor )
438 0 : EndListening( *m_pDlgEditor );
439 0 : m_pDlgEditor = NULL;
440 :
441 0 : if ( m_pDlgEdModel )
442 0 : EndListening( *m_pDlgEdModel );
443 0 : m_pDlgEdModel = NULL;
444 :
445 : // dispose all children
446 0 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
447 : {
448 0 : Reference< XComponent > xComponent( m_aAccessibleChildren[i].rxAccessible, UNO_QUERY );
449 0 : if ( xComponent.is() )
450 0 : xComponent->dispose();
451 0 : }
452 0 : m_aAccessibleChildren.clear();
453 : }
454 : }
455 0 : break;
456 : default:
457 : {
458 : }
459 0 : break;
460 0 : }
461 0 : }
462 :
463 : // -----------------------------------------------------------------------------
464 :
465 0 : void AccessibleDialogWindow::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
466 : {
467 0 : if ( m_pDialogWindow )
468 : {
469 0 : if ( m_pDialogWindow->IsEnabled() )
470 0 : rStateSet.AddState( AccessibleStateType::ENABLED );
471 :
472 0 : rStateSet.AddState( AccessibleStateType::FOCUSABLE );
473 :
474 0 : if ( m_pDialogWindow->HasFocus() )
475 0 : rStateSet.AddState( AccessibleStateType::FOCUSED );
476 :
477 0 : rStateSet.AddState( AccessibleStateType::VISIBLE );
478 :
479 0 : if ( m_pDialogWindow->IsVisible() )
480 0 : rStateSet.AddState( AccessibleStateType::SHOWING );
481 :
482 0 : rStateSet.AddState( AccessibleStateType::OPAQUE );
483 :
484 0 : rStateSet.AddState( AccessibleStateType::RESIZABLE );
485 : }
486 0 : }
487 :
488 : // -----------------------------------------------------------------------------
489 : // OCommonAccessibleComponent
490 : // -----------------------------------------------------------------------------
491 :
492 0 : awt::Rectangle AccessibleDialogWindow::implGetBounds() throw (RuntimeException)
493 : {
494 0 : awt::Rectangle aBounds;
495 0 : if ( m_pDialogWindow )
496 0 : aBounds = AWTRectangle( Rectangle( m_pDialogWindow->GetPosPixel(), m_pDialogWindow->GetSizePixel() ) );
497 :
498 0 : return aBounds;
499 : }
500 :
501 : // -----------------------------------------------------------------------------
502 : // SfxListener
503 : // -----------------------------------------------------------------------------
504 :
505 0 : void AccessibleDialogWindow::Notify( SfxBroadcaster&, const SfxHint& rHint )
506 : {
507 0 : if (SdrHint const* pSdrHint = dynamic_cast<SdrHint const*>(&rHint))
508 : {
509 0 : switch ( pSdrHint->GetKind() )
510 : {
511 : case HINT_OBJINSERTED:
512 : {
513 0 : if (DlgEdObj const* pDlgEdObj = dynamic_cast<DlgEdObj const*>(pSdrHint->GetObject()))
514 : {
515 0 : ChildDescriptor aDesc(const_cast<DlgEdObj*>(pDlgEdObj));
516 0 : if ( IsChildVisible( aDesc ) )
517 0 : InsertChild( aDesc );
518 : }
519 : }
520 0 : break;
521 : case HINT_OBJREMOVED:
522 : {
523 0 : if (DlgEdObj const* pDlgEdObj = dynamic_cast<DlgEdObj const*>(pSdrHint->GetObject()))
524 0 : RemoveChild( ChildDescriptor(const_cast<DlgEdObj*>(pDlgEdObj)) );
525 : }
526 0 : break;
527 : default: ;
528 : }
529 : }
530 0 : else if (DlgEdHint const* pDlgEdHint = dynamic_cast<DlgEdHint const*>(&rHint))
531 : {
532 0 : switch (pDlgEdHint->GetKind())
533 : {
534 : case DlgEdHint::WINDOWSCROLLED:
535 : {
536 0 : UpdateChildren();
537 0 : UpdateBounds();
538 : }
539 0 : break;
540 : case DlgEdHint::LAYERCHANGED:
541 : {
542 0 : if (DlgEdObj* pDlgEdObj = pDlgEdHint->GetObject())
543 0 : UpdateChild( ChildDescriptor( pDlgEdObj ) );
544 : }
545 0 : break;
546 : case DlgEdHint::OBJORDERCHANGED:
547 : {
548 0 : SortChildren();
549 : }
550 0 : break;
551 : case DlgEdHint::SELECTIONCHANGED:
552 : {
553 0 : UpdateFocused();
554 0 : UpdateSelected();
555 : }
556 0 : break;
557 : default: ;
558 : }
559 : }
560 0 : }
561 :
562 : // -----------------------------------------------------------------------------
563 : // XInterface
564 : // -----------------------------------------------------------------------------
565 :
566 0 : IMPLEMENT_FORWARD_XINTERFACE2( AccessibleDialogWindow, AccessibleExtendedComponentHelper_BASE, AccessibleDialogWindow_BASE )
567 :
568 : // -----------------------------------------------------------------------------
569 : // XTypeProvider
570 : // -----------------------------------------------------------------------------
571 :
572 0 : IMPLEMENT_FORWARD_XTYPEPROVIDER2( AccessibleDialogWindow, AccessibleExtendedComponentHelper_BASE, AccessibleDialogWindow_BASE )
573 :
574 : // -----------------------------------------------------------------------------
575 : // XComponent
576 : // -----------------------------------------------------------------------------
577 :
578 0 : void AccessibleDialogWindow::disposing()
579 : {
580 0 : AccessibleExtendedComponentHelper_BASE::disposing();
581 :
582 0 : if ( m_pDialogWindow )
583 : {
584 0 : m_pDialogWindow->RemoveEventListener( LINK( this, AccessibleDialogWindow, WindowEventListener ) );
585 0 : m_pDialogWindow = NULL;
586 :
587 0 : if ( m_pDlgEditor )
588 0 : EndListening( *m_pDlgEditor );
589 0 : m_pDlgEditor = NULL;
590 :
591 0 : if ( m_pDlgEdModel )
592 0 : EndListening( *m_pDlgEdModel );
593 0 : m_pDlgEdModel = NULL;
594 :
595 : // dispose all children
596 0 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
597 : {
598 0 : Reference< XComponent > xComponent( m_aAccessibleChildren[i].rxAccessible, UNO_QUERY );
599 0 : if ( xComponent.is() )
600 0 : xComponent->dispose();
601 0 : }
602 0 : m_aAccessibleChildren.clear();
603 : }
604 0 : }
605 :
606 : // -----------------------------------------------------------------------------
607 : // XServiceInfo
608 : // -----------------------------------------------------------------------------
609 :
610 0 : OUString AccessibleDialogWindow::getImplementationName() throw (RuntimeException)
611 : {
612 0 : return OUString( "com.sun.star.comp.basctl.AccessibleWindow" );
613 : }
614 :
615 : // -----------------------------------------------------------------------------
616 :
617 0 : sal_Bool AccessibleDialogWindow::supportsService( const OUString& rServiceName ) throw (RuntimeException)
618 : {
619 0 : Sequence< OUString > aNames( getSupportedServiceNames() );
620 0 : const OUString* pNames = aNames.getConstArray();
621 0 : const OUString* pEnd = pNames + aNames.getLength();
622 0 : for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
623 : ;
624 :
625 0 : return pNames != pEnd;
626 : }
627 :
628 : // -----------------------------------------------------------------------------
629 :
630 0 : Sequence< OUString > AccessibleDialogWindow::getSupportedServiceNames() throw (RuntimeException)
631 : {
632 0 : Sequence< OUString > aNames(1);
633 0 : aNames[0] = "com.sun.star.awt.AccessibleWindow" ;
634 0 : return aNames;
635 : }
636 :
637 : // -----------------------------------------------------------------------------
638 : // XAccessible
639 : // -----------------------------------------------------------------------------
640 :
641 0 : Reference< XAccessibleContext > AccessibleDialogWindow::getAccessibleContext( ) throw (RuntimeException)
642 : {
643 0 : OExternalLockGuard aGuard( this );
644 :
645 0 : return this;
646 : }
647 :
648 : // -----------------------------------------------------------------------------
649 : // XAccessibleContext
650 : // -----------------------------------------------------------------------------
651 :
652 0 : sal_Int32 AccessibleDialogWindow::getAccessibleChildCount() throw (RuntimeException)
653 : {
654 0 : OExternalLockGuard aGuard( this );
655 :
656 0 : return m_aAccessibleChildren.size();
657 : }
658 :
659 : // -----------------------------------------------------------------------------
660 :
661 0 : Reference< XAccessible > AccessibleDialogWindow::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
662 : {
663 0 : OExternalLockGuard aGuard( this );
664 :
665 0 : if ( i < 0 || i >= getAccessibleChildCount() )
666 0 : throw IndexOutOfBoundsException();
667 :
668 0 : Reference< XAccessible > xChild = m_aAccessibleChildren[i].rxAccessible;
669 0 : if ( !xChild.is() )
670 : {
671 0 : if ( m_pDialogWindow )
672 : {
673 0 : DlgEdObj* pDlgEdObj = m_aAccessibleChildren[i].pDlgEdObj;
674 0 : if ( pDlgEdObj )
675 : {
676 0 : xChild = new AccessibleDialogControlShape( m_pDialogWindow, pDlgEdObj );
677 :
678 : // insert into child list
679 0 : m_aAccessibleChildren[i].rxAccessible = xChild;
680 : }
681 : }
682 : }
683 :
684 0 : return xChild;
685 : }
686 :
687 : // -----------------------------------------------------------------------------
688 :
689 0 : Reference< XAccessible > AccessibleDialogWindow::getAccessibleParent( ) throw (RuntimeException)
690 : {
691 0 : OExternalLockGuard aGuard( this );
692 :
693 0 : Reference< XAccessible > xParent;
694 0 : if ( m_pDialogWindow )
695 : {
696 0 : Window* pParent = m_pDialogWindow->GetAccessibleParentWindow();
697 0 : if ( pParent )
698 0 : xParent = pParent->GetAccessible();
699 : }
700 :
701 0 : return xParent;
702 : }
703 :
704 : // -----------------------------------------------------------------------------
705 :
706 0 : sal_Int32 AccessibleDialogWindow::getAccessibleIndexInParent( ) throw (RuntimeException)
707 : {
708 0 : OExternalLockGuard aGuard( this );
709 :
710 0 : sal_Int32 nIndexInParent = -1;
711 0 : if ( m_pDialogWindow )
712 : {
713 0 : Window* pParent = m_pDialogWindow->GetAccessibleParentWindow();
714 0 : if ( pParent )
715 : {
716 0 : for ( sal_uInt16 i = 0, nCount = pParent->GetAccessibleChildWindowCount(); i < nCount; ++i )
717 : {
718 0 : Window* pChild = pParent->GetAccessibleChildWindow( i );
719 0 : if ( pChild == static_cast< Window* >( m_pDialogWindow ) )
720 : {
721 0 : nIndexInParent = i;
722 0 : break;
723 : }
724 : }
725 : }
726 : }
727 :
728 0 : return nIndexInParent;
729 : }
730 :
731 : // -----------------------------------------------------------------------------
732 :
733 0 : sal_Int16 AccessibleDialogWindow::getAccessibleRole( ) throw (RuntimeException)
734 : {
735 0 : OExternalLockGuard aGuard( this );
736 :
737 0 : return AccessibleRole::PANEL;
738 : }
739 :
740 : // -----------------------------------------------------------------------------
741 :
742 0 : OUString AccessibleDialogWindow::getAccessibleDescription( ) throw (RuntimeException)
743 : {
744 0 : OExternalLockGuard aGuard( this );
745 :
746 0 : OUString sDescription;
747 0 : if ( m_pDialogWindow )
748 0 : sDescription = m_pDialogWindow->GetAccessibleDescription();
749 :
750 0 : return sDescription;
751 : }
752 :
753 : // -----------------------------------------------------------------------------
754 :
755 0 : OUString AccessibleDialogWindow::getAccessibleName( ) throw (RuntimeException)
756 : {
757 0 : OExternalLockGuard aGuard( this );
758 :
759 0 : OUString sName;
760 0 : if ( m_pDialogWindow )
761 0 : sName = m_pDialogWindow->GetAccessibleName();
762 :
763 0 : return sName;
764 : }
765 :
766 : // -----------------------------------------------------------------------------
767 :
768 0 : Reference< XAccessibleRelationSet > AccessibleDialogWindow::getAccessibleRelationSet( ) throw (RuntimeException)
769 : {
770 0 : OExternalLockGuard aGuard( this );
771 :
772 0 : utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
773 0 : Reference< XAccessibleRelationSet > xSet = pRelationSetHelper;
774 0 : return xSet;
775 : }
776 :
777 : // -----------------------------------------------------------------------------
778 :
779 0 : Reference< XAccessibleStateSet > AccessibleDialogWindow::getAccessibleStateSet( ) throw (RuntimeException)
780 : {
781 0 : OExternalLockGuard aGuard( this );
782 :
783 0 : utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
784 0 : Reference< XAccessibleStateSet > xSet = pStateSetHelper;
785 :
786 0 : if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
787 : {
788 0 : FillAccessibleStateSet( *pStateSetHelper );
789 : }
790 : else
791 : {
792 0 : pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
793 : }
794 :
795 0 : return xSet;
796 : }
797 :
798 : // -----------------------------------------------------------------------------
799 :
800 0 : Locale AccessibleDialogWindow::getLocale( ) throw (IllegalAccessibleComponentStateException, RuntimeException)
801 : {
802 0 : OExternalLockGuard aGuard( this );
803 :
804 0 : return Application::GetSettings().GetLanguageTag().getLocale();
805 : }
806 :
807 : // -----------------------------------------------------------------------------
808 : // XAccessibleComponent
809 : // -----------------------------------------------------------------------------
810 :
811 0 : Reference< XAccessible > AccessibleDialogWindow::getAccessibleAtPoint( const awt::Point& rPoint ) throw (RuntimeException)
812 : {
813 0 : OExternalLockGuard aGuard( this );
814 :
815 0 : Reference< XAccessible > xChild;
816 0 : for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
817 : {
818 0 : Reference< XAccessible > xAcc = getAccessibleChild( i );
819 0 : if ( xAcc.is() )
820 : {
821 0 : Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
822 0 : if ( xComp.is() )
823 : {
824 0 : Rectangle aRect = VCLRectangle( xComp->getBounds() );
825 0 : Point aPos = VCLPoint( rPoint );
826 0 : if ( aRect.IsInside( aPos ) )
827 : {
828 0 : xChild = xAcc;
829 : break;
830 : }
831 0 : }
832 : }
833 0 : }
834 :
835 0 : return xChild;
836 : }
837 :
838 : // -----------------------------------------------------------------------------
839 :
840 0 : void AccessibleDialogWindow::grabFocus( ) throw (RuntimeException)
841 : {
842 0 : OExternalLockGuard aGuard( this );
843 :
844 0 : if ( m_pDialogWindow )
845 0 : m_pDialogWindow->GrabFocus();
846 0 : }
847 :
848 : // -----------------------------------------------------------------------------
849 :
850 0 : sal_Int32 AccessibleDialogWindow::getForeground( ) throw (RuntimeException)
851 : {
852 0 : OExternalLockGuard aGuard( this );
853 :
854 0 : sal_Int32 nColor = 0;
855 0 : if ( m_pDialogWindow )
856 : {
857 0 : if ( m_pDialogWindow->IsControlForeground() )
858 0 : nColor = m_pDialogWindow->GetControlForeground().GetColor();
859 : else
860 : {
861 0 : Font aFont;
862 0 : if ( m_pDialogWindow->IsControlFont() )
863 0 : aFont = m_pDialogWindow->GetControlFont();
864 : else
865 0 : aFont = m_pDialogWindow->GetFont();
866 0 : nColor = aFont.GetColor().GetColor();
867 : }
868 : }
869 :
870 0 : return nColor;
871 : }
872 :
873 : // -----------------------------------------------------------------------------
874 :
875 0 : sal_Int32 AccessibleDialogWindow::getBackground( ) throw (RuntimeException)
876 : {
877 0 : OExternalLockGuard aGuard( this );
878 :
879 0 : sal_Int32 nColor = 0;
880 0 : if ( m_pDialogWindow )
881 : {
882 0 : if ( m_pDialogWindow->IsControlBackground() )
883 0 : nColor = m_pDialogWindow->GetControlBackground().GetColor();
884 : else
885 0 : nColor = m_pDialogWindow->GetBackground().GetColor().GetColor();
886 : }
887 :
888 0 : return nColor;
889 : }
890 :
891 : // -----------------------------------------------------------------------------
892 : // XAccessibleExtendedComponent
893 : // -----------------------------------------------------------------------------
894 :
895 0 : Reference< awt::XFont > AccessibleDialogWindow::getFont( ) throw (RuntimeException)
896 : {
897 0 : OExternalLockGuard aGuard( this );
898 :
899 0 : Reference< awt::XFont > xFont;
900 0 : if ( m_pDialogWindow )
901 : {
902 0 : Reference< awt::XDevice > xDev( m_pDialogWindow->GetComponentInterface(), UNO_QUERY );
903 0 : if ( xDev.is() )
904 : {
905 0 : Font aFont;
906 0 : if ( m_pDialogWindow->IsControlFont() )
907 0 : aFont = m_pDialogWindow->GetControlFont();
908 : else
909 0 : aFont = m_pDialogWindow->GetFont();
910 0 : VCLXFont* pVCLXFont = new VCLXFont;
911 0 : pVCLXFont->Init( *xDev.get(), aFont );
912 0 : xFont = pVCLXFont;
913 0 : }
914 : }
915 :
916 0 : return xFont;
917 : }
918 :
919 : // -----------------------------------------------------------------------------
920 :
921 0 : OUString AccessibleDialogWindow::getTitledBorderText( ) throw (RuntimeException)
922 : {
923 0 : OExternalLockGuard aGuard( this );
924 :
925 0 : return OUString();
926 : }
927 :
928 : // -----------------------------------------------------------------------------
929 :
930 0 : OUString AccessibleDialogWindow::getToolTipText( ) throw (RuntimeException)
931 : {
932 0 : OExternalLockGuard aGuard( this );
933 :
934 0 : OUString sText;
935 0 : if ( m_pDialogWindow )
936 0 : sText = m_pDialogWindow->GetQuickHelpText();
937 :
938 0 : return sText;
939 : }
940 :
941 : // -----------------------------------------------------------------------------
942 : // XAccessibleSelection
943 : // -----------------------------------------------------------------------------
944 :
945 0 : void AccessibleDialogWindow::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
946 : {
947 0 : OExternalLockGuard aGuard( this );
948 :
949 0 : if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
950 0 : throw IndexOutOfBoundsException();
951 :
952 0 : if ( m_pDialogWindow )
953 : {
954 0 : if (DlgEdObj* pDlgEdObj = m_aAccessibleChildren[nChildIndex].pDlgEdObj)
955 : {
956 0 : SdrView& rView = m_pDialogWindow->GetView();
957 0 : if (SdrPageView* pPgView = rView.GetSdrPageView())
958 0 : rView.MarkObj(pDlgEdObj, pPgView);
959 : }
960 0 : }
961 0 : }
962 :
963 : // -----------------------------------------------------------------------------
964 :
965 0 : sal_Bool AccessibleDialogWindow::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
966 : {
967 0 : OExternalLockGuard aGuard( this );
968 :
969 0 : if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
970 0 : throw IndexOutOfBoundsException();
971 :
972 0 : if (m_pDialogWindow)
973 0 : if (DlgEdObj* pDlgEdObj = m_aAccessibleChildren[nChildIndex].pDlgEdObj)
974 0 : return m_pDialogWindow->GetView().IsObjMarked(pDlgEdObj);
975 0 : return false;
976 : }
977 :
978 : // -----------------------------------------------------------------------------
979 :
980 0 : void AccessibleDialogWindow::clearAccessibleSelection( ) throw (RuntimeException)
981 : {
982 0 : OExternalLockGuard aGuard( this );
983 :
984 0 : if ( m_pDialogWindow )
985 0 : m_pDialogWindow->GetView().UnmarkAll();
986 0 : }
987 :
988 : // -----------------------------------------------------------------------------
989 :
990 0 : void AccessibleDialogWindow::selectAllAccessibleChildren( ) throw (RuntimeException)
991 : {
992 0 : OExternalLockGuard aGuard( this );
993 :
994 0 : if ( m_pDialogWindow )
995 0 : m_pDialogWindow->GetView().MarkAll();
996 0 : }
997 :
998 : // -----------------------------------------------------------------------------
999 :
1000 0 : sal_Int32 AccessibleDialogWindow::getSelectedAccessibleChildCount( ) throw (RuntimeException)
1001 : {
1002 0 : OExternalLockGuard aGuard( this );
1003 :
1004 0 : sal_Int32 nRet = 0;
1005 :
1006 0 : for ( sal_Int32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
1007 : {
1008 0 : if ( isAccessibleChildSelected( i ) )
1009 0 : ++nRet;
1010 : }
1011 :
1012 0 : return nRet;
1013 : }
1014 :
1015 : // -----------------------------------------------------------------------------
1016 :
1017 0 : Reference< XAccessible > AccessibleDialogWindow::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
1018 : {
1019 0 : OExternalLockGuard aGuard( this );
1020 :
1021 0 : if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
1022 0 : throw IndexOutOfBoundsException();
1023 :
1024 0 : Reference< XAccessible > xChild;
1025 :
1026 0 : for ( sal_Int32 i = 0, j = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
1027 : {
1028 0 : if ( isAccessibleChildSelected( i ) && ( j++ == nSelectedChildIndex ) )
1029 : {
1030 0 : xChild = getAccessibleChild( i );
1031 0 : break;
1032 : }
1033 : }
1034 :
1035 0 : return xChild;
1036 : }
1037 :
1038 : // -----------------------------------------------------------------------------
1039 :
1040 0 : void AccessibleDialogWindow::deselectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
1041 : {
1042 0 : OExternalLockGuard aGuard( this );
1043 :
1044 0 : if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
1045 0 : throw IndexOutOfBoundsException();
1046 :
1047 0 : if ( m_pDialogWindow )
1048 : {
1049 0 : if (DlgEdObj* pDlgEdObj = m_aAccessibleChildren[nChildIndex].pDlgEdObj)
1050 : {
1051 0 : SdrView& rView = m_pDialogWindow->GetView();
1052 0 : SdrPageView* pPgView = rView.GetSdrPageView();
1053 0 : if (pPgView)
1054 0 : rView.MarkObj( pDlgEdObj, pPgView, true );
1055 : }
1056 0 : }
1057 0 : }
1058 :
1059 : // -----------------------------------------------------------------------------
1060 :
1061 : } // namespace basctl
1062 :
1063 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
