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